aula 9 matrizes clássicas e vectores em c++ melhor alternativa!

Aula 9

Matrizes clássicas e vectores em C++

Melhor alternativa!

2003/2004Introdução à Programação2

Ler três inteiros e escrevê-los por ordem inversa

#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; }

Como generalizar para 100, por exemplo?

Para simplificar ignoram-se possíveis erros de extracção!


Adaptação para 100 inteiros

Basta acrescentar 97 variáveis, obviamente…


Ler 100 inteiros e escrevê-los por ordem inversa

#include <iostream>


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…



#include <iostream>


int main() { cout << "Introduza 100 inteiros: "; int valores[100];

?}

Matriz de 100 inteiros


Sintaxe

double m[4];

m[2] = 2.2;double x = m[3];

Tipo dos elementosNome da matrizNúmero de

elementos

Indexações

Como uma variável


Organização

double m[4];

m[0]:

?

m: double[4]

m[1]:

?

m[2]:

?

m[3]:

?

Índices:1º elemento: índice 02º elemento: índice 1…nº elemento: índice n-1


Inicialização

double m[4];

Com lixo!

m[0]:

?

m: double[4]

m[1]:

?

m[2]:

?

m[3]:

?


Inicialização explícita

double m[4] = {0.0, 1.1, 2.2, 3.3};

m[0]:

0

m: double[4]

m[1]:

1,1

m[2]:

2,2

m[3]:

3,3


Inicialização implícita (I)

double m[4] = {0.0, 1.1};

m[0]:

0

m: double[4]

m[1]:

1,1

m[2]:

0

m[3]:

0


Inicialização implícita (II)

double m[4] = {};

m[0]:

0

m: double[4]

m[1]:

0

m[2]:

0

m[3]:

0


Problemas das matrizes (I)

Inicializadas implicitamente com lixo Inicialização explícita exaustiva…



#include <iostream>


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!



#include <iostream>


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



#include <iostream>



for(int i = 100; i != 0; --i) cout << valores[i - 1] << endl;}

Inserção dos 100 inteiros por ordem inversa



#include <iostream>



for(int i = 99; i != -1; --i) cout << valores[i] << endl;}

Preferível!


Elementos fictícios

double m[4];

m[0]:

?

m: double[4]

m[1]:

?

m[2]:

?

m[3]:

?

Elemento inicial

m[-1]: m[4]:

?

Elemento final

Primeiro elemento

Último elemento


Ciclos com matrizes

Directo Do primeiro ao elemento final, exclusive

Inverso Do último ao elemento inicial, exclusive


Adaptação para 1000 inteiros

Basta substituir 100 por 1000, obviamente…



#include <iostream>



for(int i = 99; i != -1; --i) cout << valores[i] << endl;}

Ops…


Ler 1000 inteiros e escrevê-los por ordem inversa#include <iostream>


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!


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…


Ler inteiros e escrevê-los por ordem inversa#include <iostream>


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!


Ler inteiros e escrevê-los por ordem inversa#include <iostream>


int main() { cout << “Introduza o número de valores a ler: “; int n; cin >> n; int const número_de_valores = n;


…}

Erro! Tem de ser constante conhecida pelo compilador!


Problemas das matrizes (II)

Inicializadas implicitamente com lixo Inicialização explícita exaustiva… De dimensão fixa De dimensão conhecida pelo compilador





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;}


Vamos modularizar

Leitura dos valores do teclado Escrita invertida dos valores no ecrã




…



// Leitura…

escreveInvertida(…);}


escreveInvertida()

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


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!


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


lêPara()

/** Lê do teclado valores inteiros que coloca por ordem nos elementos da matriz passada como argumento. */void lêPara(…) { …}


Passagem de matriz como argumento

lêPara(): passagem por referência escreveInvertida(): passagem por valor


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]) { … }


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!


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)


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…)


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!


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]) { … }


…}

Invisível aqui!Invisível aqui!



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)


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




/** … */void lêPara(int valores[]) { … }

/** … */void escreveInvertida(int const valores[]) { … }

int main() { …}

Dimensão arbitráriaDimensão arbitrária


Em falta

Invocar procedimentos em main() Corpo dos procedimentos





…

int main() { cout << "Introduza “ << número_de_valores << “ inteiros: "; int valores[número_de_valores]; lêPara(valores);

escreveInvertida(valores);}


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]; }


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!




…


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 argumentoDimensão passada como argumento


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!


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


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; }


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…


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;


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!


Explicação (escreve 3 -1)

m[0]:

0

m: double

[3]

m[1]:

1

m[2]:

2

b:

?

a:

?

…

…

Memória

3

-1


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


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!


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


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;


Matrizes n-dimensionais (II)

double (m[2])[3] = {…};

m[0][0]:

1

m[0]: double[3]

m[0][1]:

2

m[0][2]:

3

m[1][0]:

4

m[1]: double[3]

m[1][1]:

5

m[1][2]:

6

m: double[2][3]


Vectores: A solução

#include <vector>

std::vector<double> v(10);

std::vector<double> v(10, 13.0);

std::vector<double> v;

Tipo dos itensNome do vector

Número de itensInicializado com 10 itens de valor zero

Inicializado com 10 itens de valor 13

Inicializado com 0 itens!

Classe genérica


Acedendo à dimensão de vectores

vector<double> v(10, 13.0);cout << v.size() << endl;

instância.operação(argumento, …);

Invocação da operação size().

Instância para a qual a operação é invocada

Nome da operação a invocar

Argumentos a passar à operação


vector<…>::size()

Devolve inteiro sem sinal Tipo não-especificado:

unsigned short int? unsigned int? unsigned long int?

Tipo exacto é sinónimo devector<…>::size_type


Ler 1000 inteiros e escrevê-los por ordem inversa#include <iostream> #include <vector>


…


cout << "Introduza " << número_de_valores << " inteiros: "; vector<int> valores(número_de_valores); lêPara(valores);

escreveInvertido(valores); }


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]; }


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!


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; }


Leitura com devolução (I)

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);


Não é função nem procedimento! Má ideia!


Leitura com devolução (II)

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; }

Não é função nem procedimento! Má ideia!


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


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çõesInútil para tipos básicos!


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);



Redimensionando

vector<int> v(5, 1); v.resize(8); // Novos itens com zero.

v.resize(9, 2); // Novos itens com 2.

v.resize(2);


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


Problemas dos vectores

Índices não verificados Inicialização exaustiva impossível


Solução recursiva

/** 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?


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

aula 9 matrizes clássicas e vectores em c++ melhor alternativa!

Documents