Mit der Funktion stimmt was nicht

CStoll

moves ist ein Array, die Funktion soll/will aber ein normales int zurückgeben. Wenn du dazusagst, was die Funktion machen soll, können auch Gegenmaßnahmen vorgeschlagen werden.

1. Du gibts moves zurück und moves ist vom typ int*. Deine Funktionen gibt aber ein int zurück.

Du musst also ein int* zurückgeben lassen.

2. Deine Variable moves ist in der Funktion lokal, d.h. das sie danach nicht mehr existiert, also macht es keinen sinn ne adresse zurückzugeben wo "nichts" ist...

Oh daran liegt es.
Na ja, was die Funktion macht, ist doch recht einfach zu erkennen? Bekommt einen Integer, führt darauf eine Reihe von Additionen und Subtraktionen aus und gibt die Ergebnisse (bzw soll) als Array wieder zurückgeben.

Wie kann ich die Funktion überzeugen, das Array zurückzugeben?

Ich danke dir Freak_Coder, gleich mal ausprobieren

Gib ein Array mit mit und fülle es dann in der Funktion.

void movesKnight(int position, int* moves);

Edit: Am besten auch Arraygröße mitgeben und in der funktion auf passen das du nicht die grenzen überschreitest

und stell vor allem deine compilermeldungen auf englisch. versteht doch kein mensch

Hm, da liegt der Hund.
Ich kann also innerhalb einer Funktion eine lokale Variable deklarieren und zurückgeben, wenn ihr Typ mit dem der Funktion übereinstimmt, mit einem Array ist dies aber nicht möglich?

CStoll

Du kannst eine Variable problemlos zurückgeben, weil dabei der Wert kopiert wird. Arrays verhalten sich allerdings etwas (hmm) exotisch, indem sie zu Zeigern auf den Arrayanfang uminterpretiert werden. Und einen Zeiger auf eine lokale Variable solltest du besser nicht übergeben, weil der zugehörige Speicherbereich am Funktionsende wieder freigegeben wird.

Ja! Und das kommt davon:

Hast du sowas hier:

int sinn()
{
   int t = 2;
   return t;
}

//...

int a = sinn();

Dann wird ja die Zahl zurückgeben.
Dann ist egal ob die Variable lokal ist den der Wert wird zwischengespeichert und dann a zugewiesen.

t gibt es danach nicht mehr aber das ist egal du hast ja dann deinen Wert.

Sieht das ganze aber jetzt so aus:

int* sinn()
{
   int t = 2;
   return &t;
}

// bzw so
int* sinn()
{
   int t[2] = { 2,3 };
   return t;
}
// oder wie auch immer

//...

int *a = sinn();

Dann wird die Adresse zurückgegeben wo t steht, nicht der Wert, also wird die Adresse zwischengespeichert und a zugewiesen. Aber da ja t lokal ist gibt es diesen "ort" nicht mehr wo die Adresse hinzeigt, d.h. a zeigt ins -blbalbla-.

Es ist ein Unterschied ob der Wert oder eine Adresse zurückgegeben wird.
Der Wert ist immer gültig die Adresse muss es aber nicht sein.

Hoffe ich konnte es dir verständlich machen

Dank dir für die Erklärung. Bin das von höheren Sprachen ganz anders gewöhnt.

bei Funktionen, die ein Array zurückgeben sollen, muss ich ein Array global deklarieren, und dann mit als Argument einer void-Funktion übergeben?

CStoll

Sebastian_2 schrieb:

bei Funktionen, die ein Array zurückgeben sollen, muss ich ein Array global deklarieren, und dann mit als Argument einer void-Funktion übergeben?

Im Prinzip ja. Aber du kannst das Array auch lokal zur aufrufenden Funktion deklarieren - und es muß keine void-Funktion sein

Alternativ wäre es noch möglich, das Array auf dem Heap oder statisch anzulegen:

//statisches Array:
//Nachteil: Der nächste Aufruf überschreibt deine Daten
int* st_func()
{
  static int data[10];
  //...
  return data;
}

//Heap-Array:
//Nachteil: Der Aufrufer muß sich darum kümmern, den Speicher wieder freizugeben (mit free)
int* hp_func()
{
  int* data = malloc(10*sizeof(int));
  //..
  return data;
}

Super, Danke
Tolle Erklärung & Hilfe

Muss leider nochmal Hilfe bemühen..

Wie kann ich den Rückgabewert dieser Funktion jetzt einem Array zuweisen? Habe ziemlich lange in meiner PDF herumgesucht - soweit ich es verstanden habe, gibt eine Funktion, die mit int* deklariert wird, nur den Zeiger auf den Rückgabewert zurück.
Ich weiß zwar nun, mit welchem Operator ich die Adresse einer Variable bekomme, aber wie bekomme ich die Variable zu einer Adresse, so dass ich mit ihr arbeiten kann? (z.B. Addition durchführen)

CStoll

a) Du kannst direkt mit dem Rückgabewert arbeiten:

int* fval=st_func()
for(int i=0;i<10;++i)//die Größe mußt du 'wissen' ;)
  printf("%i ",fval[i]);

b) Du kopierst den Rückgabewert in ein lokales Array (entweder per for() oder mit memcpy:

int fval[10];
memcpy(fval,st_func(),10*sizeof(int));
//weiterarbeiten wie oben

Was günstiger ist, hängt von der verwendeten Funktion ab - wenn sie einen Pointer auf eine statische Variable liefert, empfiehlt sich mempcy, wenn sie Heap-Speicher bereitstellt, ist die Variante a praktischer (du mußt nur aufpassen, daß du am Ende der Arbeit free() aufrufst).