C++: Rückgabe eines Arrays

Computer: Software & Programmierung C/C++
#1

Hallo,

in einer Funktion fülle ich ein Char* Array.
Wie kann ich dieses Array übergeben?

Ich muß doch irgendwie mit zeigern arbeiten?!
deshalb habe ich als Rückgabetyp der Funktion char*.

aber wie kriege ich dann den zwieten Eintrag des Arrays??

Danke im voraus,

Jan

PS: Und weiß zufällig jemand, wie man ein anderes Programm (kein c/c++) aus einem C+±Programm startet (und diesem evtl. auch noch Parameter mitteilt)?

#2

Hallo,

in einer Funktion fülle ich ein Char* Array.
Wie kann ich dieses Array übergeben?

Ich muß doch irgendwie mit zeigern arbeiten?!
deshalb habe ich als Rückgabetyp der Funktion char*.

aber wie kriege ich dann den zwieten Eintrag des Arrays??

Danke im voraus,

Jan

Servus Jan,

es ist korrekt, den Rückgabetyp auf char* zu setzen.

Prinzipiell solltest du dich aber wohl erst mal mit Zeigern unter C/C++ vertraut machen :wink:

Auf das zweite Element des Arrays kannst du folgendermassen zugreifen

char\* pchArray = function();

// Erstes Element.
char chA = \*pchArray;
char chB = pchArray[0];

// Zweites Element.
char chC = \*(pchArray + 1);
char chD = pchArray[1];

Du kannst also auf zwei Arten auf das Array zugreifen.

  1. Über den Zeiger.
  2. Über den Index.

Beides liefert das gleiche Ergebnis.

Dirk
cha

PS: Und weiß zufällig jemand, wie man ein anderes Programm
(kein c/c++) aus einem C+±Programm startet (und diesem evtl.
auch noch Parameter mitteilt)?

#3

Hallo,

Du machst Deinem Namen alle Ehre.

Aber es klappt nicht.
Ich habe folgendes:

char *zerlegen(char * args)
{
char *param[5] ;

//Das wird jetzt gefüllt

return param[0];
}

und im main:
{
char *ptr;
char *args[5];
ptr=zerlegen(arg1);
args[0]=*ptr;
args[1]=ptr[1];
}

Ich kriege entweder nur den ersten Eintrag und kann mir diesen Zeichenweise mit ++ptr angucken
oder eine Fehlermeldung „Konvertierung von char nach char * nicht möglich“

Also ist da noch irgendwo der Wurm drin…

bis dann,
Jan

#4

char *zerlegen(char * args)
{
char *param[5] ;

//Das wird jetzt gefüllt

return param[0];
}

Wenn du ein Char-Array lokal in einer Funktion anlegst, kannst du nicht den Zeiger darauf zurückgeben, weil das Array beim Verlassen der Funktion zerstört wird.

Um ein String zurückzugeben, gibs diese Möglichkeiten:

  1. Stringklassen verwenden:
    zum Beispiel in Windows:

CString zerlegen(char * args)
{
CString param;
param=„xyz“;
return param;
}

  1. Das Chararray extern anlegen und pointer übergeben:
    void zerlegen(char * args, char *ret, int retlen)
    {
    strncpy(ret,„xyz“,retlen);
    }

Aufruf mit:

char param[100];
zerlegen(args,param,sizeof(param));

diese Vorgehensweise ist eigentlich in C die üblichste. strcpy funktioniert auch genauso.

  1. Über static:

char* zerlegen(char * args)
{
static char param[10];
strcpy(param,„xyz“);
return param;
}

ACHTUNG! diese Funktion ist dann nicht Multitaskig-Fähig. Wenn mehrere Threads gleichzeitig diese Funktion aufrufen, kann Müll bei rauskommen, weil nur ein Param global vorhanden ist.

  1. Nich zu empfehen über malloc:

char* zerlegen(char * args)
{
char *param = (char*) malloc(10);
strcpy(param,„xyz“);
return param;
}

der Aufrufer muss dann den pointer nach gebrauch mit free freigeben. Hohe Gefahr von Speicherlecks! Sollte man IMHO auf jeden Fall die Finger von lassen!

cu
Steffen

#5

re nochma. Hab mich verguckt, du willst ja CHAR* ARRAYS zurückgeben und keine char-arrays.

Die Problematik ist aber die Gleiche, nur bei char* -arrays müssen viele Pointer zurückgegeben werden…

machs doch per Übergabe, die Grösse der Parameterliste ist ja bekannt und begrenzt???

void zerlegen(char * args, char *param[], int maxparam )
{
//füllen, bis maximal maxparam
param[0] = (char*) …
param[1] = (char*) …
}

und im main:
{
char *ptr;
char *args[5];
zerlegen(arg1,args,5);
}

cu
Steffen

1 Like
#6

Moin,

in einer Funktion fülle ich ein Char* Array.
Wie kann ich dieses Array übergeben?

Ich gehe mal davon aus, daß Du ein char*-Array meinst.
Du solltest das Array im Hauptprogramm anlegen und einen Zeiger darauf an die Funktion übergeben.

int main(int argc, char\* argv[])
{
 char\* myArray[5];

 fillArray(myArray, 5);
}

void fillArray(char\*\* yourArray, int size)
{
 for (int i = 0; i 
(Kann das mal jemand checken? Nicht, daß ich ein \* vergessen habe.)



> > Ich muß doch irgendwie mit zeigern arbeiten?!

Das läßt sich in C nicht ganz vermeiden.

Thorsten
#7

Moin,

> yourArray[i] = wasImmerDuWillst(i)

Womit das Problem natürlich nur verschoben wird. Was ich damit meine: Hier kannst Du den Array füllen.

Thorsten

#8

Danke
Das war genau das richtige.

Jan

#9

HI,

Habs zwar nicht hanz so, aber das Prinzip ist dasselbe.

Thanx,
Jan

[Bei dieser Antwort wurde das Vollzitat nachträglich automatisiert entfernt]