char* übergeben und modifiziert => Zugriffsverletzung???

version nummer eins erwartet einen zeiger auf char. dahinter kann ein zeichen oder ganz viele zeichen folgen. auf dem stack wird sizeof(char*) byte angelegt (erkennbar an der symmetrischen schneeflocke: *), die Adresse wird in buffer reinkopiert.

version nummer zwei erwartet ein chararray mit 256 elementen, es werden 256*sizeof(char) byte auf dem stack angelegt und es werden 256 übergebene elemente kopiert.

supertux

klar0r schrieb:

version nummer zwei erwartet ein chararray mit 256 elementen, es werden 256*sizeof(char) byte auf dem stack angelegt und es werden 256 übergebene elemente kopiert.

nein, sie sind an sich identisch, in version 2 ist buffer auch nur ein char* Zeiger.

void ver1(char *a)
{
    printf("sizeof a = %d\n", sizeof a);
}

void ver2(char a[64])
{
    printf("sizeof a = %d, a[99] = %c\n", sizeof a, a[99]);
}

int main(void)
{
    char c[100];
    c[99] = 'A';
    ver1(c);
    ver2(c);
    return 0; 
}

erzeugt

sizeof a = 4
sizeof a = 4, a[99] = A

und bei

void ver1(char *a)
{
    printf("sizeof a = %d\n", sizeof a);
}

void ver2(char a[64])
{
    printf("sizeof a = %d\n", sizeof a);
}

sieht der Assembler Code (gcc, x86) so aus:

080483d0 <ver1>:
 80483d0:   55                      push   %ebp
 80483d1:   89 e5                   mov    %esp,%ebp
 80483d3:   83 ec 08                sub    $0x8,%esp
 80483d6:   c7 44 24 04 04 00 00    movl   $0x4,0x4(%esp)
 80483dd:   00  
 80483de:   c7 04 24 0c 85 04 08    movl   $0x804850c,(%esp)
 80483e5:   e8 16 ff ff ff          call   8048300 <printf@plt>
 80483ea:   c9                      leave  
 80483eb:   c3                      ret    

080483ec <ver2>:
 80483ec:   55                      push   %ebp
 80483ed:   89 e5                   mov    %esp,%ebp
 80483ef:   83 ec 08                sub    $0x8,%esp
 80483f2:   c7 44 24 04 04 00 00    movl   $0x4,0x4(%esp)
 80483f9:   00  
 80483fa:   c7 04 24 0c 85 04 08    movl   $0x804850c,(%esp)
 8048401:   e8 fa fe ff ff          call   8048300 <printf@plt>
 8048406:   c9                      leave  
 8048407:   c3                      ret

das ist ja der hamm0r!
ich war fest davon überzeugt, das 256 kopien angelegt würden!
ok, bin ich nun wieder etwas schlau0r!

gruß,
k.

und: @supertux, vielen dank für den post!

gruß,
klar0r

Das heißt, die Zahl wird eigentlich ignoriert?

supertux

KomischerName schrieb:

Das heißt, die Zahl wird eigentlich ignoriert?

welche Zahl meinst du?

die 256 in der deklaration
int foo_y (char buffer[256]);

supertux

ja, so könnte man es sagen, wobei bei func(datatype var[xxx]) ist var kein Array sondern ein Zeiger, ein großer Unterschied.

gilt das eigentlich für alle datentypen, also auch für strukturen und so?

supertux

ja.

char* übergeben und modifiziert =&gt; Zugriffsverletzung???

char* übergeben und modifiziert => Zugriffsverletzung???