Zeiger

Ja so was in der Art habe ich gemeint , kannst es mir ein bisschen bildlicher erklären dass mit , dem dass ein array ein zeiger auf int ist . 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 ???
Und wenn dasss stimmt wie kann ich dann wählen auf welche variable ich zugreifen soll .
Danke im voraus

KOKOKOLLKOK schrieb:

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)

Wenn man einen zeiger
int *p=foo(parameter), macht dann zeigt der zeiger auf die variablen der funktion foo .
Doch was passiert wenn man eine funktion deklariert und zwar so :
int *foo(parameter)
{
..
}
, sagen wir mal es zeigt auf ürgend was , auf was zeigt es dann , ( könnt ja eure beispiele einsetzen )
Bitte um erklärung . Wenn eine funktion ein zeiger ist , oder so ?????

Konfusius

Lightning schrieb:

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.

Ach so , also ein Zeiger er zeigt immer auf einen rückgabe wert der funktion , und da eine funktion ( in den meisten fällen ) , einen rückgabe wert hat , wird p in diesem falle auf arr zeogen . Doch meine zweite frage ist , also nicht abhängigi von diesem Fall , wenn eine funktion so deklariert wird

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

Also wie geht dass nun ??

GPC

Hallo,

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

Wie jetzt also , ist *foo(), kein zeiger sondern eine methode wie in einer klasse, doch was ist in *foo() ein zeiger, einer ihrer variablen oder parameter oder iwe geht dass ??
THX

Konfusius

KOKOLOKO schrieb:

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.

Ach so jetzt habe ich es verstanden , danke noch mals
Lightning