C: Mehrdimensionales Array - Problem beim Initialisieren

[Guido (Gast)]

Hi Leute!

Ich stehe gerade vor dem Problem, dass ich mein Mehrdimensionales Array 
nicht gescheit initialisiert bekomme:

char array[10][6];

array[1] = "Hallo";
array[2] = "Welt ";

Ist bestimmt ganz einfach, aber ich bekomme es nicht hin. Sorry, habe 
schon verschiedenes versucht, wie

array[1][] = "Hallo";

aber der Compiler meckert beim ersten, das es sich nicht um einen 
modifizierbaren Wert handelt und beim zweiten, dass er einen Ausdruck 
erwartet.

Kann/will jemand helfen?

[J.-u. G. (juwe)]

google:

c mehrdimensionales array initialisieren

erster Treffer:

http://openbook.galileocomputing.de/c_von_a_bis_z/011_c_arrays_009.htm#mj760b5cacdde1f5e176a39559fbba3ecb

[Guido (Gast)]

Hi & danke.

Das habe ich schon gesehen. OK, dumm formuliert - nicht initialisieren, 
sondern ein Element einzeln beschreiben.

[holger (Gast)]

>Das habe ich schon gesehen. OK, dumm formuliert - nicht initialisieren,
>sondern ein Element einzeln beschreiben.

Das geht in C so nicht. Nimm strcpy().

[Guido (Gast)]

Achso, das wusste ich nicht - danke für die Info!

[123 (Gast)]

Das Problem ist, dass ein String kein char[] ist, sondern eben ein 
Zeiger auf einen solchen. Klappen würde also

array[1]={'H', 'a', 'l', 'l', 'o'}

Oder halt eben strcpy

[sebi707 (Gast)]

123 schrieb:
> Klappen würde also array[1]={'H', 'a', 'l', 'l', 'o'}

Nein das funktioniert leider auch nicht. Das Problem ist hier, dass man 
Arrays nur bei der Deklaration initialisieren kann und nicht mehr später 
per einfacher Zuweisung. Gehen würde eher sowas:

char array[10][6] = {"Hallo", "Welt "};

[123 (Gast)]

Hast recht. War wohl gerade was im Hirn verpolt...

[DirkB (Gast)]

sebi707 schrieb:
> Das Problem ist hier, dass man
> Arrays nur bei der Deklaration initialisieren

Das ist dann die Definition.

[Guido (Gast)]

Ich verzweifle hier noch mit meinen Arrays...

Folgendes:

char array[2][6];

void kopiere_was_ins_array( char * array )
{
  // tu dies und das mit dem array
}

void aufrufer( void )
{
  kopiere_was_ins_array( &array[0] );
}

Das funktioniert, aber wenn ich dann das nächste Element nehme

void aufrufer( void )
{
  kopiere_was_ins_array( &array[1] );
}

dann wird immer die falsche Adresse übergeben...woran liegts?

[Guido (Gast)]

Ich revidiere...der Fehler muss vorher passieren. Das Array wird noch 
durchgereicht, da geht wohl der Aufbau des Arrays verloren...also wie 
besser machen?

char array[2][6];

void kopiere_was_ins_array( char * array )
{
  // tu dies und das mit dem array
}

void unterfunktion( char * array )
{
  // mache noch dies und das...
  kopiere_was_ins_array( &array[0] );
}

void main( void )
{
  unterfunktion( *array );
}

Da weiß die Funktion wohl nicht mehr, wo das eine Element anfängt und 
das andere aufhört.

[Guido (Gast)]

Mal was anderes...bin ich jetzt total blöd, oder wird ein array nicht 
mit array[y][x] angeben? Also

array[2][6]

00 01 02 03 04 05
10 11 12 13 14 15

hier:
http://pronix.linuxdelta.de/C/standard_C/c_programmierung_14_2.shtml
ist es doch andersherum?!

[Max H. (hartl192)]

Guido schrieb:
> dann wird immer die falsche Adresse übergeben...woran liegts?
array[0] ist schon der Pointer auf das ersten Elements der der ersten 
Zeile, Versuch mal einfach array[0] ohne '&' an die Funktion zu 
übergeben:

char array[2][6];

void kopiere_was_ins_array( char * array )
{
  // tu dies und das mit dem array
}

void aufrufer( void )
{
  kopiere_was_ins_array( array[0] );
}

[Guido (Gast)]

Das geht auch nicht. Das muss irgendwie daran liegen das bei der ersten 
Übergabe die Dimension verloren geht. Aber wie schicke ich die mit?

[Yalu X. (yalu) (Moderator)]

Guido schrieb:
> Das funktioniert, aber wenn ich dann das nächste Element nehme
>
> void aufrufer( void )
> {
>   kopiere_was_ins_array( &array[1] );
> }

&array[1] ist vom Typ char(*)[6], kopiere_was_ins_array erwartet aber
ein char*. Da sollte der Compiler mindestens eine Warnung ausgeben.

Der Argumenttyp ist char* und damit passend, wenn du das & weglässt:

  kopiere_was_ins_array( &array[1] );

> dann wird immer die falsche Adresse übergeben...woran liegts?

Welche Adresse erwartest du denn?

Mit &array[1] wird ein Zeiger auf das zweite Unter-Array, mit array[1]
ein Zeiger auf das erste Element des zweiten Unter-Arrays übergeben.
Beide haben zwar einen unterschiedlichen Typ, aber den gleichen
numerischen Wert.

Guido schrieb:
> Mal was anderes...bin ich jetzt total blöd, oder wird ein array nicht
> mit array[y][x] angeben? Also
>
> array[2][6]
>
> 00 01 02 03 04 05
> 10 11 12 13 14 15

Ja.

> hier:
> http://pronix.linuxdelta.de/C/standard_C/c_programmierung_14_2.shtml
> ist es doch andersherum?!

Die Initialisierung im Link ist fehlerhaft. Wie du richtig erkannt hast,
müssen dort die Zeilen und Spalten vertauscht werden.

[Guido (Gast)]

Ok, danke schonmal, aber ich kriege es nicht hin. Wie müsste es denn 
jetzt lauten? Ich habe ein Array

char array[2][6];

Dann habe ich die Funktion die mir was ins Array schreiben soll. Hier 
muss die Adresse des ersten Elementes von array[0] oder [1] übergeben 
werden.

void schreibe_ins_array( char * array )
{
  array[0] = 'T';
  array[1] = 'E';
  array[2] = 'X';
  array[3] = 'T';
  array[4] = '0';
  array[5] = '1';
}

Dann gibt es eine Unterfunktion, welche das komplette Array bekommen 
soll, um damit zu arbeiten. Hier muss ja bekannt sein, wo die beiden 
ersten Elemente beginnen, also quasi der "Aufbau" des Arrays, damit es 
bei der Übergabe von array[0] oder array[1] das jeweilige erste Element 
übergibt, bzw. dessen Adresse.

void unterfunktion( char * array )
{
  schreibe_ins_array( array[0] );
}

Und dann ist da noch die main, aus der die Unterfunktion aufgerufen wird 
und das komplette Array an die Unterfunktion übergibt

void main( void )
{
  unterfunktion( array );
}

Wie ist hierfür jetzt die richtige Syntax? Woher weiß die Unterfunktion, 
wie das Array aufgebaut ist? Das Array ist ja statisch, liegt also im 
Speicher direkt hintereinander? Ich bräuchste doch quasi ein Zeiger auf 
Zeiger, oder nicht?

Ich blicks nicht, sorry.

[Yalu X. (yalu) (Moderator)]

Wenn die Größe des inneren Arrays (6) immer gleich ist, kannst du das so
schreiben:

#include <stdio.h>

char array[2][6];

void schreibe_ins_array(char *array) {
//void schreibe_ins_array(char array[]) {
  array[0] = 'T';
  array[1] = 'E';
  array[2] = 'X';
  array[3] = 'T';
  array[4] = '0';
  array[5] = '1';
}

void unterfunktion(char (*array)[6]) {
//void unterfunktion(char array[][6]) {
  schreibe_ins_array(array[0]);
  schreibe_ins_array(array[1]);
}

int main(void) {
  unterfunktion(array);

  for(int i=0; i<2; i++) {
    for(int j=0; j<6; j++)
      putchar(array[i][j]);
    putchar('\n');
  }
  return 0;
}

Die auskommentierten Zeilen enthalten jeweils eine alternative, aber
äquivalente Schreibweise der Funktionsköpfe.

Ausgabe:

TEXT01
TEXT01

Wenn an unterfunktion zweidimensionale Arrays unterschiedlicher Größe
übergeben werden sollen, kannst du das auch mit "variable-length arrays"
(VLAs) bewerkstelligen.

Edit:

Vielleicht hilft dir dieser Beitrag zu mehrdimensionalen Arrays und
Zeigern in C etwas weiter:

  Beitrag "Re: Ein Zeiger auf ein mehrdimensionales Feld"

[Dr. Sommer (Gast)]

Falls das Programm nicht gerade auf einem winzigen Mikrocontroller 
laufen soll, kannst du auch C++ und std::vector und std::string 
verwenden. C++ ist abwärtskompatibel wie C, aber seine Arrays & Strings 
verhalten sich so wie man es erwarten würde:

#include <vector>
#include <string>
#include <iostream>

void schreibe_string (std::string& str) {
  str = "Welt!";
}

int main () {
  std::vector<std::string> array (2);
  
  array[0] = "Hallo ";
  schreibe_string (array [1]);
  
  std::cout << array[0] << array [1] << std::endl;
}

"array" ist hier ein Array aus Strings. Diese kann man zuweisen (Zeilen 
5 und 11), Referenzen darauf erstellen (Zeile 13), und zugreifen & 
ausgeben (Zeile 15).

So ersparst du dir die Frickelage mit C-Arrays, kannst aber immer noch 
alles machen was C auch kann.

Nachteil: Es wird dynamischer Speicher benötigt, was aber nur auf 
kleinen Mikrocontrollern problematisch ist.

[Yalu X. (yalu) (Moderator)]

Wenn die einzelnen Elemente des Arrays konstante, nullterminierte
Strings sind, die immer nur als Ganzes ersetzt werden, kannst du statt
eines zweidimensionalen Arrays auch ein Array von Zeigern nehmen. Das
sieht dann so aus:

#include <stdio.h>

const char *array[2];

void schreibe_ins_array(const char **array) {
//void schreibe_ins_array(char *array[]) {
  *array = "TEXT01";
}

void unterfunktion(const char **array) {
//void unterfunktion(char *array[]) {
  schreibe_ins_array(&array[0]);
  schreibe_ins_array(&array[1]);
}

int main(void) {
  unterfunktion(array);
  for(int i=0; i<2; i++)
    printf("%s\n", array[i]);
  return 0;
}

Da nur Zeiger umkopiert werden, wird auch weniger Rechenzeit verbraucht,
und die Länge der einzelnen Strings ist beliebig, muss also nicht schon
bei der Deklaration des Arrays mit angegeben werden. Da die Strings aber
konstant sind, kannst du ihre Inhalte nicht ändern.

array[1][3] = 'x';  // Fehler

im Hauptprogramm, um das vierte Zeichen des zweiten Strings in ein 'x'
zu ändern, geht also nicht.

[J. (Gast)]

Wozu brauchst du überhaupt das Array?  Vielleicht ist ja der ganze 
Ansatz verkehrt.