Matrizes clássicas e vectores em C++ Aula 9 Matrizes clássicas e vectores em C++ Melhor alternativa!

Ler três inteiros e escrevê-los por ordem inversa Como generalizar para 100, por exemplo? #include <iostream> using namespace std; int main() { cout << "Introduza três inteiros: "; int a, b, c; cin >> a >> b >> c; cout << c << endl << b << endl << a << endl; } Para simplificar ignoram-se possíveis erros de extracção! Introdução à Programação 2003/2004

Adaptação para 100 inteiros Basta acrescentar 97 variáveis, obviamente… Introdução à Programação 2003/2004

Ler 100 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << "Introduza 100 inteiros: "; int a1, a2, a3, …, a100; cin >> a1 >> a2 >> a3 >> … >> a100; cout << a100 << endl << a99 << endl … << a1 << endl; } Pouco prático… Introdução à Programação 2003/2004

Ler 100 inteiros e escrevê-los por ordem inversa Matriz de 100 inteiros #include <iostream> using namespace std; int main() { cout << "Introduza 100 inteiros: "; int valores[100]; ? } Introdução à Programação 2003/2004

Introdução à Programação Sintaxe Tipo dos elementos Nome da matriz Número de elementos double m[4]; m[2] = 2.2; double x = m[3]; Indexações Como uma variável Introdução à Programação 2003/2004

Introdução à Programação Organização Índices: 1º elemento: índice 0 2º elemento: índice 1 … nº elemento: índice n-1 double m[4]; m[0]: ? m: double[4] m[1]: m[2]: m[3]: Introdução à Programação 2003/2004

Introdução à Programação Inicialização Com lixo! double m[4]; m: double[4] m[0]: m[1]: m[2]: m[3]: ? ? ? ? Introdução à Programação 2003/2004

Inicialização explícita double m[4] = {0.0, 1.1, 2.2, 3.3}; m[0]: m: double[4] m[1]: 1,1 m[2]: 2,2 m[3]: 3,3 Introdução à Programação 2003/2004

Inicialização implícita (I) double m[4] = {0.0, 1.1}; m[0]: m: double[4] m[1]: 1,1 m[2]: m[3]: Introdução à Programação 2003/2004

Inicialização implícita (II) double m[4] = {}; m[0]: m: double[4] m[1]: m[2]: m[3]: Introdução à Programação 2003/2004

Problemas das matrizes (I) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… Introdução à Programação 2003/2004

Ler 100 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << "Introduza 100 inteiros: "; int valores[100]; cin >> valores[0]; cin >> valores[1]; cin >> valores[2]; … ? } Absurdo! Por extensão não se ganhou nada! Introdução à Programação 2003/2004

Ler 100 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << "Introduza 100 inteiros: "; int valores[100]; for(int i = 0; i != 100; ++i) cin >> valores[i]; ? } Extracção dos 100 inteiros e armazenamento na matriz por compreensão Introdução à Programação 2003/2004

Ler 100 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << "Introduza 100 inteiros: "; int valores[100]; for(int i = 0; i != 100; ++i) cin >> valores[i]; for(int i = 100; i != 0; --i) cout << valores[i - 1] << endl; } Inserção dos 100 inteiros por ordem inversa Introdução à Programação 2003/2004

Ler 100 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << "Introduza 100 inteiros: "; int valores[100]; for(int i = 0; i != 100; ++i) cin >> valores[i]; for(int i = 99; i != -1; --i) cout << valores[i] << endl; } Preferível! Introdução à Programação 2003/2004

Introdução à Programação Elementos fictícios Primeiro elemento Elemento inicial double m[4]; m: double[4] m[-1]: m[0]: m[1]: m[2]: m[3]: m[4]: ? ? ? ? ? Último elemento Elemento final Introdução à Programação 2003/2004

Introdução à Programação Ciclos com matrizes Directo Do primeiro ao elemento final, exclusive Inverso Do último ao elemento inicial, exclusive Introdução à Programação 2003/2004

Adaptação para 1000 inteiros Basta substituir 100 por 1000, obviamente… Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << "Introduza 1000 inteiros: "; int valores[1000]; for(int i = 0; i != 1000; ++i) cin >> valores[i]; for(int i = 99; i != -1; --i) cout << valores[i] << endl; } Ops… Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { int const número_de_valores = 1000; cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; for(int i = 0; i != número_de_valores; ++i) cin >> valores[i]; for(int i = número_de_valores - 1; i != -1; --i) cout << valores[i] << endl; } Constante! Introdução à Programação 2003/2004

Introdução à Programação Generalização (I) E se se pretender generalizar a leitura para qualquer número de inteiros, dado pelo utilizador? Basta usar uma variável, obviamente… Introdução à Programação 2003/2004

Ler inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << “Introduza o número de valores a ler: “; int número_de_valores; cin >> número_de_valores; cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; … } Erro! Tem de ser constante! Introdução à Programação 2003/2004

Ler inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { cout << “Introduza o número de valores a ler: “; int n; cin >> n; int const número_de_valores = n; cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; … } Erro! Tem de ser constante conhecida pelo compilador! Introdução à Programação 2003/2004

Problemas das matrizes (II) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int main() { int const número_de_valores = 1000; cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; for(int i = 0; i != número_de_valores; ++i) cin >> valores[i]; for(int i = número_de_valores - 1; i != -1; --i) cout << valores[i] << endl; } Introdução à Programação 2003/2004

Introdução à Programação Vamos modularizar Leitura dos valores do teclado Escrita invertida dos valores no ecrã Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; … int main() { int const número_de_valores = 1000; cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; // Leitura… escreveInvertida(…); } Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos da matriz passada como argumento começando no último. */ void escreveInvertida(…) { … } Introdução à Programação 2003/2004

Introdução à Programação E a leitura? Procedimento, que altera a matriz recebida, preenchendo-a… …ou função, que devolve uma matriz preenchida? C++ proíbe devolução de matrizes! Mas era má ideia devolver: Leitura afecta estado do programa (cin): procedimento Devolução de valor: função Rotina mista é má ideia! Introdução à Programação 2003/2004

Problemas das matrizes (III) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Não se podem devolver Introdução à Programação 2003/2004

Introdução à Programação lêPara() /** Lê do teclado valores inteiros que coloca por ordem nos elementos da matriz passada como argumento. */ void lêPara(…) { … } Introdução à Programação 2003/2004

Passagem de matriz como argumento lêPara(): passagem por referência escreveInvertida(): passagem por valor Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos da matriz passada como argumento começando no último. @pre V. @post cout.fail()  cout sofreu inserções dos número_de_valores elementos da matriz valores pela sua ordem inversa. */ void escreveInvertida(int valores[número_de_valores]) { … } Introdução à Programação 2003/2004

Introdução à Programação lêPara() /** Lê do teclado valores inteiros que coloca por ordem nos elementos da matriz passada como argumento. @pre cin.good()  cin permite extracção de número_de_valores inteiros sucessivos. @post cin.fail()  cin já não contém os primeiros número_de_valores inteiros que continha inicialmente  a matriz valores contém-nos pela mesma ordem. */ void lêPara(int valores[número_de_valores]) { … } Falta dizer que passagem é por referência! Introdução à Programação 2003/2004

Passagem de matriz como argumento Sempre por referência! Necessário precaver alterações do argumento em escreveInvertida()! Mentira piedosa… Explicação no 2º semestre… (tem a ver com ponteiros) Introdução à Programação 2003/2004

Problemas das matrizes (IV) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Não se podem devolver Passagem sempre por referência (mentirita…) Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos da matriz passada como argumento começando no último. @pre V. @post cout.fail()  cout sofreu inserções dos número_de_valores elementos da matriz valores pela sua ordem inversa. */ void escreveInvertida(int const valores[número_de_valores]) { … } Não é a matriz que é constante! São os seus elementos! Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa … /** … */ void lêPara(int valores[número_de_valores]) { } void escreveInvertida(int const valores[número_de_valores]) int main() int const número_de_valores = 1000; Invisível aqui! Invisível aqui! Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa … int const número_de_valores = 1000; /** … */ void lêPara(int valores[número_de_valores]) { } void escreveInvertida(int const valores[número_de_valores]) int main() Mas o C++ ignora dimensão de matrizes usadas como parâmetro! (mais uma vez, tem a ver com ponteiros) Mas o C++ ignora dimensão de matrizes usadas como parâmetro! (mais uma vez, tem a ver com ponteiros) Introdução à Programação 2003/2004

Problemas das matrizes (V) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Não se podem devolver Passagem sempre por referência (mentirita…) Dimensão ignorada em parâmetros Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa … int const número_de_valores = 1000; /** … */ void lêPara(int valores[]) { } void escreveInvertida(int const valores[]) int main() Dimensão arbitrária Dimensão arbitrária Introdução à Programação 2003/2004

Introdução à Programação Em falta Invocar procedimentos em main() Corpo dos procedimentos Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; int const número_de_valores = 1000; … int main() { cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; lêPara(valores); escreveInvertida(valores); } Introdução à Programação 2003/2004

Introdução à Programação lêPara() /** Lê do teclado valores inteiros que coloca por ordem nos elementos da matriz passada como argumento. @pre cin.good()  cin permite extracção de número_de_valores inteiros sucessivos. @post cin.fail()  cin já não contém os primeiros número_de_valores inteiros que continha inicialmente  a matriz valores contém-nos pela mesma ordem. */ void lêPara(int valores[]) { assert(cin.good()); for(int i = 0; i != número_de_valores; ++i) cin >> valores[i]; } Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos da matriz passada como argumento começando no último. @pre V. @post cout.fail()  cout sofreu inserções dos número_de_valores elementos da matriz valores pela sua ordem inversa. */ void escreveInvertida(int const valores[]) { for(int i = número_de_valores - 1; i != -1; --i) cout << valores[i] << endl; } Ainda constante global! Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> using namespace std; … int main() { int const número_de_valores = 1000; cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; lêPara(valores, número_de_valores); escreveInvertida(valores, número_de_valores); } Dimensão passada como argumento Dimensão passada como argumento Introdução à Programação 2003/2004

Introdução à Programação lêPara() /** Lê do teclado valores inteiros que coloca por ordem nos elementos da matriz passada como argumento. @pre 0 ≤ número_de_valores  número_de_valores ≤ dim(valores)  cin.good()  cin permite extracção de número_de_valores inteiros sucessivos. @post cin.fail()  cin já não contém os primeiros número_de_valores inteiros que continha inicialmente  a matriz valores contém-nos pela mesma ordem. */ void lêPara(int valores[], int const número_de_valores) { assert(0 <= número_de_valores); assert(cin.good()); for(int i = 0; i != número_de_valores; ++i) cin >> valores[i]; } Não há forma de saber dimensão de matriz parâmetro! Introdução à Programação 2003/2004

Problemas das matrizes (VI) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Não se podem devolver Passagem sempre por referência (mentirita…) Dimensão ignorada em parâmetros Não há forma de saber dimensão de matriz parâmetro Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos da matriz passada como argumento começando no último. @pre 0 ≤ número_de_valores  número_de_valores ≤ dim(valores). @post cout.fail()  cout sofreu inserções dos número_de_valores elementos da matriz valores pela sua ordem inversa. */ void escreveInvertida(int const valores[], int const número_de_valores) { assert(0 <= número_de_valores); for(int i = número_de_valores - 1; i != -1; --i) cout << valores[i] << endl; } Introdução à Programação 2003/2004

Finalmente uma vantagem! Procedimentos genéricos Funcionam com matrizes de dimensão arbitrária Número de valores passado pode ser diferente da dimensão das matrizes Mas… índices não verificados… Introdução à Programação 2003/2004

Indexação fora dos limites (I) int a = 0; int m[3] = {0, 1, 2}; int b = 0; m[-1] = -1; m[3] = 3; cout << a << ‘ ‘ << b << endl; Introdução à Programação 2003/2004

Indexação fora dos limites (II) Que sucede? Programa aborta Escreve 3 -1 Escreve -1 3 Escreve 0 -1 ou -1 0 ou 0 3 ou … Escreve 0 0 Sorte! Pior caso! Introdução à Programação 2003/2004

Explicação (escreve 3 -1) … Memória a: ? 3 m[2]: 2 m: double[3] m[1]: 1 m[0]: b: -1 ? … Introdução à Programação 2003/2004

Problemas das matrizes (VII) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Não se podem devolver Passagem sempre por referência (mentirita…) Dimensão ignorada em parâmetros Não há forma de saber dimensão de matriz parâmetro Índices não verificados Introdução à Programação 2003/2004

Introdução à Programação Mais problemas… double valores1[2] = {1.1, 2.2}; double valores2[2] = {3.3, 4.4}; if(valores1 != valores2) valores1 = valores2; Impossível! Impossível! Introdução à Programação 2003/2004

Problemas das matrizes (VIII) Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador Não se podem devolver Passagem sempre por referência (mentirita…) Dimensão ignorada em parâmetros Não há forma de saber dimensão de matriz parâmetro Índices não verificados Atribuições inválidas Comparações inválidas Introdução à Programação 2003/2004

Matrizes n-dimensionais (I) double m[2][3] = { {1, 2, 3}, {4, 5, 6} }; Duas linhas e três colunas Matriz de matrizes Indexável: m[1][2] = 12.0; Introdução à Programação 2003/2004

Matrizes n-dimensionais (II) double (m[2])[3] = {…}; m: double[2][3] m[0]: double[3] m[1]: double[3] m[0][0]: m[0][1]: m[0][2]: m[1][0]: m[1][1]: m[1][2]: 1 2 3 4 5 6 Introdução à Programação 2003/2004

Introdução à Programação Vectores: A solução Classe genérica Tipo dos itens Nome do vector Número de itens Inicializado com 10 itens de valor zero #include <vector> std::vector<double> v(10); std::vector<double> v(10, 13.0); std::vector<double> v; Inicializado com 10 itens de valor 13 Inicializado com 0 itens! Introdução à Programação 2003/2004

Acedendo à dimensão de vectores vector<double> v(10, 13.0); cout << v.size() << endl; instância.operação(argumento, …); Instância para a qual a operação é invocada Nome da operação a invocar Argumentos a passar à operação Invocação da operação size(). Introdução à Programação 2003/2004

vector<…>::size() Devolve inteiro sem sinal Tipo não-especificado: unsigned short int? unsigned int? unsigned long int? Tipo exacto é sinónimo de vector<…>::size_type Introdução à Programação 2003/2004

Ler 1000 inteiros e escrevê-los por ordem inversa #include <iostream> #include <vector> using namespace std; … int main() { int const número_de_valores = 1000; cout << "Introduza " << número_de_valores << " inteiros: "; vector<int> valores(número_de_valores); lêPara(valores); escreveInvertido(valores); } Introdução à Programação 2003/2004

Introdução à Programação lêPara() /** Lê do teclado valores inteiros que coloca por ordem nos itens do vector passado como argumento. @pre cin.good()  cin permite extracção de valores.size() inteiros sucessivos. @post cin.fail()  cin já não contém os primeiros valores.size() inteiros que continha inicialmente  o vector valores contém-nos pela mesma ordem. */ void lêPara(vector<int>& valores) { assert(cin.good()); for(vector<int>::size_type i = 0; i != valores.size(); ++i) cin >> valores[i]; } Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos do vector passado como argumento começando no último. @pre V. @post cout.fail()  cout sofreu inserções dos valores.size() itens do vector valores pela sua ordem inversa. */ void escreveInvertido(vector<int> const valores) { for(vector<int>::size_type i = valores.size() - 1; i != -1; --i) cout << valores[i] << endl; } i é de um tipo sem sinal. Nunca poderá chegar a -1. Guarda sempre verdadeira! Introdução à Programação 2003/2004

Introdução à Programação escreveInvertida() /** Escreve no ecrã os elementos do vector passado como argumento começando no último. @pre V. @post cout.fail()  cout sofreu inserções dos valores.size() itens do vector valores pela sua ordem inversa. */ void escreveInvertido(vector<int> valores) { for(vector<int>::size_type i = valores.size(); i != 0; --i) cout << valores[i - 1] << endl; } Introdução à Programação 2003/2004

Leitura com devolução (I) Não é função nem procedimento! Má ideia! vector<int> vectorLido(int número_de_valores) { assert(cin.good()); vector<int> valores(número_de_valores); for(vector<int>::size_type i = 0; i != valores.size(); ++i) cin >> valores[i]; return valores; } … int main() vector<int> valores = vectorLido(número_de_valores); escreveInvertido(valores); Introdução à Programação 2003/2004

Leitura com devolução (II) Não é função nem procedimento! Má ideia! vector<int> vectorLido(int número_de_valores) { assert(cin.good()); vector<int> valores; for(int i = 0; i != número_de_valores; ++i) { int valor; cin >> valor; valores.push_back(valor); } return valores; Introdução à Programação 2003/2004

Introdução à Programação Vectores por valor? Vectores podem-se passar por valor Implica cópia do vector Vectores podem ser grandes Passagem por referência não faz cópia Mas permite alterações no parâmetro… Ideal: vantagens de ambos Introdução à Programação 2003/2004

Passagem por referência constante /** Escreve no ecrã os elementos do vector passado como argumento começando no último. @pre V. @post cout.fail()  cout sofreu inserções dos valores.size() itens do vector valores pela sua ordem inversa. */ void escreveInvertido(vector<int> const& valores) { for(vector<int>::size_type i = valores.size(); i != 0; --i) cout << valores[i - 1] << endl; } Sinónimo que proíbe alterações Inútil para tipos básicos! Introdução à Programação 2003/2004

Introdução à Programação Generalização … int main() { cout << "Quantos valores quer que sejam lidos? "; int número_de_valores; cin >> número_de_valores; cout << "Introduza " << número_de_valores << " inteiros: "; vector<int> valores(número_de_valores); lêPara(valores); escreveInvertido(valores); } Introdução à Programação 2003/2004

Introdução à Programação Redimensionando vector<int> v(5, 1); v.resize(8); // Novos itens com zero. v.resize(9, 2); // Novos itens com 2. v.resize(2); Introdução à Programação 2003/2004

Vantagens dos vectores Inicializados implicitamente com zero Inicialização explícita abreviada… Dimensão variável Podem-se devolver Podem-se passar por valor ou por referência Dimensão não é nunca ignorada Pode-se saber dimensão Atribuições válidas Comparações válidas Introdução à Programação 2003/2004

Problemas dos vectores Índices não verificados Inicialização exaustiva impossível Introdução à Programação 2003/2004

Solução recursiva Onde ficam guardados os valores? /** Lê o número de inteiros passado como argumento e escreve-os pela ordem inversa. @pre 0 ≤ numero_de_valores  cin.good()  cin permite extracção de numero_de_valores inteiros sucessivos. @post cout.fail()  cout sofreu inserções dos numero_de_valores inteiros lidos pela sua ordem inversa. */ void leEInverteInteiros(int const numero_de_valores) { assert(0 <= numero_de_valores); if(numero_de_inteiros_a_ler != 0) { int valor; cin >> valor; leEInverteInteiros(numero_de_valores - 1); cout << valor << endl; } Onde ficam guardados os valores? Introdução à Programação 2003/2004

Introdução à Programação Aula 9: Sumário Matrizes clássicas do C++: Agregado indexável de instâncias do mesmo tipo Sintaxe: definição e inicialização Particularidades: dimensão constante proibidas atribuições, comparações e devoluções passagens sempre por referência indexações fora dos limites não verificadas Indexação fora dos limites: sintomatologia Vectores: Vantagens face a matrizes Operações da classe genérica vector Introdução à Programação 2003/2004