Pointer auf Char

mahlzeit!

pointer auf int sind soweit klar. eine kleines beispiel, was sich bis zum problempunkt erstreckt:

int var = 4711;
int *pointer = &var;
*pointer = 0815;                //dereferenzierung
printf("%d \n", *pointer);      //wert des pointers auf den er zeigt (0815)

soweit ist der derefenzierungsoperator und die ausgabe verständlich.

bei einzelnen chars klappt das mit bisheriger vorgehensweise auch noch.
beispiel auch wieder hier:

char array[3] = {'A', 'B', 'C'};
char *pointer = &array[0];
*pointer = 'X'
printf("%c \n", *pointer);       //X

nun aber strings:

char array[] = "ABC";
char *pointer = &array;
*pointer = "neu"                 // "*" Fehlerpunkt
printf("%s \n", *pointer);       // "*" Fehlerpunkt

warum funktioniert die dereferenzierung bitte bei dem beispiel 1 und 2 mit dem dereferenzierungsoperator und mit der ausgabe via printf, wo hingegen beispiel 3 nicht klappt, obwohl dort selbiges schema angewendet wird?
wenn ich den "" im 3. beispiel bei der dereferenzierung und der ausgabe wegnehme, gehts. so aber nicht.
ich versteh es irgendwie nicht.
liegt es evtl. daran, dass ich im 2. beispiel nur ein arraywert dereferenziere und im 3. beispiel den ganzen string?
wieso aber klappt es dann, wenn ich "" in den zeilen der dereferenzierung und ausgabe entferne?
meines erachtens gebe ich mit printf("%d", *pointer) den wert des pointers auf den er zeigt aus. wenn ich nur printf("%d", pointer) als beispiel schreibe, kommt ja blödsinn raus. er würde quasi den inhalt auf den er zeigt als dezimalzahl darstellen wollen.

wie immer gilt: besten dank und bitte auf laieniveau
gruß norben!

aus der printf manpage:

s    if no l modifier is present: The const char* argument is expected to be a pointer to an     array of character type(...). 
     Characters from the array are written up to (but not including) a terminating null byte ('\0');

Du darfst den Zeiger also nicht derefernzieren. Darüberhinaus solltest du darauf achten, das array mit einem Nullbyte abzuschließen:

char array[] = { 'a', 'b', 'c', 0};
char *pointer =  &array;
printf("%s \n", pointer);

char array[] = "ABC";
// Da es sich hier nicht um einen Pointer auf ein Char handelt, sondern auf ein Pointer auf ein CString(Chararray wo das letzte Element eine binäre 0 ist);
char *pointer = &array; // so nicht, das wäre die adresse der ersten adresse des ersten chars also ein char **pointer(glaube ich)
char *pointer = &array[0]; // entweder so 
char *pointer = array; // oder so in Kurzschreibweise 

*pointer = "neu"                 // "*" Fehlerpunkt Ja klar da du ja die in dem Pointer enthaltene Adresse ändern willst und nicht den ersten Char des zuvor zugewiesenen A von "ABC"
pointer = "neu"; // So weist man einen Pointer eine neue Adresse zu, in diesem Falle die des ersten Zeichens des Literals "neu"
printf("%s \n", *pointer);       // "*" Fehlerpunkt Klar, weil die Adresse des ersten Zeichen des CStrings erwartet wird und nicht das erste Zeichen selbst 
printf("%s \n", pointer); // so wäre dies dann richtig

Alles ungetestet. Ich bin auch kein Informatiker, ist alles nur ein kleines Hobby von mir.

ich muss trotzdem nochmal nachfragen.

char array[] = "ABC";
char *pointer1, *pointer2;
pointer1 = &array[0];
pointer2 = &array[1];

*pointer1 = 'H';
pointer2 = "neu";

wenn ich jetzt die speicheradresse auslesen lasse, dann steht:
im array[0]: 0x22aaa0
im array[1]: 0x22aaa1

will ich nun via printf auslesen lassen, worauf der zeiger zeigt, dann steht:
bei pointer1: 0x22aaa0 //zeigt auf array[0]
bei pointer2: 0x100403030

warum zeigt ponter2 dann nicht auf array[1], sondern irgendwohin?

mit pointer1 schreibt er dank dereferenzierung einen neuen wert (hier: char) in das array[0]
pointer2 schreibt ebenfalls dank irgendwas (da dereferenzierungsoperator fehlt und ich immer noch nicht verstanden habe, wieso er dann den wert ändert) einen neuen wert (hier string (x chars halt)) in das array[1].

lustig ist auch, was mich total zurückwirft:

printf("%p \n", pointer1);   //0x22aaa0
printf("%p \n", pointer2);   //0x100403030

ändern ich nun die ausgabe mittels %s um den string auszugeben, kommt:

printf("%s \n", pointer1);   //HBC
printf("%s \n", pointer2);   //neu

wieso steht jetzt "HBC" drin und nicht nur H? schießlich habe ich oben nur das array[0] dem pointer1 zugewiesen und nicht den string.
array[0] dürfte meines erachtens nur "H" ausspucken
array[1] nur "neu"

das hingegen funktioniert, wie ich es auch erwartete:

printf("%c \n", *pointer1);    //"H"

ich dachte das themengebiet sitzt für die klausur, aber der sachverhalt mit strings haut mich zurück

korrigiert mich, aber grob zusammengefasst.
einzelne chars und int werte z.b. ändere ich mit dem dereferenzierungsoperator und gebe sie mit NAME in der printf aus!?
bei strings hingegen ändere ich durch den pointer den wert ohne "" und gebe sie in der printf nur mit NAME aus?!

ergo:

int/char/etc:

*NAME = 7;
printf("...",*NAME)

strings:
NAME = "TEXT";
printf("...",NAME);

oder habe ich jetzt den totalen denkfehler.

besten dank nochmal!

C-Strings sind keine Elemente der Sprache C sondern nur eine Vereinbarung.
Es sind nullterminierte char-Arrays. D.h das Zeichen '\0' (mit dem Wert 0) zeigt das Ende der Zeichenkette an.

Der Arrayname steht für die Adresse vom ersten Element.

Ein Stringliteral (Text zwischen " ") wird automatisch terminiert und ist die Adresse auf das erste Zeichen.

char array[4] = {'A', 'B', 'C', '\0'};
char array[] = "ABC";

ergibt das Selbe. Da ist kein Unterschied.
Die Zuweisung von Inhalten an Arrays mit dem = funktioniert aber nur bei der Definition. Sonst nicht.

Auch ist

pointer1 = &array[0];
pointer1 = array;

identisch.

Bei pointer2 = "neu"; weist du pointer2 die Adresse von dem Stringliteral zu. Das steht irgendwo im Speicher. Darum hast du bei %p auch andere Adressen.

Bei *pointer1 = 'H'; schreibst du ein 'H' an die Stelle, auf die pointer1 zeigt. Sonst änderst du nichts. Da wird dann auch keine '\0' geschrieben, die das Ende kennzeichnet.

%s bei printf erwartet die Adresse von einem C-String und gibt diesen aus.

Arrays werden in C anders behandelt als die integralen Typen.
Der Name zerfällt in die Adresse vom ersten Element.
Es ist kein Zeiger, da du diese Adresse nicht ändern kannst.

C macht auch keinen Unterschied bei den Arrays. Der Compiler hilft durch die automatische Terminierung von Stringliteralen.
Der Rest ist eine Vereinbarung. Allerdings baut die C-Standard-Library darauf auf.

Wutz

Norben schrieb:

meines erachtens gebe ich mit printf("%d", *pointer) den wert des pointers auf den er zeigt aus. wenn ich nur printf("%d", pointer) als beispiel schreibe, kommt ja blödsinn raus. er würde quasi den inhalt auf den er zeigt als dezimalzahl darstellen wollen.

Den Inhalt würde er nur anzeigen, wenn du den Zeiger auch dereferenzierst, sonst gibt er den nach int konvertierten Wert der Zeigervariable aus.

Handwerker2013 schrieb:

char *pointer = &array; // so nicht, das wäre die adresse der ersten adresse des ersten chars also ein char **pointer(glaube ich)

&array bedeutet (sinnigerweise) Adresse von array mit dem Typ Zeiger auf array und nicht Zeiger auf char.

Ist array(arr[]) und Zeiger auf Zeiger(**arr) nicht dasselbe?

Bitte nochmal verständlich.

Falls du nur die Bezeichner in den Klammern meinst: Nein, das ist nicht dasselbe.

Was ist der Unterschied zwischen **char arr; und char arr[]; ?

Bashar

Das eine ist ein Zeiger, also eine Adresse von was, und das andere ist ein Array, also eine Aufreihung gleichartiger Objekte. Völlig verschiedene Sachen.

Ja, stimmt, Zeiger und Arrays sind wirklich ziemlich unterschiedlich. Hier ist eine gut verständliche Seite mit Fragen und Antworten zu dem Thema. Das ist auch für Nichtakademiker leichte Kost.

http://c-faq.com/~scs/cgi-bin/faqcat.cgi?sec=aryptr

http://cdecl.org/ schrieb:

char arr[]; declare arr as array of char
char **arr; declare arr as pointer to pointer to char

arr[] als Variablendefinition:
Bei arr[] reicht einmal dereferenziern aus, um auf ein char zu kommen.
Es ist ein 1D-Array
Das kann mit Arrayzugriff oder mit dem * sein. (arr[0] oder *arr)
Du kannst arr nicht verändern (arr++ geht nicht). Es ist kein Pointer.
sizeof() liefer die Größe des Arrays in Byte.

arr[] in der Parameterliste einer Funktion:
Es wird zu *arr. Also einem Pointer
Einmal dereferenzieren.

Bei arr musst du zweimal dereferenziern aus, um auf ein char zu kommen.
Es ist ein Pointer.
Du kannst das char als Zeiger auf char[] benutzen.
Es ist kein Zeiger auf ein echtes 2D-Array

Für Pointer gilt:
Du kannst arr verändern (z.B. arr++ )
Derefernzieren kann mit Arrayzugriff [] oder mit dem Operator * sein.
sizeof() liefert die Größe des Zeigers in Byte
Du kannst (mit arr) keine Ausssage über die Größe des Blocks treffen auf den arr zeigt.

is schon nich wirklich einfach

eine einfache hoffentlich letzte frage noch.

ein array mit z.b. "ABC" würde ja bedeuten, dass
buchstabe A im array[0]
buchstabe B im array[1]
und buchstabe C im array[2] steht.

wenn ich einen pointer erstelle, wie im folgenden beispiel:

char array[] = "ABC";
char *pointer;
pointer = array; //oder: pointer = &array[0];
pointer = "neu";

dann will ich aber mein array[1] wo "B" drin steht, auf z.b. "neu" ändern (können).

DirkB schrieb:

Bei pointer = "neu"; weist du pointer die Adresse von dem Stringliteral zu. Das steht irgendwo im Speicher. Darum hast du bei %p auch andere Adressen

dirkb meinte ja das dann im pointer irgendeine speicheradresse steht, wo wiederum "neu" drin steht. ich will aber das "neu" im array[1] steht und nicht irgendwo. geht das dann nicht irgendwie mit hilfe eines pointers?

ok das war fail. ich sollte doch öfters eine pause machen
ist natürlich klar, dass ich kein string in einzelnes char array speichern kann.

ich kann natürlich mit dem dereferenzierungsoperator einen buchstaben ins array speichern/überschreiben. aber strings gehen ja schlecht in ein einzelnes array

sry!

"neu" besteht aus 4 Zeichen (3 Buchstaben + '\0')
array[1] ist ein char und bietet Platz für ein Zeichen.

Wie soll da das Ergebnis aussehen?

Dein Antwort habe ich gerade beim schreiben nicht mehr gesehen.

kein problem! wie gesagt: muss mal frische luft schnappen gehen

danke aber vielmals für die antworten