Retour tableau

Question

Comment renvoyer un pointeur vers un tableau et obtenir des valeurs à partir de cela?

int * getChange(int first[], int second[], int SIZE) { 
    int i = 0; 
    int * change = new int[2]; 
    for (i = 0; i < SIZE; i++) { 
     if (first[i] != second[i]) { 
      change[0] = first[i]; 
      change[1] = second[i]; 
     } 
     break; 
    } 
    return change; 
} 

function main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    int * change; 
    change = getChange(possibilities, myNumbers, 4); 
    printf("%i/%i\n", (change), (change+1)); 
} 

Malheureusement, la fonction semble retourner des adresses, des valeurs non ...

Answer 1

Essayez de changer

printf("%i/%i\n", (change), (change+1)); 

à

printf("%i/%i\n", *(change), *(change+1)); 

Dans la fonction printf vous devez utiliser un int comme paramètres, et non un int*. la variable change est un pointeur. Vous devez utiliser *change et, en utilisant des arithmétiques de pointeurs, *(change + 1)

Évidemment, n'oubliez pas de libérer la mémoire allouée.

Answer 2

printf("%i/%i\n", (change), (change+1)); 

Cela devrait être:

printf("%d/%d\n", *change, *(change + 1)); 

Answer 3

int* functionReturningArray(int *inputArray, int size) 
{ 
    int*outputArray = new int[20]; 
    return outputArray; 
} 

Mais il est préférable d'utiliser un vecteur dans les tableaux de type c + c puis style. Parce qu'il vous protège de beaucoup d'erreurs et qu'il est plus rapide d'écrire du code en utilisant un vecteur. Aussi, un tel functionReturningArray n'est pas très bon car il renvoie juste un pointeur au premier élément du tableau mais ne retourne pas la taille. Vous pouvez retourner la taille et un pointeur (deux arguments) par prédéfinir les et les pointeurs qui les traverse à votre fonction comme ceci:

void f(int**outputArray, int *size) 
{ 
    *outPutArray = new int[20]; 
    *size = 20; 
} 

Et comment il regarde avec un vecteur:

std::vector<int> func(const std::vector<int> &input) 
{ 
    std::vector<int> output; 
    output.push_back(5); 
    return output; 
} 

Vous pouvez également créez le vecteur sur un tas et renvoyez un pointeur dessus. Mais évitez d'utiliser std :: vector - utilisez std :: string à la place

Answer 4

Je pense que je l'écrirais un peu différemment (et notez que je m'en tiens aux concepts C seulement - en C++ j'aurais presque certainement faire les choses un peu différemment):

void getChange(int *first, int *second, int SIZE, int *change) { 
    int i = 0; 
    for (i = 0; i < SIZE; i++) { 
     if (first[i] != second[i]) { 
      change[0] = first[i]; 
      change[1] = second[i]; 
      break; 
     } 
    } 

    return;  
} 

function main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    int change[2]; 
    getChange(possibilities, myNumbers, 4, change); 
    printf("%i/%i\n", change[0], change[1]); 
} 

Si vous allouez change en dehors de getChange vous résoudre les problèmes de fuite de mémoire.

Answer 5

En C++, vous ne comptez pas utiliser des tableaux (int[] ou int*), parce qu'ils sont ennuyeux de plusieurs façons: vous devez passer autour du SIZE, ils sont généralement exceptions à risque (vous devez attraper l'exception, supprimez le tableau, puis relancez l'exception), et ils sont difficiles à utiliser correctement en tant que membres de la classe. Utilisez un conteneur de bibliothèque standard ou une plage d'itérateurs.

La façon idiomatiques de faire ce que vous essayez de faire serait d'utiliser les itérateurs et les paires:

template <typename IT_1, typename IT_2> 
std::pair<int,int> getChange(IT1 begin, IT1 end, IT2 begin2) 
{ 
    for (; begin != end; ++begin, ++begin2) 
    { 
    if (*begin != *begin2) return std::make_pair(*begin,*begin2); 
    } 
    return std::make_pair(0,0); 
} 

void main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    std::pair<int,int> change = getChange(possibilities, possibilities + 4, 
              myNumbers); 
    printf("%i/%i\n", change.first, change.second); 
} 

Notez que la deuxième séquence (myNumbers) devrait être au moins aussi longtemps que le premier séquence.Si vous n'êtes pas à l'aise avec itérateurs et des modèles de fonction encore, vous pouvez toujours utiliser des vecteurs à la place:

std::pair<int,int> getChange(std::vector<int> a, std::vector<int> b) { 
    for (int i = 0; i < a.size() && i < b.size(); ++i) 
    { 
    if (a[i] != b[i]) return std::make_pair(a[i],b[i]); 
    } 
    return std::make_pair(0,0); 
} 

void main() { 
    int _myNumbers[] = {1, 0, 2, 3}; 
    int _possibilities[] = {0, 1, 2, 3}; 

    std::vector<int> myNumbers(_myNumbers,_myNuymbers+4), 
        possibilities(_possibilities,_possibilities+4); 

    std::pair<int,int> change = getChange(possibilities, myNumbers); 
    printf("%i/%i\n", change.first, change.second); 
} 

Bien que ce dernier peut sembler un peu plus bavard que la version du tableau (après tout, il est la création de deux tableaux, puis copier leurs valeurs dans les vecteurs), gardez à l'esprit que l'initialisation d'un tableau à partir d'une constante est une occurrence assez rare: la plupart du temps, les tableaux (et vecteurs) sont initialisés dynamiquement par un morceau de code dédié à cela. Un tel code peut généralement être utilisé à la fois pour les tableaux et les vecteurs avec seulement des changements minimes.

Et, bien sûr, vous pouvez typedef à la fois std::pair<int,int> et std::vector<int> à des noms plus courts si vous finissez par les utiliser beaucoup.

Answer 6

Comme il a été dit, votre code est très faux dans de très nombreux niveaux. Je vais essayer d'expliquer.

Tout d'abord, si vous voulez retourner le même tableau, pourquoi en créer un nouveau? Qu'est-ce que tu veux faire, exactement? En second lieu, ce nouveau que vous faites ne devient jamais gratuit. Après les sorties de main(), toute la mémoire de votre application va être réclamée par le système d'exploitation, mais vous ne devriez pas compter dessus.

Le code qui Chowlett écrit est correct (+1 pour être agréable et pointant vers le problème d'allocation;), donc je vais simplement passer par votre code et signaler des choses

for(int i = 0 ; i < size i++) 
{ 
    if(first[i] != second[i]) 
    { 
     change[0] = first[i]; 
     change[1] = second[i]; 
    } 
    break; 
} 

qui ne fonctionne pas fais ce que tu veux. Il vérifie si first [0] est différent de second [0], puis frappe la rupture si cela est vrai ou non. Vous voulez la rupture dans le bloc d'instruction if. Ensuite, si vous voulez utiliser le contenu d'un tableau, vous devez l'indexer avec [], sinon vous faites référence à l'adresse mémoire du tableau et à ses index. Cela signifie que a été dit, que vous voulez faire

printf("%d/%d", changed[0], change[1]) 

Bien que ce qui a été dit ci-dessus que l'utilisation de C++ vecteurs est « meilleur » pour ce cas que les tableaux, je ne pense pas que ce soit la bonne réponse à votre question . Vous semblez apprendre à utiliser des tableaux, et les tableaux sont une partie importante du codage C et même C++ de la vie réelle. Vous les utiliserez beaucoup, ils sont WAY plus rapides que les vecteurs, et beaucoup de nombreuses bibliothèques que vous manipulez sont écrites en langage C, donc vous devrez les utiliser. Apprenez-vous un peu d'arithmétique de pointeur, et tout ira bien. N'oubliez pas de libérer la mémoire que vous allouez, ce n'est pas Java. Rappelez-vous qu'un dans

int a[3]; 

est plus comme un

int *a; 

que comme un

int a; 

qui explique pourquoi vous pouvez également faire

printf("%d/%d", *changed, *(changed + 1)); 

Lire la Kernighan et Ritchie. Happy hacking

---