using arrays with functions c
Tudo o que você precisa saber sobre arrays com funções em C ++:
Neste tutorial, discutiremos como os arrays podem ser usados com funções em C ++. Geralmente, os arrays podem ser passados para funções como argumentos da mesma maneira que passamos as variáveis para funções.
Mas a avaliação de parâmetros formais é um pouco diferente quando se trata de matrizes. Antes de realmente explorar a passagem de matrizes para funções, precisamos discutir brevemente o conceito de um ponteiro para uma matriz.
=> Verifique os tutoriais detalhados de treinamento C ++ aqui.
O que você aprenderá:
- Ponteiro para uma matriz
- Passando matrizes para funcionar
- Retornando Arrays de Funções
- Conclusão
- Leitura recomendada
Ponteiro para uma matriz
Considere a seguinte matriz contendo os primeiros cinco números da sequência de Fibonacci.
int fibSeq[5] = {1,1,2,3,5};
Vamos declarar um ponteiro fibPtr para apontar esta matriz.
int* fibPtr; fibPtr = fibSeq;
Quando imprimimos o conteúdo de fibPtr, a saída será o primeiro elemento do array fibSeq. Isso ocorre porque o nome da matriz sem colchetes é avaliado como um ponteiro para o primeiro elemento da matriz. Assim, no exemplo acima, o nome “fibSeq” aponta para o primeiro elemento da matriz “fibSeq”.
Abaixo está uma representação pictórica do mesmo:
Conforme mostrado na representação pictórica acima, fibPtr aponta para o primeiro elemento da matriz. Assim, usando a aritmética de ponteiros, podemos imprimir todos os elementos do array usando apenas fibPtr.
Por exemplo, expressão * (fibPtr + 1) apontará para o segundo elemento da matriz e assim por diante.
o que pode reproduzir arquivos .swf
Vamos colocar isso em um programa e verificar a saída de “fibSeq” e “fibPtr”:
#include #include using namespace std; int main() { int fibSeq[5] = {1,1,2,3,5}; int* fibPtr; fibPtr = fibSeq; cout<<'
fibSeq points to :'<<*fibSeq; cout<<'
fibSeq[0]: '<<*fibPtr; cout<<'
fibSeq[1]: '<<*(fibPtr + 1); cout<<'
fibSeq[2]: '<<*(fibPtr + 2); cout<<'
fibSeq[3]: '<<*(fibPtr + 3); cout<<'
fibSeq[4]: '<<*(fibPtr + 4); } }
Resultado:
fibSeq aponta para: 1
fibSeq [0]: 1
fibSeq [1]: 1
fibSeq [2]: 2
fibSeq [3]: 3
fibSeq [4]: 5
No exemplo acima, declaramos uma variável de ponteiro fibPtr e, em seguida, fazemos com que ela aponte o array atribuindo o nome do array a fibPtr. Quando fazemos isso, fazemos o ponto fibPtr para o primeiro elemento da matriz. Em seguida, imprimimos todos os valores de um array usando fibPtr.
Passando matrizes para funcionar
Quando estamos lidando com funções, passamos arrays para a função de maneira semelhante à como passamos variáveis para a função. Mas não passamos a variável de array do tipo [].
Em vez disso, passamos o ponteiro para o array, ou seja, o nome do array que aponta para o primeiro elemento do array. Então, o parâmetro formal que aceita esse ponteiro é na verdade uma variável de matriz. Conforme passamos o ponteiro, podemos modificar diretamente o array dentro da função.
Considere o seguinte programa que calcula o quadrado de cada elemento dos primeiros cinco elementos na sequência de Fibonacci para demonstrar a passagem de uma matriz para funcionar.
#include #include using namespace std; void fibSeqSquare(int fibSeq[]) { for(int i=0;i<5;i++) { fibSeq[i] *= fibSeq[i]; } } int main() { int fibSeq[5] = {1,1,2,3,5}; fibSeqSquare(fibSeq); for(int i=0;i<5;i++) { cout<No exemplo acima, calculamos o quadrado de cada elemento em uma sequência de Fibonacci. Este quadrado é calculado dentro de uma função. Conseqüentemente, passamos o nome do array para a função “fibSeqSquare” enquanto chamamos a função principal. Dentro da função, calculamos os quadrados de cada elemento.
Como passamos a referência ao array por meio de um ponteiro, quaisquer modificações que fizermos no array dentro da função refletirão o array. Portanto, quando imprimimos o array na função principal, obtemos os quadrados de cada elemento como saída.
No exemplo acima, vimos que o argumento da matriz (parâmetro formal) da função fibSeqSquare não especifica o tamanho da matriz, mas apenas os colchetes ([]) para indicar que é uma matriz. Esta é uma maneira de especificar os argumentos da matriz.
Outra maneira de especificar o argumento da matriz na lista de parâmetros formal é especificando o tamanho da matriz dentro dos colchetes. Ambos os argumentos funcionam de forma semelhante. Essas são simplesmente as duas maneiras pelas quais especificamos os argumentos da matriz.
O exemplo a seguir mostra um argumento Array especificado com size.
#include #include using namespace std; void displayFibSeq(int fibSeq[5]) { for(int i=0;i<5;i++) { cout<O exemplo acima tem uma função para exibir a sequência de Fibonacci. A função tem um parâmetro como array, onde também especificamos o tamanho do array.
Também podemos passar arrays multi-dimensionais para funções da mesma maneira mostrada acima.
programa para copiar dvds para o computador
Retornando Arrays de Funções
Quando se trata de retornar um array da função, C ++ não nos permite retornar um array inteiro da função. No entanto, podemos fazer uma função para retornar um ponteiro para o array. Mas há um problema nisso.
Considere o seguinte trecho de código:
int* funcArray() { int arr[3] = {1,2,3}; return arr; } int main() { int* aryPtr = funcArray(); cout< Embora o programa acima simplesmente retorne o ponteiro para o primeiro elemento de uma matriz da função, ele não funciona conforme o esperado. Não podemos garantir que o programa nos dará a saída correta. Ele pode ou não fornecer a saída correta.
lista circular duplamente ligada c ++
Isso ocorre porque estamos retornando a variável local da função e não temos certeza se ela estará no escopo no momento em que for retornada ou não.
Portanto, em poucas palavras, C ++ não favorece o retorno de matrizes de funções.
Se precisarmos retornar arrays da função, precisamos usar qualquer um dos seguintes métodos:
# 1) Retorno de matrizes alocadas dinamicamente
Podemos retornar o ponteiro do array do array alocado dinamicamente. Usamos o operador ‘novo’ para alocar dinamicamente a matriz. Como é uma matriz dinâmica, estará no escopo, a menos que ‘excluamos’ a matriz. Portanto, o programa funcionará bem quando retornarmos o array.
Isso é mostrado no exemplo a seguir.
#include #include using namespace std; int* funcArray() { int* arr = new int[3]; arr[0]=1; arr[1]=2; arr[2]=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Resultado:
1 2 3
# 2) Retorno de matrizes estáticas
Como variáveis / arrays estáticos têm escopo em todo o programa, também podemos retornar arrays estáticos de funções. Podemos dar um exemplo para demonstrar isso. Este é o mesmo que o exemplo anterior, com a única diferença de que neste exemplo usamos um array estático em vez do array alocado dinamicamente.
#include #include using namespace std; int* funcArray() { static int arr[3]; arr[0]=1; arr[1]=2; arr[2]=3; return arr; } int main() { int* aryPtr = funcArray(); cout< Resultado:
1 2 3
Observação : Também podemos usar uma estrutura para envolver a matriz dentro dela e, em seguida, retornar essa estrutura. Dessa forma, retornaremos naturalmente um array de uma função. Mas esse não é um método muito viável de retornar matrizes.
Conclusão
Portanto, neste tutorial, discutimos os arrays com relação às funções em detalhes. Esperamos que este tutorial tenha ajudado a esclarecer todas as dúvidas e equívocos sobre arrays e funções C ++.
=> Confira o guia de treinamento perfeito C ++ aqui.
Leitura recomendada