*String != String[] ???

Hi!
Ich arbeite derzeit ein C++ Tut durch und bin demnach noch Anfänger.
Leider kann ich jetzt einen der Beispielcodes nicht ganz nachvollziehen

#include <cstdio>

using namespace std;

int Zahl = 500;
char *String = "Hallo da";
float Zahl2 = 44.332211f;

int main(void)
{
   Zahl = printf("%s, der Wert von Zahl ist %d (oder %x) und von Zahl2 %.5f!!!", 
          String, Zahl, Zahl, Zahl2);

   printf("\nEs wurden in der Zeile oben %d Zeichen ausgegeben!!!", Zahl);

   getchar(); //erwartet Eingabe

   return 0;
}

Mein Problem, der * vor String:
char *String = "Hallo da";
was hat der zu bedeuten?
Ich könnte mich nicht daran erinnern, das der bisher jemals erwähnt worden wäre und die suche in der online-version des tut's mit strg+f ergab auch nix.

String muss ein Array sein, soviel ist mir klar, sonst könnte ja nur ein Buchstabe in der char-variable gespeichert werden.
Aber im Kapitel Arrays habe ich nur die möglichkeit gelernt, Arrays so zu schreiben:
Array[] = "BlaBlaBla";
Die Variable Array ist ein Zeiger, mit * davor mach ich mir den Wert des ersten Elementes zugänglich, *Array entspräche also Array[0]
Also ist das wahrscheinlich einfach nur eine andere Schreibweise, oder?

Aber was soll mir der Stern bei diesem Prototyp sagen?
int strncmp (const char* sz1, const char* sz2, size_t sizeMaxCompare);

danke für alle Antworten

evilissimo

Nehmen wir mal als Beispiel:

char test[] = "Hallo";

Wenn man jetzt nur test weiter verwendet verhält sich diese Variable wie ein Zeiger. ( Weil es auch einer ist )

Daher auch das mit dem *

MyPrint( char const * string )
{
  printf(string);
}
//...
MyPrint(test); // Kein Problem

evilissimo schrieb:

Wenn man jetzt nur test weiter verwendet verhält sich diese Variable wie ein Zeiger. ( Weil es auch einer ist )

nein, aber besser als es hier beschrieben ist koennt ich es wohl auch nicht beschreiben:

Frage 2.2: Aber ich habe gehört dass char a[] das gleiche wie char *a ist.

Antwort: Überhaupt nicht. (Diese Aussage hat etwas mit den formalen Parametern einer Funktion zu tun. Vgl. Frage 2.4.) Arrays sind keine Zeiger. Die Feldvereinbarung "char a[6]" fordert, dass Platz für sechs Zeichen bereitgestellt wird, der unter dem Namen "a" bekannt ist. Das bedeutet, dass es einen Ort mit dem Namen "a" gibt, an dem sechs Zeichen gespeichert sein können. Die Zeigervereinbarung "char *p" dagegen fordert Platz für einen Zeiger an. Der Zeiger trägt den Namen "p" und er kann auf jedes Zeichen (oder jedes zusammenhängende Array von Zeichen) irgendwo im Speicher zeigen.

Wie so häufig ist ein Bild tausend Worte wert. Die Anweisungen

char a[] = "hello";
char *p = "world";

würden zu Datenstrukturen führen, die auf folgende Weise dargestellt werden können:

+---+---+---+---+---+---+
a: | h | e | l | l | o |\0 |
+---+---+---+---+---+---+

+-----+ +---+---+---+---+---+---+
p: | *======> | w | o | r | l | d |\0 |
+-----+ +---+---+---+---+---+---+

Es ist wichtig zu begreifen, dass ein Bezug wie x[3] zu unterschiedlichem Maschinencode führt, je nach dem, ob x ein Array oder ein Zeiger ist. Wenn man den obigen Quelltext heranzieht, wird ein Compiler für den Ausdruck a[3] Maschinencode ausgeben, der an der Speicherposition "a" beginnt, von dort drei Schritte weitergeht und das Zeichen an der so gefundene Speicherposition liest. Wenn der Compiler auf den Ausdruck p[3] trifft, erzeugt er Maschinencode der an der Speicherposition "p" beginnt, den Zeiger holt der dort liegt, zu diesem Zeiger 3 dazuzählt und zum Schluß das Zeichen holt, auf das dieser Zeiger zeigt. In dem obigen Beispiel sind zufällig sowohl a[3] als auch p[3] das Zeichen 'l', aber der Compiler kommt auf verschieden Wegen zu diesem Zeichen.

(quelle: http://www2.informatik.uni-wuerzburg.de/dclc-faq/kap2.html)

@socke: beschaeftige dich am besten noch mal intensiv mit pointern. ist zwar am anfang schwer aber da muss man durch. -der linkt ist ja schonmal ein guter anfang.

-echt sehr sehenswerte und nuetzliche seite wie ich finde.

evilissimo schrieb:

Nehmen wir mal als Beispiel:
char test[] = "Hallo";
Wenn man jetzt nur test weiter verwendet verhält sich diese Variable wie ein Zeiger. ( Weil es auch einer ist )

Daher auch das mit dem *
MyPrint( char const * string )
{
  printf(string);
}
//...
MyPrint(test); // Kein Problem

*string wäre dann eine dereferenzierung von test, richtig?
Das würde ich ja auch verstehen, aber bei der deklaration habe ich sowas halt noch nie gesehen:
char *test = "StringStringString...";

und was der stern hier bedeutet hat mir auch noch niemand erklärt:
int strncmp (const char* sz1, const char* sz2, size_t sizeMaxCompare);
soll das heißen, das ein zeiger übergeben werden soll, der sich dann dereferenziert? also das der stern gar nicht am ende von char steht, sondern am anfang von sz1? hmmm.... aber was wäre dann, wenn ich eine konstante übergebe?
ist der stern nur für die eventualität, das ein zeiger übergeben wird, gedacht?

@Cpt.Tanga: eigentlich denke ich das meiste von zeigern verstanden zu haben, aber weil die beiden sachen halt nie erwähnt wurden, bin ich mir da etwas unsicher, wie genau das jetzt funktioniert.

evilissimo

Einfach mal hier schauen: http://tutorial.schornboeck.net/c_string.htm

hmmm, okey... da sehe ich es zwar in der anwendung, erklärt wird es dort aber auch nicht

while(*str != 0) //oder: while(*str)
      {
        cout<<*str;
        ++str;
      }

str ist ein zeiger, *str die dereferenzierung, ++str geht eine stelle weiter, zum nächsten buchstaben, indem es die speicheradresse um 1 erhöht... alles klar, soweit.

dann ist
char *String = "Hallo da";
also doch nur eine andere schreibweise für
char String[] = "Hallo da";
richtig?!

die Speicheradresse die String enthält zeigt ja auf das nullte element, also auf String[0]
*String müsste also String[0] bedeuten? Aber mit String[0] kann ich doch kein Array mit 8 Elementen initialisieren

socke schrieb:

dann ist
char *String = "Hallo da";
also doch nur eine andere schreibweise für
char String[] = "Hallo da";
richtig?!

nein. hast du eigentlich das zitat in meinem post gelesen? -da steht der unterschied drin.

socke schrieb:

Aber mit String[0] kann ich doch kein Array mit 8 Elementen initialisieren

mit *String alleine aber auch nicht. (der pointer und das array haben uebrigens 9 elemente)

achso!
naja, deinen post hatte ich vorher schon gelesen, aber jetzt erst verstanden
danke.

@evilissmo: auch danke für den link zum tut, das kapitel über c-strings, auf das du gelinkt hast, hat mir zwar nicht so wirklich geholfen, aber ein anderes ( http://tutorial.schornboeck.net/zeiger.htm )