Hallo,

Folgendes geht ohne Angabe der Feldgröße:
char abc[]={"hallo"};
char def[]="hallo";
char *ghi={"hallo"};
char *jkl="hallo";

Folgende Beispiele gehen jedoch nicht:
char abc[][]={"compiler", "meckert"};
char def[2][]={"compiler", "meckert"};
char ghi[][9]={"compiler", "meckert"};

Wieso kann wenigstens für "char def" nicht automatisch die Feldgröße
(Stringlänge) ermittelt werden?

Das hier geht allerdings wieder ohne jegliche Feldgrößenangabe:
char *abc[] = {"so", "klappt", "es"};
printf(abc[2]);  //Ausgabe: "es"

Wieso? die subtilen Regeln von C sind mir nicht klar. Vielleicht kann
mich jemand erhellen... Danke

> Wieso kann wenigstens für "char def" nicht automatisch die
Feldgröße
> (Stringlänge) ermittelt werden?

ghi funktioniert anstandslos.  Die Stringlänge mehrerer Strings kann
er nicht automatisch ermitteln, aber die erste Felddimension kann
automatisch an Hand der Initializer ermittelt werden.  Aber das
mehrdimensionale Array ist für Zeichenketten ohnehin keine sehr
praktikable Lösung.

> Das hier geht allerdings wieder ohne jegliche Feldgrößenangabe:
> char *abc[] = {"so", "klappt", "es"};

Klar, jetzt bist du ja auch von einem mehrdimensionalen Array (of
char) übergegangen zu einem eindimensionalen (of pointer to char).
Das hat den zusätzlichen netten Effekt, dass du im Gegensatz zum
mehrdimensionalen Array nicht N-mal den Platz für den längsten String
allozierst, sondern N-mal den Platz für einen Zeiger, während die
Strings selbst ausschließlich den für ihre Darstellung notwendigen
Platz belegen.

char ghi[][9] als vermeintlich falsch ist mir glatt durchgegangen.
Vielen Dank für die Erklärung und den Hinweis auf Speicherbedarf! :-)

> Wieso? die subtilen Regeln von C sind mir nicht klar. Vielleicht
> kann mich jemand erhellen... Danke

Im Grunde ist das Prinzip sehr simpel:
Wenn du ein mehrdimensionales Feld anlegst, dann muss
der Compiler dass irgendwie im Speicher unterbringen.
Er macht das so, dass er die einzelnen Elemente der
2-ten Dimension einfach aneinanderhängt.

char Test[2][3];

  Test
  +---+---+---+---+---+---+
  |   |   |   |   |   |   |
  +---+---+---+---+---+---+
    0   1   2   0   1   2

   |          |          |
     das hier    und hier
   ist Test[0]    Test[1]

man sagt auch: "der letzte Index läuft am schnellsten"
Die Elemente [0][0], [0][1], [0][2] liegen also direkt
hintereinander, gefolgt von [1][0], [1][1], [1][2]
usw.

Wenn du daher auf ein Element [a][b] zugreifst, muss
der Compiler ausgehend von der Startadresse des Arrays
rechnen:

    Adresse von [a][b] = Startadresse +
                         a * Dimensionierung der 2.ten Dimension +
                         b

Um also die Adresse berechnen zu können, muss der Compiler wissen
wie gross den die 2. te Dimension tatsächlich ist.
Bei
  char Test[2][3]
wäre das die 3.

Nun hätte man natürlich für char-Arrays als Sonderfall
zulassen können, dass der Compiler die Abzählerei macht.
Schliesslich ist alles dazu Notwendige in der Initialisierung
enthalten. Ich denke aber man wollte sich einfach keinen
Sonderfall einhandeln.

Übrigens: Bei
  char *abc[] = {"so", "klappt", "es"};

wird etwas völlig anderes im Speicher aufgebaut.
Das sieht dann so aus


    abc
   +-----+        +---+---+----+
   |  o---------->| s | o | \0 |
   +-----+        +---+---+----+   +---+---+---+---+---+---+----+
   |  o--------------------------->| k | l | a | p | p | t | \0 |
   +-----+                         +---+---+---+---+---+---+----+
   |  o-----------+
   +-----+        |
                  |    +---+---+----+
                  +--->| e | s | \0 |
                       +---+---+----+

Die einzelnen Strings liegen also irgendwo im Speicher und
werden nur durch das Pointer-Array zusammengehalten.

Gut erklärt Karl Heinz, gefällt mir :-)

Dafür ist er bekannt.

Der Thread ist zwar schon alt aber Karls Erklärung hat mich grad auch
begeistert, besonders die netten ASCII Zeichnungen^^ (hast du die per
Hand eingetippt? xD)

lg PoWl

In nem emacs mit Mausunterstützung kann man die malen :D