Mandar um cafézinho para o programador:


Me ajude a transformar café em código!
Mostrando postagens com marcador Vetor. Mostrar todas as postagens
Mostrando postagens com marcador Vetor. Mostrar todas as postagens

Arrays e Ponteiros de Structs em C++


 Neste tutorial de nossa apostila de C++, vamos aprender como trabalhar tanto com arrays como com ponteiros, usando structs.

Array de Structs

Assim como qualquer outro tipo de variável, o tipo que você definiu, usando structs, pode ser declarado na forma de array, ou seja, várias instâncias de structs.

Nos tutoriais anteriores, estamos usando a struct Student, instanciando apenas um aluno para nosso estudo. Mas qual escola, faculdade ou curso que você conhece que só tem um aluno? O normal é ter 20, 30, 50...

Então vamos lá, para declarar 50 structs do tipo Student, basta fazer:

  • Student alumns[50];

E prontinho, está declarado seu array de nome 'alumns', do tipo 'Student', com 50 elementos, onde o índice varia de 0 até 49.

Para acessar os nomes dos alunos, basta acessar as variáveis:

  • alumn[0].name
  • alumn[1].name
  • alumn[2].name
  • ...
  • alumn[49].name

Para acessar as notas de matemática dos alunos, basta acessar as variáveis:

  • alumn[0].math
  • alumn[1].math
  • alumn[2].math
  • ...
  • alumn[49].math

Podemos também, se quisermos, declarar e já inicializar as structs do array, por exemplo, para 3 alunos:
Student alumns[3] = {
                                    {"Neil Peart", 10, 10, 10},
                                    {"Geddy Lee", 9.1, 9.5, 9.2},
                                    {"Alex Lifeson", 2.5, 3.5, 4.7},
                                 };

Ponteiros para Structs

E, por fim, também podemos criar ponteiros especiais, que apontam para structs!
Por exemplo, para criar um ponteiro do tipo Student e de nome 'alumn':
  • Student *alumn;
Prontinho, temos um ponteiro do tipo Student. Agora vamos criar uma instância dessa struct:
  • Student s = { "Neil Peart", 10.0, 10.0, 10.0 };
Podemos fazer:
  • alumn = &s;

E prontinho, nosso ponteiro está apontando para uma variável do tipo Student. Podemos trabalhar e alterar essa instância através do ponteiro, se desejarmos.

Vamos mudar o nome do aluno, através do ponteiro, basta fazer:
  • *alumn.name = "Alex Lifeson";
Certo?
Errado!

O operador ponto . tem precedência ao operador *, logo, você vai estar acessando a referência para o membro 'alumn.name' e não para o ponteiro 'alumn'.

Assim, o correto é:
  • (*alumn).name = "Alex Lifeson";
Porém, fica muito feio e trabalhoso escrever desse jeito aí. Então, criaram um operador especial para usar em ponteiros de structs. A linha de código acima pode ser escrita assim:
  • alumn->name = "Alex Lifeson";
Prontinho. Usando o operador -> significa que estamos acessando o conteúdo do local para onde o ponteiro está apontando.

O código a seguir declara um array com 3 elementos do tipo Student, preenche seus campos um por um com um laço while, usando ponteiros, e depois exibe os dados dos alunos:
#include <iostream>
using namespace std;

int main()
{
    Student s[3], *ptr_s;
    int i;

    for(i=0 ; i<3 ; i++)
    {
        ptr_s=&s[i];

        cout << "Nome do aluno "<<i+1<<": ";
        cin.getline(ptr_s->name, 50);

        cout << "Nota de Matemática do aluno "<<i+1<<": ";
        cin >> ptr_s->math;

        cout << "Nota de Física do aluno "<<i+1<<": ";
        cin >> ptr_s->physics;

        cout << "Nota de Ciências do aluno "<<i+1<<": ";
        cin >> ptr_s->science;

        cin.ignore();
        cout << endl;
    }

    cout << endl;

    for(i=0 ; i<3 ; i++)
    {
        ptr_s=&s[i];
        cout << "Aluno "<<i+1<<": "<<ptr_s->name<<endl;
        cout << "Nota em Matemática "<<i+1<<": "<<ptr_s->math<<endl;
        cout << "Nota em Física "<<i+1<<": "<<ptr_s->physics<<endl;
        cout << "Nota em Ciências "<<i+1<<": "<<ptr_s->science<<endl;
        cout << endl;
    }

    return 0;
}

Matrizes em Funções

Neste tutorial de nossa apostila de C++, vamos aprender como trabalhar com matrizes e funções, aprendendo a declarar, invocar e usar estes dois importantes tópicos, conjuntamente.

Como Passar Matriz para Função

No estudo de arrays, vimos que existem algumas maneiras de declarar o cabeçalho de funções com arrays como parâmetros, da seguinte maneira:
  • tipo func(tipo *array);
  • tipo func(tipo array[tamanho]);
  • tipo func(tipo array[]);

Ou seja, basta passar o ponteiro (*array - estudaremos mais na frente) ou o só com o par de colchetes em aberto (array[]).

No caso de arrays bidimensionais, precisamos especificar o número de colunas da matriz que estamos enviando:
  • void func(int arr[][COLUMN]);

Veja bem, o número de linhas não é obrigatório (até podemos passar), mas o número de colunas, sim.
Vamos declarar e inicializar uma matriz 2x2 e em seguida enviara para a função show(), que vai simplesmente exibir ela na forma de uma tabela, veja como fica nosso código:
#include <iostream>
using namespace std;

void show(int arr[][2], int row)
{
    for (int i=0 ; i<row ; i++){
        for(int j=0 ; j<2 ; j++)
            cout<<arr[i][j]<<"  ";
        cout<<endl;
    }
}

int main()
{
    int arr[][2]={ {1,2}, {3,4} };
    show(arr, 2);
    return 0;
}
Note algumas coisas importantes, no código acima.

Primeiro, passamos a matriz arr[][2] para a função, com o número de colunas.
Mas e o número de linhas? Como a função vai saber o tanto de linhas, para imprimir a tabela ?
Ela não sabe, por isso passamos outro parâmetro na função, o inteiro 'row'.

Matriz em C++: Passagem por referência

Toda passagem de dados para funções que envolvem arrays, é por referência. Sempre.
Ou seja, passou um array pra uma função? Ela vai acessar diretamente o array e seus dados, direto na memória. Não é uma cópia que vai pra função, não é passagem por valor, ok?

Isso quer dizer uma coisa: cuidado! As funções podem modificar seus arrays, lembre-se sempre disso.

O código abaixo introduz a função 'init', que vai receber um array e inicializar cada elemento dele, perguntando pro usuário:
#include <iostream>
using namespace std;
const int COLS = 3;
const int ROWS = 3;

void init(int arr[][COLS], int ROWS)
{
    for(int i=0 ; i<ROWS ; i++)
        for(int j=0 ; j<COLS ; j++){
            cout << "matrix["<<i+1<<"]["<<j+1<<"]: ";
            cin  >> arr[i][j];
        }
}

void show(int arr[][COLS], int ROWS)
{
    for (int i=0 ; i<ROWS ; i++){
        for(int j=0 ; j<COLS ; j++)
            cout<<arr[i][j]<<"  ";
        cout<<endl;
    }
}

int main()
{
    int arr[ROWS][COLS];
    init(arr, ROWS);
    show(arr, ROWS);
    return 0;
}
Para melhorar a organização, já definimos as linhas (ROWS) e colunas (ROLS) como variáveis globais do tipo constantes, para não ter perigo de ninguém, em algum local do código, alterar seus valores. Isso deixa o código mais claro e seguro, para manutenção.

Array de arrays em C++

Exercício de Matriz em C++

Crie uma matriz 4x4, onde cada linha representa as notas de um aluno, e cada coluna é uma matéria diferente. Você deve criar uma função que vai preenchendo as notas dos alunos, uma por uma, assinalando qual é a matéria e qual é o aluno.

Em seguida, seu programa deve exibir, de maneira organizada, as notas de cada aluno, bem como a média de cada um, a média da turma para cada matéria, e a média geral, de todos alunos de todas as notas.

Postem sua solução nos comentários.

Matriz em C++ : Array de Arrays

Neste tutorial de nosso Curso de C++, vamos aprender o importante conceito de matriz em C++.

Array de Arrays - O que é? Para que serve?

Até o momento, em nossa seção de arrays, criamos arrays de inteiros, float, doubles, char etc.
Ou seja, criamos arrays que armazenam números ou caracteres.
Porém, também é possível armazenar outras coisas em arrays.

Uma coisa curiosa de se armazenar em arrays, são outros arrays.

Por exemplo, imagine que você foi contratado por uma escola para fazer um programa em C++ que vai, dentre outras coisas, armazenar as notas dos alunos. Cada aluno tem, por exemplo, 5 notas diferentes.

Você pode, antes de tudo, raciocinar assim: criar um array para armazenar os alunos.
Por exemplo: alunos[10]

Porém, cada aluno tem 5 notas. Então cada aluno desses vai ter um array de notas:
notas[5]

Veja bem: temos um array de alunos, cada bloco representa um aluno. E dentro de cada bloco, ou seja, de cada aluno, tem uma espécie de array interno, com as notas de cada aluno. Cada aluno tem seu array de notas, e cada aluno faz parte do array de alunos.

Vamos formalizar isso?

Como declarar uma Matriz em C++

Chamamos pelo nome de matriz, um array de arrays, ou arrays multidimensionais.
Até o momento, trabalhamos apenas com arrays de uma dimensão, só uma 'linha' de bloquinhos, que formam um array.

Para aumentarmos o número de dimensões de um array, basta irmos acrescentando pares de colchetes, por exemplo:

  • Para declarar um array de uma dimensão, fazemos: float grade[5];
  • Para declarar um array de duas dimensões, fazemos: float students[10][5];


Vamos lá. Quando fazemos 'float grade[5]' queremos dizer: 5 bloquinhos de float.
Quando fazemos: 'float students[10][5]', queremos dizer: 10 bloquinhos, onde cada bloquinho desses tem um array dentro, de 5 floats.
Dizemos que essa é uma matriz 10x5 (10 linhas e 5 colunas, onde cada linha representa um aluno, e cada coluna representa uma nota diferente).

Para facilitar, vamos imaginar uma matriz 3x3, declaramos assim:

  • int matrix[3][3];


A expressão 'matrix[3]' quer dizer: um array de 3 elementos.
O que contém cada elemento? Um inteiro? Um float? Um char? Não, cada elemento é um outro array, de tamanho [3].

Veja como fica a representação dessa matriz:
Array de arrays em C++

O primeiro elemento de nossa matriz é: matrix[0]
Ele é um array, de 3 elementos, que são representados por:
Primeiro elemento: matrix[0][0]
Segundo elemento: matrix[0][1]
Terceiro elemento : matrix[0][2]

O segundo elemento de nossa matriz é: matrix[1]
Ele é um array, de 3 elementos, que são representados por:
Primeiro elemento: matrix[1][0]
Segundo elemento: matrix[1][1]
Terceiro elemento : matrix[1][2]

O terceiro elemento de nossa matriz é: matrix[2]
Ele é um array, de 3 elementos, que são representados por:
Primeiro elemento: matrix[2][0]
Segundo elemento: matrix[2][1]
Terceiro elemento : matrix[2][2]

Ou seja, para declaramos uma matriz de 'i' linhas e 'j' colunas, fazemos:

  • tipo matrix[i][j];

Se você já estudou matriz e determinantes, na escola, deve se lembrar de como se usa uma matriz, como sinalizar cada elemento etc. Aqui, a única diferença é que a contagem começa do índice 0, ao invés de 1.

Como inicializar uma Matriz em C++

Vamos criar uma matriz para armazenar as notas de 3 alunos, onde cada aluno tem duas notas.
Ou seja, teremos uma matriz de 3 linhas (uma para cada aluno) e 2 colunas (cada coluna representa uma nota). Declaramos essa matriz, então:

  • float grade[3][2];


Vamos agora inicializar essa matriz com as notas:
float grade[3][3] = { {9.5, 9.1},
                                  {8.8, 8.4},
                                  {10.0, 10.0} };

O array de notas do primeiro aluno é: {9.5, 9.1}
O array de notas do segundo aluno é: {8.8, 8.4}
O array de notas do terceiro aluno é : {10.0, 10.0}

Por exemplo, qual a primeira nota do segundo aluno? Segundo aluno é o aluno 1, primeira nota é a de índice 0, então essa nota está armazenada em: grade[1][0] = 8.8
Já a segunda nota do segundo aluno é: grade[1][1] = 8.4

Simples, não?

Ordenar elementos de um Array em C++

Neste tutorial de nosso curso de C++, vamos aprender como ordenar os elementos de um Array.

Ordenar elementos (sorting)

Ordenar, isto é, colocar elementos (como números) em uma determinada ordem (como crescente ou decrescente, por exemplo), é um dos assuntos mais importantes e estudados em computação, devido sua importância.

Na sua escola ou universidade, a lista de alunos é ordenada em ordem alfabética.
As seções eleitorais onde você vai votar, também usam algum tipo de ordem.
As contas bancárias, também organizam tudo de acordo com números, bem como os números de uma cartela de loteria.

Quando você for um programador profissional em C++, sua empresa vai pedir para você organizar diversas coisas, em algum tipo de ordem, como nomes, salários, identificações, cargos, tamanho ou peso de produtos, etc etc.

Ou seja, é um assunto absurdamente usado, importante demais mesmo, que você vai usar muito mesmo, várias vezes, em sua carreira, e vamos introduzir agora neste tutorial, um pouco do assunto.

Como ordenar um Array em C++

Vamos usar o algoritmo Selection Sort, para ordenar os elementos do Array.
Primeiro, criamos a função gen(), que vai gerar números aleatórios entre 1 até 100.

Vamos criar um array de tamanho size=10 e nome 'num'.
Vamos preencher, em seguida, cada posição desse array com um número aleatório, e depois imprimimos esse array de valores aleatórios. Próximo passo agora é ordenar esse array,

A lógica é a seguinte: pegamos o primeiro elemento do array, e comparamos com todos os outros. Ou seja, comparamos o elemento 0 com o de índice 1, depois o 0 com o de índice 2...até chegar no 0 com o de índice 9.

Se esses outros elementos forem menores que o de índice 0, invertemos os valores desses dois elementos. Pronto, ao término dessa operação, o menor valor do array estará na posição 0.

Agora vamos colocar o segundo menor valor na posição de índice 1.
Para isso, vamos comparar o elemento 1 com o 2, depois o 3, depois o 4...até compararmos o elemento 1 com o elemento 9, o último. Novamente, se esse outro elemento for menor que o de índice 1, invertemos a posição deles.

Ao final desta etapa, o segundo menor valor estará na posição 1. Agora basta fazer isso para os elementos 2, 3,...7 e 8. Na última 'rodada' de comparações, comparamos o elemento 8 com o 9 para decidir qual é maior e qual é menor.

O primeiro looping, usando um laço for, é o que controla o primeiro elemento, e dentro dele vamos comparar com todos os outros índices.
Vamos usar a variável 'prev' para receber o primeiro índice. Ela vai de 0 até 'size-2' (de 0 até 8, ou seja: for(prev=0; prev < size -1 ; prev++) ).

O segundo looping, um laço for aninhado, vai comparar o índice 'prev' com todos os outros elementos do array.
O segundo índice vai ser armazenado na variável 'next', ele começa sempre do valor 'prev+1' (quando o primeiro elemento é 0, ela começa do 1...quando o primeiro elemento é o de índice 1, ele começa no índice 2, etc etc...até o primeiro elemento ser o de índice 8 e ela será o índice 9), até 'size-1' (ou seja, for (next=prev+1 ; next < size ; next++) ).

Dentro desse laço interno, usamos um teste condicional IF pra saber se o segundo elemento é menor que o primeiro, se for, invertemos os valores desses elementos.

Veja como fica nosso código:
#include <iostream>
#include <random>
using namespace std;

int gen()
{
    std::random_device rd;
    std::mt19937 gen_numb(rd());
    std::uniform_int_distribution<> dis(1, 100);

    return dis(gen_numb);
}

int main()
{
    int size=10, prev, next, aux;
    int num[size];

    for(aux=0 ; aux<size ; aux++){
        num[aux] = gen();
    }

    cout<<"Array original: "<<endl;
    for(aux=0 ; aux<size ; aux++)
        cout<<num[aux]<<" ";
    cout<<endl;

    // Selection sort algorithm
    for(prev=0 ; prev<size-1 ; prev++)
        for(next=prev+1 ; next<size ; next++){
            aux=num[prev];

            if(num[next]<num[prev]){
                num[prev]=num[next];
                num[next] = aux;
            }
        }

    cout<<"Array Ordenado: "<<endl;
    for(aux=0 ; aux<size ; aux++)
        cout<<num[aux]<<" ";
    cout<<endl;

    return 0;
}

Exercícios de Arrays

01. Faça um algoritmo que ordena os elementos de um array do maior pro menor, ou seja, ordem decrescente.

02. Coloque o código anterior todo dentro de funções: função que preenche o array, função que inverte dois valores, função que faz o selection sort e função que exibe arrays. Use protótipos de função, pra deixar seu código bem profissional.

Solução na apostila

Como achar o Maior e o Menor elemento de um Array

Neste tutorial, vamos fazer um exercício interessante, que envolve arrays e busca. Vamos gerar um array de 1 milhão elementos, com valores aleatórios, e vamos fazer a máquina fazer uma varredura nesse array gigante, em busca do maior e do menor elemento do vetor.

Fazendo buscas em Arrays

Primeiro, definimos o tamanho de nosso array, que será SIZE, será uma constante de valor 1 milhão.
Em seguida, basta declarar nosso array, de nome 'numb': numb[SIZE];

Vamos declarar uma variável auxiliar, a 'count', e outras duas que vão armazenar o valor do maior (highest) e menor valor contido naquele array (lowest).

Vamos primeiro sair em busca do maior elemento.
A lógica é a seguinte: de início, vamos supor que o primeiro elemento do array, o de índice 0, seja o maior. Então, fazemos:
highest = numb[0];

O que temos que fazer é percorrer, todo o array, a partir do índice 1 e comparar todos os outros elementos com o valor armazenado em 'highest'.

Vamos comparar se o elemento 'numb[1]' é maior que 'highest'.
Vamos comparar se o elemento 'numb[2]' é maior que 'highest'.
Vamos comparar se o elemento 'numb[3]' é maior que 'highest'.
...
Vamos comparar se o elemento 'numb[999999]' é maior que 'highest'.

Essas comparações vamos fazer com um simples teste condicional IF, dentro de um looping FOR que vai percorrer todos os elementos do array gigante:
if (numb[count] > highest)

Ora, se algum elemento for maior, devemos alterar o valor armazenado em 'highest' para esse novo valor, concorda? Resumindo, basta fazer:
highest = numb[count];

Nosso código fica assim:
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main()
{
    const int SIZE = 1000000;
    int numb[SIZE], count, highest, lowest;
    srand( time(0) );

    for (count=0; count<SIZE; count++ )
        numb[count] = rand();

    highest=numb[0];
    for (count=1; count<SIZE; count++){
        if (numb[count] > highest)
            highest = numb[count] ;
    }

    lowest=numb[0];
    for (count=1; count<SIZE; count++){
        if (numb[count] < lowest)
            lowest = numb[count] ;
    }

    cout<<"Maior: "<<highest<<endl;
    cout<<"Menor: "<<lowest<<endl;
}
E para achar o menor valor?
A lógica é a mesma.

Fazemos com que, de início, o menor valor armazene o valor do primeiro elemento do array:
lowest = numb[0];

Depois comparamos todos os outros elementos do array com esse 'lowest', checando se os outros elementos do array são MENORES, que lowest, se forem, atualizamos o novo valor de lowest.

Aliás, dá até pra gente fundir esses dois laços FOR com IFs aninhados, em um só laço, veja:
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main()
{
    const int SIZE = 1000000;
    int numb[SIZE], count, highest, lowest;
    srand( time(0) );

    for (count=0; count<SIZE; count++ )
        numb[count] = rand();

    highest=numb[0];
    lowest=numb[0];

    for (count=1; count<SIZE; count++){
        if (numb[count] > highest)
            highest = numb[count];

        if (numb[count] < lowest)
            lowest = numb[count];
    }

    cout<<"Maior: "<<highest<<endl;
    cout<<"Menor: "<<lowest<<endl;
}
1 milhão de elementos, e achamos o menor e o maior elemento de maneira praticamente instantânea. Poderoso esse esquema de buscar com arrays e laços, não acha? Fantástico o C++.

Probabilidade e Estatística em C++: Jogando Dados

Agora que já aprendemos os conceitos básicos dos Arrays em C++, vamos ver um uso na prática deles, fazendo lançamento de dados e usando conceitos de Probabilidade e Estatística.

Lançar Dados em C++

O que vamos fazer é bem simples: vamos jogar dados, ou seja, sortear números de 1 até 6.
Vamos fazer isso 100 vezes, 1000 e 100 mil vezes.

Inicialmente, declaramos um array de nome dice, de 6 posições, do tipo inteiro, e inicializamos com valor nulo. Vamos usar um inteiro num para armazenar o número aleatório gerado.

Em seguida, para gerar os números, vamos utilizar a função gen():
int gen()
{
    std::random_device rd;
    std::mt19937 gen_numb(rd());
    std::uniform_int_distribution<> dis(1, 6);

    return dis(gen_numb);
}
Usamos uma solução mais sofisticada, pois vamos gerar milhares de números aleatórios, num curtíssimo intervalo de tempo, e para isso a rand()/srand() não servem (gerar números seguidamente).

Vamos usar a biblioteca raindon e vai retornar um inteiro entre 1 e 6, simulando um dado.
(Referência: https://en.cppreference.com/w/cpp/numeric/random/uniform_int_distribution)

Se sair 1, armazenamos na posição dice[0].
Se sair 2, armazenamos na posição dice[1].
...
Se sair 6, armazenamos na posição dice[5].

Agora, basta fazer: num = gen();
Depois: dice[num-1]++ (pois o array vai de 0 até 5)
E incrementar o índice 'num' do array em uma unidade.

Fazemos os loopings rodar, primeiro gerando os aleatórios, depois exibindo quantas vezes cada número saiu (o número 'num' saiu dice[num] vezes). Não esqueçamos de zerar os valores do array, antes de cada looping de geração de números.

Veja como fica nosso código:
#include <iostream>
#include <iomanip>
#include <random>
using namespace std;

int gen()
{
    std::random_device rd;
    std::mt19937 gen_numb(rd());
    std::uniform_int_distribution<> dis(1, 6);

    return dis(gen_numb);
}

int main()
{
    int dice[6] = {},
        num=0, aux;

    cout <<"100 lançamentos de dados:"<<endl;
    for(aux=0 ; aux<100 ; aux++){
        num = gen();
        dice[num-1]++;
    }
    for(aux=0 ; aux<6 ; aux++){
        cout<<"Numero "<<aux+1<<" saiu: "<<dice[aux]
            <<" ("<<fixed<<setprecision(2)<<100.0*dice[aux]/100<<" %)"<<endl;
    }

    cout <<"\n1000 lançamentos de dados:"<<endl;
    for(aux=0 ; aux<1000 ; aux++){
        num = gen();
        dice[num-1]++;
    }
    for(aux=0 ; aux<6 ; aux++){
        cout<<"Numero "<<aux+1<<" saiu: "<<dice[aux]
            <<" ("<<fixed<<setprecision(2)<<100.0*dice[aux]/1000<<" %)"<<endl;
    }

    cout <<"\n100000 lançamentos de dados:"<<endl;
    for(aux=0 ; aux<100000 ; aux++){
        num = gen();
        dice[num-1]++;
    }
    for(aux=0 ; aux<6 ; aux++){
        cout<<"Numero "<<aux+1<<" saiu: "<<dice[aux]
            <<" ("<<fixed<<setprecision(2)<<100.0*dice[aux]/100000<<" %)"<<endl;
    }

}
Poderíamos ter feito direto com o código: dice[ gen()-1]++
E o resultado:
Como gerar muitos números aleatórios

Segundo a teoria das probabilidades, a chance de sair algum número em um dado é de 1 em 6, ou 1/6 ou 16,67% de chances.

Note que em 100 lançamentos, o resultado é um pouco flutuante.
A medida que aumentamos o número de sorteios, as estatísticas reais vão se aproximando do resultado da teoria, por volta dos 16,67% , logo nosso método de jogar dados é cada vez mais realista e mais aleatório à medida que aumentamos o número de lançamentos.

Arrays em C++ : Como Declarar, Inicializar, Acessar e Usar

Agora que já aprendemos o que são arrays, para que servem e onde são usados, vamos aprender a trabalhar com eles, declarando, acessando e usando das mais variadas maneiras.

Como declarar um Array em C++

Assim como as variáveis que usamos até o momento, em nossa apostila, para declarar um vetor, você primeiramente precisa declarar o tipo de dado dele (char, int, double, float etc). Em seguida, precisa dar um nome também.

Agora vem a parte diferente, em array: você precisa dizer o tamanho do seu array, ou seja, quantas variáveis únicas aquele vetor vai conter, e isso é informado entre colchetes [ ].

Vamos declarar algumas variáveis?

  • int RG[10]: array com 10 inteiros pra armazenar números de RG's
  • float notas[5]: array com 5 números floats, pra armazenar notas
  • char nome[100]: array com espaços para 100 caracteres, para armazenar um nome ou texto (também chamado de strings, que estudaremos futuramente nosso curso)


Só isso: tipo, nome do array e quantos elementos ele deve ter.

Como inicializar um Array

Ao declarar, você já pode de cara inicializar os elementos do array. Para isso, colocamos os valores entre colchetes { }.
Por exemplo, um array de 2 elementos inteiros de valores 21 e 12:

  • int rush[2] = { 21, 12 };

Se você quiser inicializar um array de mil elementos, todos com valor 0, basta fazer:

  • int num[1000] = {};


Automaticamente o C++ vai preencher todas as variáveis com valor inicial nulo.

Você não precisa nem declarar o número de elementos se for inicializar diretamente, o C++ vai contar quantos elementos você informou e declarar o array com tamanho exato daquilo que está usando, basta deixar os colchetes vazios.

Por exemplo,  inicializando uma string (array de caracteres) com o nome do nosso curso e exibir uma mensagem de boas vindas:
#include <iostream>
using namespace std;

int main()
{
    char site[] = {"C++ Progressivo"};

    cout << "Bem vindos ao "<< site <<endl;
}

Como acessar os elementos de um Array

Vamos supor que tenhamos um array de 3 inteiros:
int num[3];

A primeira variável é: num[0]
A segunda variável é: num[1]
A terceira variável é : num[2]

Note uma coisa essencial: o primeiro elemento tem SEMPRE índice 0
O primeiro é num[0] e não num[1].

Você pode declarar um vetor de 10, 100, mil, milhão...o primeiro elemento é acessado usando o índice 0:
Primeiro elemento: num[0]
Segundo elemento: num[1]
n-ésimo elemento : num[n-1]

Ou seja, se seu array tem tamanho X, você acessa os elementos a partir do índice 0, até o índice (X-1), ok ?

Como usar Arrays em C++

Vamos colocar a mão na massa e ver como se usa arrays em C++? De verdade?
Como vamos tratar com uma grande quantidade de variáveis, praticamente sempre que usamos arrays, usamos também laços para acessar mais rapidamente e de maneira mais dinâmica e flexível, os vetores. Vamos ver na prática.

Exemplo 1

Coloque os números 0, 1, 2, 3, ..., 9 em um array de 10 elementos.
#include <iostream>
using namespace std;

int main()
{
    int num[10], cont;

    for(cont=0 ; cont<10 ; cont++)
        num[cont] = cont;
}

Nossa variável auxiliar é 'cont', e ela recebe valores de 0 até 9.
A variável de índice 0 recebe o valor 0.
A variável de índice 1 recebe o valor 1.
...
A variável de índice 9 recebe o valor 9.

Isso é feito com a linha de comando: num[cont] = cont;

Exemplo 2

Coloque os números 1, 2, 3, ..., 10 em um array de 10 elementos, em seguida exiba eles no formato 'Elemento 1', 'Elemento 2', ..., 'Elemento 10'.
#include <iostream>
using namespace std;

int main()
{
    int num[10], cont;

    for(cont=0 ; cont<10 ; cont++)
        num[cont] = cont+1;

    for(cont=0 ; cont<10 ; cont++)
        cout << "Elemento " << cont+1 << ": " << num[cont] << endl;
}

Agora fizemos com um detalhe de diferença:
 A variável de índice 0 recebe o valor 1.
A variável de índice 1 recebe o valor 2.
...
A variável de índice 9 recebe o valor 10.

Isso é feito com a linha de comando: num[cont] = cont+1;

Veja bem, nós programadores, contamos a partir do 0. Mas as pessoas normais (?????!), contam a partir do 1. Então, temos que exibir 'elemento 1' como o primeiro, e não elemento 0. Por isso, adicionamos 1 à variável cont,

Exemplo 3

Crie um programa que peça a nota de 5 alunos, armazene essas notas num array, depois exiba elas, bem como a sua média.
#include <iostream>
using namespace std;

int main()
{
    float grade[5], sum=0;
    int cont;

    for(cont=0 ; cont<5 ; cont++){
        cout<<"Insira a nota "<<cont+1<<": ";
        cin >> grade[cont];
        sum += grade[cont];
    }

    for(cont=0 ; cont<5 ; cont++)
        cout<<"Nota "<<cont+1<<": "<<grade[cont]<<endl;

    sum /= 5;

    cout<<"Media: "<<sum<<endl;

}
Vamos armazenar as notas no array 'grade', e a soma das notas na variável 'sum'. Nosso contador é o 'cont'.

Primeiro, usamos um laço FOR para pedir as 5 notas ao usuário.
Cada vez que ele digita uma nota, ela é atribuída a um elemento do array, em seguida é somada a variável sum (que deve inicializar em 0).

Depois, exibimos todas as notas digitadas.
Por fim, basta dividir a variável 'sum' por 5 e teremos a média das notas digitadas.

Note que o tamanho do código seria o mesmo pra 1 milhão de notas, bastaria mudar o número 5 pra 1000000. Viu como os arrays deixam nossas possibilidades de criar programas bem mais flexíveis?

Exemplo 4

Crie um array de 101 elementos. Em cada elemento do array, armazene o valor do dobro do índice. Ou seja, a variável num[x] deve ter armazenado o valor 2x. Depois, exibe a lista dos 100 números primeiros números pares.
#include <iostream>
using namespace std;

int main()
{
    const int ARRAY_SIZE = 101;
    int num[ARRAY_SIZE], cont;

    for(cont=0 ; cont<ARRAY_SIZE ; cont++)
        num[cont] = 2*cont;

    for(cont=1 ; cont<ARRAY_SIZE ; cont++)
        cout<<"Dobro de "<<cont<<": "<<num[cont]<<endl;

}
Os arrays sempre devem ser inicializados com um valor literal (um número diretamente) ou por uma variável, de preferência constante (const). Aliás, é recomendável você declarar uma constante no começo do programa e ficar usando variável durante o código, fica mais fácil para futuras alterações.

Exemplo 5

Peça para que 6 funcionários de uma empresa digitem seus salários. Em seguida, seu programa deve dizer quanto de imposto de renda cada um deles deve pagar por mês. A taxa é de 15%.
#include <iostream>
using namespace std;

int main()
{
    const int ARRAY_SIZE = 6;
    float func[ARRAY_SIZE];
    int cont;

    for(cont=0 ; cont<ARRAY_SIZE ; cont++){
        cout<<"Funcionario "<<cont+1<<": ";
        cin >> func[cont];
    }

    cout<<"Imposto a pagar: "<<endl;
    for(cont=0 ; cont<ARRAY_SIZE ; cont++)
        cout<<"Funcionario "<<cont+1<<": R$"<<func[cont]*0.15<<endl;

}

Ajude o C++ Progressivo

Que tal apoiar e fazer crescer o ensino da programação no Brasil ?

Ajudar nosso país a crescer e se desenvolver cada vez mais, tecnologicamente?

Clica abaixo pra saber mais!

Apoiar o Projeto Progressivo