Ajude nosso projeto a se manter online.

Como usar Arrays em Funções

Neste tutorial de nossa seção de Arrays em C++, vamos aprender como trabalhar com arrays e funções, aprendendo como passar um array como argumento, como retornar e receber um array, como copiar, comparar e alterar arrays, usando funções.

Arrays como argumentos para Funções

O que diferencia, basicamente, uma variável inteira de um array de inteiros? Vejamos as declarações:
  • int num;
  • int num[2112];

Hora, é o par de colchetes, com um número dentro. Concorda?
Quando passamos um inteiro para uma função, seu protótipo fica:
  • show(int num); ou show(int);

Então, como você pode suspeitar, para passarmos um array como argumento, você pode fazer, no protótipo:
  • show(int num[]); ou show(int []);

Veja bem, você passa só com o par de colchetes, ok? Sem número dentro.
Já no código da função, o cabeçalho é com: show(int num[]);

Vamos dar um exemplo de código de um array que declaramos na main(), de inteiros, passamos pra função show() e ela exibe esses elementos:

Olhe como invocamos a função: show(num);
O nome do array é 'num', ok? Não faça: show(num[]) pra invocar a função.
#include <iostream>
using namespace std;

void show(int []);

int main()
{
    int num[]={10, 20, 30};

    show(num);

    return 0;
}

void show(int num[])
{
    int count;

    for(count=0 ; count<3 ; count++)
        cout<<"Elemento "<<count+1<<": "<<num[count]<<endl;
}
Pegou? Porém, aí tem um problema...a função 'já sabia' de antemão que o array tinha 3 elementos. Mas, ora, as funções não tem bola de cristal. Por isso, é comum e de praxe, passarmos junto com o array, o seu tamanho também, para as funções:
#include <iostream>
using namespace std;

void show(int [], int);

int main()
{
    int num[]={10, 20, 30, 40, 50};
    int size=5;
    show(num, size);

    return 0;
}

void show(int num[], int size)
{
    int count;

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

Quando estudarmos a classe vector, em STL, vamos ver tipos mais dinâmicos e poderosos, de arrays, e não precisaremos nos preocupar de informar o tamanho do array, pois será uma informação própria da estrutura que vamos usar.

Retornar Array: Passagem por referência

Vamos criar um array chamado num[], inserir alguns números.
Em seguida, vamos passar para a função doub(), que vai dobrar cada elemento do array, e imprimir ele dobrado.

Em seguida, imprimimos, agora na main(), novamente o array num:
#include <iostream>
using namespace std;

void doub(int [], int);

int main()
{
    int num[]={10, 20, 30, 40, 50};
    int size=5, count;

    doub(num, size);

    for(count=0 ; count<size ; count++)
        cout<<num[count]<<"  ";

    return 0;
}

void doub(int num[], int size)
{
    int count;

    for(count=0 ; count<size ; count++)
        num[count] *= 2;

    for(count=0 ; count<size ; count++)
        cout<<num[count]<<"  ";

    cout<<endl;
}
O resultado é:
20  40  60  80  100
20  40  60  80  100

Ora, veja só! Você passou um array pra função. Dentro dela, ela dobrou.
Quando voltou da função, pra main(), e você imprimiu novamente o array, ele estava dobrado.
Ou seja: sua função mexeu no array.

Embora você tenha passado somente o nome do array, ela alterou o array original. Ou seja: quando passamos um array pra uma função, essa passagem é por referência. Quando passamos o nome do array pra função, o C++ passa o endereço real do array. Assim, a função altera aquela posição da memória, diretamente, e não uma cópia do valor (como ocorre na passagem por valor).

Isso ocorre por questões de eficiência, visto que levaria muito tempo pra fazer uma cópia dos arrays passados para as funções (no dia-a-dia, trabalhamos com arrays muuuito grandes mesmo).
Ok? C++ passa o array por referência, não se esqueça!

Como copiar Arrays

Muitas vezes, queremos fazer algumas coisas com arrays, mas sem alterá-los.
Por exemplo, vamos supor que tenhamos um array 'num' de inteiros, e queiramos um outro array onde cada elemento seja o triplo do valor de cada elemento do array 'num'.

O que podemos fazer é primeiro criar uma cópia de 'num', vamos chapar de 'copy', e pimba, mandamos a 'copy' para uma função que triplica os elementos. Como a passagem é por referência, ela vai alterar os valores da 'copy' e nem vai ficar sabendo da existência de 'num', que fica inalterado.

Para fazer uma função 'copyArray' que faz uma cópia de um array, precisamos passar os dois arrays como argumento para a função, bem como o tamanho deles, que deve ser necessariamente o mesmo. Depois, basta copiar elemento por elemento, com um laço.

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

void copyArray(int [], int [], int);
void triple(int [], int);

int main()
{
    int num[]={10, 20, 30, 40, 50}, copy[5];
    int size=5, count;

    copyArray(num, copy, size);
    triple(copy, size);

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

    cout<<"\nArray triplicado: "<<endl;
    for(count=0 ; count<size ; count++)
        cout<<copy[count]<<"  ";

    return 0;
}

void copyArray(int num[], int copy[], int size)
{
    int count;

    for(count=0 ; count<size ; count++)
        copy[count] = num[count];
}

void triple(int copy[], int size)
{
    int count;

    for(count=0 ; count<size ; count++)
        copy[count] *= 3;

}
Resultado:
Array original:
10  20  30  40  50 
Array triplicado:
30  60  90  120  150

Se você realmente quiser preservar o array original 'num' e quiser mesmo garantir que ele não seja alterado, pode declará-lo e usá-lo como sendo do tipo const:
No cabeçalho: void copyArray(const int [], int [], int);
Na declaração da função: void copyArray(const int num[], int copy[], int size) {...}
No declaração do array: const int num[]={10, 20, 30, 40, 50};

Nenhum comentário:

Postar um comentário