int* foo(int value)
{
static int arr[2];
arr[0]=value;
arr[1]=-value;
return arr;
}

int main()
{
int* p=foo(7);
cout<<p[0]<<'\n'<<p[1]<<'\n';
}
In diesem teil zeigt der Zeiger *p auf die funktion foo(int value) ,
und in dem Zweiten Teil soll p[0] ausgegeben werden , doch wie soll man p[0] ausgeben wenn es gar nicht in der funktion foo ist , es gibt kein parameter p[0] nur arr[0] oder wie soll dass gehen ???
Danke im voraus

ehrlich gesagt, ich verstehe die frage nicht. falls du wissen willst, wie es sein kann, daß in main() mit p[0] und p[1] der inhalt von arr[] ausgegeben werden kann: in c++ sind arrays eigentlich zeiger. arr ist eigentlich ein int* auf zwei im speicher aufeinanderfolgende ints. und dieser zeiger wird von foo() zurückgegeben und p zugewiesen. daß der speicher von arr nach verlassen von foo() überhaupt noch gültig ist (normalerweise werden lokale variablen beim verlassen der funktion ja gelöscht), liegt daran, daß arr als static deklariert ist. das hat zur folge, daß arr wie eine globale variable angelegt wird, nur mit dem unterschied, daß sie wie eine lokale variable ausschließlich in foo() sichtbar ist.

int *p=foo(parameter)

schreibe , dann greift mein Zeiger immer auf die variablen die in foo deklariert sind zu , oder wie sieht dass aus ???
Und wenn dasss stimmt wie kann ich dann wählen auf welche variable ich zugreifen soll .
Danke im voraus

UNd noch was , wenn ich also

int *p=foo(parameter)

schreibe , dann greift mein Zeiger immer auf die variablen die in foo deklariert sind zu , oder wie sieht dass aus ???

Ja.

Und wenn dasss stimmt wie kann ich dann wählen auf welche variable ich zugreifen soll .

Indem du in der Funktion angibst, welche Adresse zurückgegeben wird:

int* foo(int value, bool larr)
{
  static int sh[2];
  static int ln[4];
  if(larr)
  {
    ln[0]=value;ln[1]=value/2;ln[2]=-value/2;ln[3]=-value;
    return ln;
  }
  else
  {
    sh[0]=value;sh[1]=-value;
    return sh;
  }
}

(bei "p=foo(x,true);" bekommst du das 4-elementige Array ln, bei "p=foo(x,false);" das 2-elementige sh)

sagen wir mal es zeigt auf ürgend was , auf was zeigt es dann

also, jetzt verstehe ich die frage beim besten willen nicht mehr

versuche bitte, dich klarer auszudrücken.

p enthält den zeiger, den die funktion foo per return-befehl zurückgegeben hat. in der funktion foo(), die du gepostet hast, ist der rückgabewert ein zeiger auf arr, weil foo() den den zeiger auf arr per return zurückgibt. p zeigt nicht automatisch auf die funktion oder deren variablen.

int *foo()
{
...
}

Auf was zeigt dann der zeiger foo() , alsoi jetzt ist eine funktion ein Zeiger .
Auf was kann er jetzt zeigen ???????????????????
Das wäre meine haupt frage
Lightning

bei deinem Beispiel gibt es keinen "zeiger foo()". foo ist eine Methode, die einen Zeiger auf ein int zurückliefert (und das int existiert hoffentlich noch nach Verlassen der Methode). Wie das mit dem zurückliefern funktioniert, hat ja CStoll bereits ausführlich gezeigt.

Ansonsten hier einiges an Literatur:
http://tutorial.schornboeck.net/zeiger.htm
http://www.pronix.de/pronix-623.html
http://www.c-plusplus.net/forum/viewtopic-var-t-is-124532-and-start-is-0.html

MfG

GPC

alsoi jetzt ist eine funktion ein Zeiger

da hast du was falsch verstanden. int *foo() bedeutet, daß der rückgabewert der funktion einzeiger ist. und was für einen wert die funktion zurückgibt, bestimmt das programm in der funktion per return-befehl.

wenn du eine variable per int *foo deklarierst, dann ist foo ein zeiger auf ein int. wenn du eine funktion per int *foo() deklarierst, dann ist foo() immer noch genauso eine funktion wie int foo(), nur daß sie alstelle eines int eben einen int* zurückgibt.