Problem mit char* array

Hallo,

ich habe ein (Verständnis-)Problem mit char *arrray und hoffe, dass mir jemand helfen kann.

Wieso sind bei nachfolgendem Beispielprogramm die char* Variablen myPtr[0] und myPtr[1] beide "EFGH", obwohl myPtr[0] zuerst "ABCD" zugewiesen wurde?

char *myPtr[6];
char myChar[10];

void setup() {
  Serial.begin(115200);

  strcpy(myChar, "ABCD");
  myPtr[0] = myChar;
  Serial.print("myPtr[0] = ");
  Serial.println(myPtr[0]);

  strcpy(myChar, "EFGH");
  myPtr[1] = myChar;
  Serial.print("myPtr[1] = ");
  Serial.println(myPtr[1]);

  Serial.println();

  Serial.print("myPtr[0] = ");
  Serial.println(myPtr[0]);

  Serial.print("myPtr[1] = ");
  Serial.println(myPtr[1]);
}

void loop() {
}

Ergebnis:

myPtr[0] = ABCD myPtr[1] = EFGH

myPtr[0] = EFGH myPtr[1] = EFGH

Bitte um eure Hilfe. Danke!

Gruß Retian

Deine Zeiger zeigen doch nur auf ein und das selbe CharArray. Kein Wunder, dass da das gleiche drin steht ;-)

Dann ist es also ein Verständnisproblem von mir.

Ich nahm an, dass ich mit der Deklaration von "char * myPtr[6]" ein Array mit 6 Elementen myPtr[0] bis myPtr[5] festlege, wobei jedes Element eine Zeichenkette speichern kann. Ist das so nicht richtig?

Ja, da hast du recht!
Das ist nicht richtig.

Du hast ein Char Array definiert.
Und ein Array mit 6 Zeigern. (ohne jegliche Zeichenketten)

Was du speicherst ist nur ein Zeiger auf einen C String. Dieser String muss wo anders als char Array existieren

Merke: Array Variablen sind Zeiger auf das erste Element.

myChar zerfällt bei bestimmten Operationen in einen char*. Aber es wird bei einer Zuweisung nur der Zeiger (d.h. eine Adresse kopiert). Nicht der gante String. Wenn du myPtr[index] = myChar machst dann wirkt sich jede Änderung in myChar auf myPtr aus

Wenn du ein Array aus Strings willst, dann ist eventuell ein zwei-dimensionales Array die Lösung:

char myStringArray[6][10];

Das sind 6 Strings mit je 10 Zeichen (inklusive Terminator! d.h. 9 sichtbare Zeichen). Und jeder String hat eigenen Speicher

Mir ist klar, dass ich normalerweise ein Array mit 6 Elementen in dieser Form deklariere:

char* ArrayName[6] = {"Text1", "Text2", "Text3", usw.};

Mein Problem aber ist, das ich zum Zeitpunkt der Deklaration die Inhalte der einzelnen Elemente nicht kenne, da diese erst im Zuge des Programms zugewiesen werden sollen. Deshalb habe ich beim Beispielprogramm um den Speicherplatz für die Zeichenketten zu reservieren, auch folgende Deklaration versucht, die aber auch nicht geholfen hat:

char *myPtr[6] = {" ", " ", " ", " ", " ", " "};

Was wäre deine Lösung, wenn die Zeichenketten erst während des Programmablaufs feststehen?

Dann brauchst du kein Array aus char* sondern ein zwei-dimensionales Array aus char

Array aus char* ist ok wenn man mit Konstanten arbeitet.

Serenifly: Dann brauchst du kein Array aus char* sondern ein zwei-dimensionales Array aus char

Array aus char* ist ok wenn man mit Konstanten arbeitet.

Bisher war ich eigentlich der Meinung, dass char* myChar[n] eben ein zweidimensionales Array ist und gleichwertig mit char myChar[n][m]. Aber Danke, ich werde euren Vorschlag mit dem zwei-dimensionalen Array gleich ausprobieren.

Die Deklaration sieht also so aus:

char myPtr[6][10]; char myChar[10];

Aber wie erfolgt die Zuweisung der Variablen myChar zum z.B. ersten Element von myPtr ?

"myPtr[0][0] = myChar" oder "myPtr[0][] = myChar" funktioniert nicht.

Muss ich jedes Zeichen einzeln aus myChar nach myPtr kopieren, oder gibt es einen einfacheren Weg?

Du hast nur das zwei-dimensionale Array. Sonst nichts. Und dann machst du strcpy() darin. Oder besser strncpy()

char myChar[6][10];

...

strcpy(myChar[0], "test0");
strcpy(myChar[1], "test1");

Nein, ich brauche auch das eindimensionale Array, weil ich ja die Zeichenkette “test0” nicht kenne. Diese Zeichenkette kommt in meinem konkreten Fall von einer SD-Karte.
Ich habe das jetzt mit kopieren der einzelnen Zeichen erreicht, aber werde es nun auch mit stgcpy probieren.

for (int i = 0; i < 10; i++) myPtr[0][i] = myChar[i];

Ok, jetzt wird es klarer. Solche Zuweisungen wie du oben gemacht hast gehen eben nicht weil Array Variablen nur Zeiger auf das erste Element sind. Und man dann nur den Zeiger kopiert, aber nicht den ganzen Inhalt. Um Strings zu kopieren gibt es eben strcpy() und strncpy().

Du kannst aber auch direkt einzelne chars in ein zwei-Dimensionales Array schreiben:

char myChar[6][10];

...

myChar[0][0] = 'x';

Oder auch über for-Schleifen. Der erste Index ist der String. Der zweite Index ist das Zeichen in diesem String.

Und vergiss bei sowas den Null-Terminator nicht!

Ja, danke, super, mit strcpy funktionier es auch.

Und char* prt[n] - Deklaration soll bzw. kann man also wirklich nur verwenden, wenn die einzelnen Elemente im Deklarationsteil bereits bekannt und konstant sind.

Danke für deine (für eure) Hilfe!!!!