Wie der Zugriff auf eine lokale variable aus einer anderen Funktion mit Zeigern?

myArray ist eine lokale variable und somit der Zeiger ist nur solange gültig, bis das Ende des Bereichs (das ist in diesem Fall, die Funktion getArray) ist Links. Wenn Sie später wieder darauf zugreifen bekommst du Undefiniertes Verhalten.

In der Praxis was passiert, ist, dass der Aufruf zu printf überschreibt den Teil des Stacks verwendet myArray und es enthält dann einige andere Daten.

Reparieren Ihre Codes müssen Sie entweder deklarieren Sie das array in einen Bereich, der lebt lange genug (die main Funktion in deinem Beispiel) oder um Speicher auf dem heap. Wenn Sie sich um Speicher auf dem heap, die Sie brauchen, um frei es entweder manuell, oder in C++ mit RAII.

Einer alternative, die ich übersehen (wahrscheinlich sogar das beste hier, sofern das array nicht zu groß) ist, um wickeln Sie Ihre array in ein struct und damit es einen Wert geben. Dann wieder es wird eine Kopie erstellt, die überlebt die Funktion zurück. Sehen tp1's Antwort für details.

InformationsquelleAutor CodesInChaos

Versuchen Sie so etwas wie, dass. Die Art und Weise Sie tun es "tötet" myArray verursachen, wenn es lokal definiert.

#include <stdio.h>
#include <stdlib.h>

void replaceNumberAndPrint(int * array) {
 printf("%i\n", array[0]);
 printf("%i\n", array[1]);
 printf("%i\n" , array[2]);
 free(array);
}

int * getArray() {
 int * myArray = malloc(sizeof(int) * 3);
 myArray[0] = 4;
 myArray[1] = 64;
 myArray[2] = 23;
 //{4, 65, 23};
 return myArray;
}

int main() {
 replaceNumberAndPrint(getArray());
}

Mehr : http://www.cplusplus.com/reference/clibrary/cstdlib/malloc/

Edit: Als Kommentare richtig darauf hingewiesen: Ein besserer Weg, es zu tun wäre :

#include <stdio.h>
#include <stdlib.h>

void replaceNumberAndPrint(int * array) {
    if(!array)
        return;

    printf("%i\n", array[0]);
    printf("%i\n", array[1]);
    printf("%i\n" , array[2]);
}

int * createArray() {
    int * myArray = malloc(sizeof(int) * 3);

    if(!myArray)
        return 0;

    myArray[0] = 4;
    myArray[1] = 64;
    myArray[2] = 23;
    return myArray;
}

int main() {
    int * array = createArray();
    if(array)
    {
        replaceNumberAndPrint(array);
        free(array);
    }
    return 0;
}

InformationsquelleAutor Muggen

Dein code ruft Undefiniertes Verhalten, weil myArray geht out of scope, sobald getArray() gibt, und jeder Versuch verwenden (dereferenzieren) die baumelnden Zeiger UB.

InformationsquelleAutor Prasoon Saurav

Richtige Weg, dies zu tun ist wie folgt:

struct Arr {
   int array[3];
};
Arr get_array() {
   Arr a;
   a.array[0] = 4;
   a.array[1] = 65;
   a.array[2] = 23;
   return a;
}
int main(int argc, char **argv) {
   Arr a = get_array();
   for(size_t i=0; i<3; i++)
       printf("%d\n", a.array[i]);
   return 0;
}

Zu verstehen, warum Sie brauchen, um dies zu tun, müssen Sie wissen, wie sizeof(array) funktioniert. C (und damit auch c++) hart versucht zu vermeiden, kopieren Sie das array, und Sie müssen die struct zu gehen, dass Vergangenheit. Warum das kopieren ist erforderlich, weil mit den Bereichen -- die get_array () - Funktion des scope verschwindet und jeder Wert noch benötigt von diesem Umfang kopiert werden müssen, um aufrufenden Bereichs.

InformationsquelleAutor tp1

C++ - Lösung:

"Kann ich keinerlei Zugriff auf eine lokale variable in einer anderen Funktion? Wenn ja, wie?"

Die Antwort ist Nein, auch nicht, nachdem die Funktion beendet wurde. Lokale Variablen werden zerstört.

In C++ den Umgang mit der Rückgabe von arrays ist, Sie zu verwalten in einer container wie ein std::array (Feste Größe) oder eine std::vector (dynamische Größe).

ZB:

void replaceNumberAndPrint(const std::array<int, 3>& array) {
    printf("%i\n", array[0]);
    printf("%i\n", array[1]);
    printf("%i\n", array[2]);
}

std::array<int, 3> getArray() {
    std::array<int, 3> myArray = {4, 65, 23};
    return myArray;
}

In der zweiten Funktion ist der zurückgegebene Wert wird optimiert durch den compiler, so dass Sie nicht den Preis zahlen, der eigentlich kopieren der array.

InformationsquelleAutor Galik