Jiraspiom

Blog Pessoal

Lição 08

Lição 8 – Vetores e Seqüência de Caracteres

Vetores

Um vetor ou array é uma série de elementos do mesmo tipo colocados em seqüencia em locais de memória que podem ser acessados ou referenciados individualmente usando índices. Podemos abstrair os vetores pensando neles como se fossem dessa forma:

vet1
Figura 2 – Exemplo de Vetor

Significa que, por exemplo, podemos armazenar 6 valores do tipo int em um vetor sem ter que declarar 6 diferentes variáveis, cada uma com um identificador. Para fazer isso, criamos um vetor com um identificador único (por exemplo vet) e referenciamos as posições usando índices (por exemplo vet[0], vet[1], vet[2], vet[3],… etc). Também abstraindo isto, teríamos:

vet3

Figura 3 – Outro exemplo de Vetor

Lembrando que os índices nos vetores se iniciam de 0, necessitamos declarar um vetor antes de usá-lo, como fizemos com as variáveis. Fazemos assim:

tipo nome_do_vetor [numero_de_elementos];

onde tipo é qualquer tipo válido ja conhecido (int, float, etc…), nome_do_vetor deve ser um identificador válido (como sempre) e numero_de_elementos deve ser uma constante inteira, já que vetores são valores são blocos de memória não-dinâmica cujo tamanho deve ser determinado antes da execução. Exemplo:

int notas[30];

,significa que armazenaremos um vetor com 30 números inteiros.

Inicializando os Vetores

Ao declararmos um vetor localmente, se não especificarmos, seus elementos não serão inicializados com valor algum por padrão e seu conteúdo será indeterminado até que algum valor seja atribuído a eles. Localmente e globalmente, ao declararmos um vetor, podemos atribuir valores iniciais às posições do vetor colocando-os entre chaves { } e separados por vírgulas (,). Assim:

int notas[5] = { 10, 5, 7, 3, 6};

que criaria um vetor assim:

vetor com valores

Figura 4 – Criação de Vetor

Note que o número de elementos nas chaves { } deve sempre ser igual ao declarado dentro dos colchetes [ ];

Acessando os valores

Para acessarmos os valores do vetor individualmente, como se fossem variáveis, podemos usar índices, como já foi falado. Desta maneira:

nome_do_vetor[índice]

,para armazenarmos um valor do vetor em uma variável separada fazemos por exemplo:

int x = notas[3];

que atribuir o valor inserido na quarta posição do vetor notas para a variável x. Podemos também fazer o contrário, inserindo algum valor em uma determinada posição do vetor desta meneira:

notas[2] = 7;

São também operações válidas de vetores:

notas[0] = i;
notas[i] = 75;
x = notas[i+2];
notas[notas[i]] = notas[2] + 2;

OBS: é importante notar que os colchetes desempenham 2 funções nos vetores. São usados na declaração de um novo vetor, especificando seu numero de elementos, e são também usados para isolar os índices, na hora de acessar as posições do vetor. Exemplo:

int notas[5];
notas[2] = 7;

Exemplo de código com vetores:

#include <iostream>
using namespace std;

int notas[] = {1, 2, 3, 4, 5};
int n, resultado=0;

int main ()
{
for ( n=0 ; n<5 ; n++ )
{
resultado += notas[n];
}
cout << resultado;
return 0;
}

, que mostra na tela o valor 15.

Arrays multidimensionais

São basicamente “vetores de vetores”. Vetores multidimensionais podem conter quantos índices quanto forem necessários. Só devemos ter cuidado com o tamanho de memória necessária, já que num vetor deste tipo ela cresce rapidamente com cada dimensão.
Podemos abstrair um array bidimensional assim:

array  multi
Figura 5 – Array Multidimensional


mat, por exemplo, representa um vetor bidimensional de 4 por 5 do tipo inteiro. Declaramos desta maneira:

int nome_do_array[numero_de_linhas][numero_de_colunas];

Exemplo:

int mat[4][5];


Lembrando que os índices começam sempre em 0, referenciamos o 2º elemento verticalmente e 3º horizontalmente por exemplo (marcado em vermelho na figura), desta maneira:

mat[1][2]

Passando Vetores Como Parâmetros

Podemos querer, em algum momento, passar vetores como parâmetros de funções. Como não é possível passar um bloco completo de memória por valor como um parâmetro, passamos apenas os endereços. Na prática, tem quase o mesmo efeito e é mais eficiente e rápido. A única coisa que necessitamos é especificar na declaração da função o tipo do vetor, um identificador e os colchetes [ ]. Desta maneira:

void funcao (int vet[])
{bloco de instruções}


A declaração de função anterior aceita um parâmetro do tipo “vetor de inteiros”, neste caso o vet. Para passar a esta função um vetor declarado como:

int vetor[30];


,podemos chamar a funcao desta maneira:

funcao(vet);


Exemplo:

#include <iostream>
using namespace std;

void mostravetor(int vet[], int length) {
for (int n=0; n<length; n++)
cout << vet[n] << ” “;
cout << “\n”;
}

int main ()
{
int vetor1[] = {5, 10, 15};
int vetor2[] = {2, 4, 6, 8, 10};
mostravetor(vetor1,3);
mostravetor(vetor2,5);
return 0;
}


,que mostra na tela:

5 10 15
2 4 6 8 10

Também podemos passar vetores multidimensionais como parâmetros de funções. Eles teriam o seguinte formato:

tipo nome_da_funcao (tipo nome[][profundidade][profundidade])
{bloco de instruções}


Exemplo:

void funcao (int multi[][3][4])


Note que os primeiros colchetes são deixados em branco enquanto os seguintes não. Funciona assim pois o compilador deve ser capaz de determinar numa função qual é a profundidade de cada dimensão adicional.

Seqüencia de Caracteres

Assim como em várias linguagens, podemos representar em C++ as strings como vetores de caracteres, já que elas são, na verdade, seqüências de caracteres. Desta maneira, a seguinte expressão:

char frase[30];

,é um vetor que pode armazenar até 30 elementos do tipo caractere. Podemos, entretanto, armazenar seqüências menores. Por exemplo, frase poderia armazenar “Ola!” ou “Como vai voce?”, ambas com menos de 30 caracteres. Para designar o fim de uma seqüência válida, usa-se o caracter null (”) . Podemos representar graficamente como:

carac

Figura 6 – Seqüência de caracteres

Inicialização de seqüências de caracteres terminadas com null

Como podem ser considerados simples vetores, as seqüências de caracteres seguem as mesmas regras. Se quisermos inicializar um vetor de caracteres com alguma seqüência pré-determinada, por exemplo, fazemos igual a qualquer outro vetor:

char frase[] = { ‘B’, ‘e’, ‘m’, ‘ ‘, ‘V’, ‘i’, ‘n’, ‘d’, ‘o’, ‘s’, ”};

Arrays de caractere, no entanto, ainda contam com outro método para terem seus valores inicializados: usando strings. Sabemos que:

“esta é uma frase”

é uma string cujo tipo é, na verdade, um array de caracteres. Então strings também contêm o caracter null ao final (”). Com isso podem ser usados para inicializar um vetor de caracteres, desta maneira:

char frase[] = “Bem Vindos”;

,que tem o mesmo resultado que a declaração mostrada anteriormente.

Até aqui mostramos inicializações de vetores de caracteres no momento em que são declarados, mas não ainda após já terem sido declarados. Se frase for um vetor char[], expressões deste tipo:

frase = “Bem vindos”;
frase = { ‘B’, ‘e’, ‘m’, ‘ ‘, ‘V’, ‘i’, ‘n’, ‘d’, ‘o’, ‘s’, ”};
frase[] = “Bem vindos”;


não seriam válidas. Ao sabermos mais sobre ponteiros, isso ficará um pouco mais claro, já que mostraremos que um vetor é, na verdade, um ponteiro constante apontando para certo bloco de memória.

Cin e cout suportam seqüências terminadas em null como containers válidos para seqüências de caracteres. Podem, com isso, ser diretamente usados para extrair strings de caracteres do cin ou para inserí-las no cout.
Exemplo:

#include <iostream>
using namespace std;

int main ()
{
char perg[] = “Por favor, insira seu Primeiro nome: “;
char resp[] = “Bem vindo, “;
char nome[90];
cout << perg;
cin >> nome;
cout << resp << nome << “!”;
return 0;
}


, o que mostrará:

Por favor, insira seu Primeiro nome: Júlio
Bem vindo, Júlio!”


Como podemos ver, declaramos três arrays de caracteres. Nos dois primeiros, inicializamos com strings e o terceiro não foi inicializado. Em todos os casos é necessário definir o tamanho do vetor. Nos dois primeiros está implícito, definido pelo comprimento da string com que eles foram inicializados. O último está explícito que são 90 posições. Por fim, seqüências de caracteres armazenadas em vetores de caracteres podem ser facilmente convertidas em strings apenas usando o operador de atribuição, desta maneira:

string str;
char text[]=”fim de licao”;
str
= text;


%d blogueiros gostam disto: