Matriz de retorno de C ++ da function

Eu preciso ler em uma matriz para minha function, extrair os dados e, em seguida, retornar uma matriz da function.

A matriz sempre terá apenas 2 valores.

Isto é o que eu quero fazer no conceito:

int myfunction(int my_array[1]) { int f_array[1]; f_array[0] = my_array[0]; f_array[1] = my_array[1]; // modify f_array some more return f_array; } 

Eu li sobre pointers etc, mas tenho muito confuso e gostaria de receber um exemplo muito básico de como melhor abordar isso!

Obrigado!

Você não pode retornar um array embutido em c ++.

Se você é novo no c ++ e fica confuso sobre pointers, não quer usar matrizes (pelo menos não arrays embutidos). Use std::vector , ou se você tiver um certo número de elementos e quiser expressar isso (e realmente precisar do melhor desempenho) use boost::array (ou mesmo std::array , se você programar em C++11 (se você não sabe se programa ou não em C++11 chances são de que você não saiba) Por exemplo:

 std::vector myfunction(const std::vector& my_array) { std::vector f_array; for(int i = 0; i < my_array.size(); ++i) f_array.push_back(my_array[i]); return f_array; } boost::array myfunction(const boost::array& my_array) { boost::array f_array; f_array[0] = my_array[0]; f_array[1] = my_array[1]; return f_array; } 

Você pode então tornar seu código de cópia mais simples (procure os construtores e funções de membro de qualquer class que você decida usar, assim como os algoritmos STL). Exemplo:

 std::vector myfunction(const std::vector& my_array) { std::vector f_array(m_array); ... return f_array; } 

Como outro ponto seu código tem um bug: você define my_array como int my_array[1] , significando seu array com um elemento, mas você acessa dois elementos ( my_array[0] e my_array[1] ), o access a my_array[1] está fora dos limites ( int foo[N] tem lugar para N itens, começando no índice 0 e indo para o índice N-1 ). Eu suponho que você realmente quer dizer int my_array[2] .

 std::array myfunction(int * my_array) { std::array f_array; f_array[0] = my_array[0]; f_array[1] = my_array[1]; // modify f_array some more return f_array; } 

Note que, como parâmetro, int my_array[1] é exatamente idêntico a int my_array[1000] , int my_array[] ou int * my_array . É apenas um ponteiro, e o valor do tamanho não tem sentido. Isso não se aplica a declarações de matriz regulares, apenas parâmetros.

Para garantir que você esteja sendo transmitido somente matrizes de tamanho 2, é possível usar a matriz por referência:

 std::array myfunction(int (&my_array)[2]) 

Se você precisar de apenas dois valores, eu daria uma olhada no std :: pair , afinal, é para isso que está lá. Ele também tem a semântica da cópia apropriada (mover em c ++ 11) para fazer isso funcionar corretamente.

Se você vai ter estritamente 2 elementos no array eu sugiro std::pair

 typedef std::pair int_pair; int_pair myfunction(int_pair ip) { ip.first *= 0.12; ip.second -= 355; return ip; } 

Você não pode retornar uma matriz em C ou C ++.

Como você está trabalhando em C ++, use uma class de contêiner em vez de uma matriz bruta. Um std::vector ou um boost::array seriam boas opções.

Você não pode retornar uma matriz de uma function, mas você pode adicionar um segundo argumento para a matriz “out”:

 void foo(int array_in[], int array_out[], int array_size) { for (int i = 0; i < array_size; i++) array_out[i] = array_in[i]; } 

Um array com dois valores deve ser declarado como int my_array[2] . De qualquer forma, você não pode copiar matrizes por valor. Você disse que só terá dois ints no object. Então eu sugiro que você use pair .

 using namespace std; pair myfunction(pair my_array) { pair f_array; f_array.first = my_array.first; f_array.second = my_array.second; // modify f_array some more return f_array; } 

C ++ não permite retornar uma matriz inteira como um argumento para uma function. No entanto, você pode retornar um ponteiro para uma matriz, especificando o nome da matriz sem um índice.

Para retornar uma matriz unidimensional de uma function, você teria que declarar uma function retornando um ponteiro como mostrado abaixo:

 int * myfunc(){ static int arr[size_of_array]; /* code for manipulation of arr */ return arr; } 

As variables ​​declaradas dentro de um corpo de function são destruídas assim que deixamos o bloco de funções. Portanto, precisamos declarar int arr[size_of_arr] como static . Isso irá alocar memory para int arr[size_of_arr] no heap e garantir que ele não seja destruído assim que sairmos do bloco de funções.

A maneira de chamar o myfunc() é descrita abaixo:

 int *myarray; myarray=myfunc(); 

Agora a matriz retornada por myfunc() é armazenada em myarray