unterschiede von string deklarationen??

worin liegt der unterschied wenn ich einen string so initialisiere:

char var[]="hallo\0";

und so initialisiere:

char *var="hallo\0";

??

Bei folgendem Bsp: bekomm ich mit indirektionsoperator einen segfault.
mit [] funkt alles wunderbar

char *var="hallo\0";
char *ptr;

ptr=var;
puts("ptr=var;");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var,var,&ptr,ptr,*ptr);

*ptr='k';
puts("*ptr='k';");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var,var,&ptr,ptr,*ptr);

*ptr+=5;
puts("*ptr+=5; // var muesste nun p sein");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var,var,&ptr,ptr,*ptr);

(*ptr)++;
puts("(*ptr)++;");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var,var,&ptr,ptr,*ptr);

puts("nun schaut var so aus:");
puts(var);

fehlermeldung :

ptr=var;
var addr:'0xbffff374' wert 'hallo'
ptr addr:'0xbffff370' wert:'0x8048644' deref:'h'
Segmentation fault

mfg
fm

CarstenJ

Hallo,

du hast keinen Speicher reserviert (per malloc) für *var. D. h. du versuchst einen Bereich zu beschreiben, der dir nicht gehört. Außerdem ist char var[]="hallo"; schon nullterminiert.

*ptr='k'; sollte auch nicht gehen, da du praktisch versuchst, einem Pointer ein int zuzuweisen.

*ptr='k' sollte doch gehen.

die ausgabe des progs mit [] schaut so aus:

ptr=var;
var addr:'0xbffff360' wert 'hallo'
ptr addr:'0xbffff35c' wert:'0xbffff360' deref:'h'
*ptr='k';
var addr:'0xbffff360' wert 'kallo'
ptr addr:'0xbffff35c' wert:'0xbffff360' deref:'k'
*ptr+=5; // var muesste nun p sein
var addr:'0xbffff360' wert 'pallo'
ptr addr:'0xbffff35c' wert:'0xbffff360' deref:'p'
(*ptr)++;
var addr:'0xbffff360' wert 'qallo'
ptr addr:'0xbffff35c' wert:'0xbffff360' deref:'q'
wert -------- p;
wert2-------- q;
nun schaut var so aus:
qallo

und der komplette source code:

#include <stdio.h>

int main (void)
{
char var[]="hallo";
char *ptr;

ptr=var;
puts("ptr=var;");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var[0],var,&ptr,ptr,*ptr);

(*ptr)='k';
puts("*ptr='k';");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var[0],var,&ptr,ptr,*ptr);

*ptr+=5;
puts("*ptr+=5; // var muesste nun p sein");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var[0],var,&ptr,ptr,*ptr);

char wert=(*ptr)++;
char wert2=*ptr;
puts("(*ptr)++;");
printf("var addr:'%p' wert '%s'\nptr addr:'%p' wert:'%p' deref:'%c'\n",&var[0],var,&ptr,ptr,*ptr);

printf("wert -------- %c;\n",wert);
printf("wert2-------- %c;\n",wert2);
puts("nun schaut var so aus:");
puts(var);
return 0;
}

Bashar

char var[] = "Hallo Welt!";

definiert ein char-Array, das mit "Hallo Welt!" und einem Nullzeichen initialisiert wird, d.h. es wird Platz für 12 Zeichen auf dem Stack freigemacht und dann der statische String (das "Stringliteral") dort hineinkopiert. Du kannst frei über dieses Array verfügen.

char *var = "Hallo Welt!";

ist dagegen lediglich ein Zeiger auf das genannte Stringliteral. Verändern desselben ist verboten (deshalb bekommst du ein Segfault), deshalb wär ein const char* als Datentyp eigentlich vorzuziehen.

dh.

char var[] = "Hallo Welt!";

wird nicht auf den stack kopiert.

thx

Bashar

Doch.