Matrizes clássicas e vectores em C++

Apresentação em tema: "Matrizes clássicas e vectores em C++"— Transcrição da apresentação:

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

2 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

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

4 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

5 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

6 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

7 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

8 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

9 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

10 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

11 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

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

13 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

14 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

15 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

16 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

17 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

18 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

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

20 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

21 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

22 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

23 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

24 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

25 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

26 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

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

28 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

29 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

30 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

31 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

32 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

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

34 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

35 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

36 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

37 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

38 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

39 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

40 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

41 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

42 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

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

44 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

45 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

46 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

47 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

48 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

49 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

50 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

51 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

52 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

53 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

54 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

55 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

56 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

57 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

58 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

59 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

60 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

61 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

62 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

63 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

64 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

65 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

66 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

67 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

68 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

69 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

70 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

71 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

72 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

73 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

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

75 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

76 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