zeiger in c

[leifg]

eigentlich dachte ich ich hab zeiger jetzt einigermaßen verstanden aber jetzt versteh ich doch einige sachen nicht. folgendes zum beispiel:

char *zgr = "text";

geht einwandfrei aber:

char *zgr;
*zgr = malloc(100);

fehler!!!

warum? warum muss ich da weglassen?as sternchen warum?

und warum muss ich auch ab jetzt immer

zgr = "text";
statt *zgr = "text"; schreiben???

ich verstehs einfach nicht.

im prinzip sind mir zeiger schon klar aber das versteh ich wirklich nicht.

[micha]

Hallo,

eine Zeiger ist wie der Name schon sagt, ein Zeiger auf einen bestimmten Adressbereich, an dem sich Daten befinden - oder auch nicht
Das heisst, ein Zeiger beinhaltet keine Daten, sondern kann nur darauf zeigen:

char* ptr = "data";
-> der Zeiger beinhaltet nur die Adresse, an der "data" liegt, nicht "data" selbst.

char *ptr = (char*)malloc(100);
-> hier schafft malloc Platz für 100 Variablen vom Typ char und gibt einen Zeiger auf den Adressbereich zurück, nicht den Inhalt.

Gruß micha

[leifg]

Original geschrieben von micha
Hallo,

eine Zeiger ist wie der Name schon sagt, ein Zeiger auf einen bestimmten Adressbereich, an dem sich Daten befinden - oder auch nicht
Das heisst, ein Zeiger beinhaltet keine Daten, sondern kann nur darauf zeigen:

char* ptr = "data";
-> der Zeiger beinhaltet nur die Adresse, an der "data" liegt, nicht "data" selbst.

char *ptr = (char*)malloc(100);
-> hier schafft malloc Platz für 100 Variablen vom Typ char und gibt einen Zeiger auf den Adressbereich zurück, nicht den Inhalt.

Gruß micha

ja das hab ich schon verstanden aber warum muss ich wenn ich einen zeiger erst später initialisiere das sternchen weglassen?

[micha]

Du verwechselst den Zeiger mit einem Dereferenzierungsoperator.
Der Zeiger wird einmal deklariert, danach musst Du nur noch den Namen verwenden, den Du dem Zeiger gegeben hast.

char *ptr;
ptr = (char*)malloc(100);

Setzt Du jetzt vor den Zeiger ein Sternchen, dann ist das ein Dereferenzierungs- oder Inhaltsoperator, d.h Du bekommst über den Operator die Daten, auf die der Zeiger zeigt.

Beispiel:

->Zeiger deklarieren
char *ptr;

->Dem Zeiger wird die Adresse des ersten Elements der konstanten Zeichenkette "Hello Pointer" zugewiesen, damit zeigt er jetzt auf 'H'
ptr = "Hello Pointer";

->Willst Du jetzt beispielsweise das erste Zeichen der Zeichenkette ausgeben, benötigst Du den Inhalstoperator *
fprintf( stdout, "%c\n", *ptr );

->Du kannst jetzt mit Hilfe dieses Operators auch durch die Zeichenkette "wandern", indem Du inkrementierst
*ptr++;

->Damit verweist der Zeiger nicht mehr auf das erste Element 'H', sondern auf das zweite, nämlich 'e'.

Hier noch mal an einem Stück:

#include <stdio.h>

int main()
{
        char *ptr;
        ptr = "Hello Pointer";

        while( *ptr != '\0' )
        {
                fprintf( stdout, "%c\n", *ptr );
                *ptr++;
        }
        return(0);
}

Hoffe, ich hab mich einigermaßen verständlich ausgedrückt

Gruß micha

[leifg]

jo jetzt hab ichs einigermaßen gerafft gleich mal weiter proggen

[Trillian]

Original geschrieben von micha

char *ptr;
ptr = "Hello Pointer";

Ist das nicht evil[TM]?
Weil der ptr irgendwohin in den Speicher zeigt, und der wird dann einfach überschrieben... Ich benutze sowas auch ab und zu (versuche es zu minimieren), ohne Probleme - liegt das an der Speicherverwaltung von Unix oder wie is das?

[micha]

@Trillian

Klar verweist der Zeiger am Anfang ins Nirvana, allerdings wird er in der nächsten Zeile sofort initialisiert, indem ihm ein Zeiger auf den Zeichenvektor zugewiesen wird. Aber eine Zuweisung einer konstanten Zeichenkette dieser Art verwende ich nie, das sollte nur verdeutlichen, dass der Dereferenzierungsoperator hier fehl am Platz ist

Gruß micha

[DerLipper[TuX]]

also

char *ptr;
ptr = "Hello World";

sollte man so nie benutzen !

besser ist:

char *ptr = NULL;

/* immer dran denken das man +1 rechnen muss wegen \0 */
ptr = (char*) malloc (wivielbyteshaettensdenngern);

/* prüfen ob der pointer gültig ist, ansonsten
    segfault
*/
if (NULL == ptr)
{
    fprintf(sterr,"hoppla - not enough memory!\n");
    exit(-1);
}

/* weise dem string nen wert zu */
strcpy(ptr,"Hello World");

/* further processing here */

Just my 0,02€
Marko

[jgbauman]

Naja, das nie is vielleicht ein bisschen stark.

Zumindest für

const char *fix_string = "I'm immutable! HAHAHA!";

gilt es IMHO nicht.