[C] insert in char* -> segmentation fault

[evilnapster]

Mede tweakers,

Onderstaande probleem houd mij al enkele dagen uit mijn nachtelijke rust, doel is een funtie om een enkele character uit een char* te bewerken. Ik heb het probleem herleid tot de volgende code

C:

#include <stdio.h>
#include <string.h>

void main(void){
    char* c = "hoo";
    printf("%s \n", c);
    char b = c[1];
    b--;
    c[1] = (char) b;
    printf("%c \n", b);
}

bovenstaande code loopt stuk op c[1] = (char) b;
dit geeft een segmentation fault.

Ik heb al best wat lopen zoeken maar nog niet een forumpost kunnen vinden wat hier echt op aansluit.

Ik gebruik Ubuntu 18.04.3 en GCC

Alle input hierover wordt gewaardeerdt.

[ Voor 0% gewijzigd door RobIII op 23-12-2019 18:46 . Reden: Code tags toegevoegd ]

[NMe]

Heb je al gekeken wat er in b zit voordat je b-- doet en nádat je dat gedaan hebt?

[evilnapster]

ja, dat is eerst een 'o' en word daarna een 'n'.

dat is ook wat ik verwachte.

als ik die lijn met c[1] = .... ook uitcomment dan print de tweede printf ook netjes een 'n'

of zie ik iets essentieels over het hoofd?

[SavageNL]

Volgens stackoverflow maak je een pointer naar een immutable string:
https://stackoverflow.com...alization-is-this-mutable

Je toewijzing aan een positie in c is dus niet toegestaan omdat dat niet schrijfbare ruimte is.

[ Voor 23% gewijzigd door SavageNL op 23-12-2019 18:53 ]

[venom1]

Bovenstaande antwoord stuurt je in de juiste richting. Maak er char c[] (array) van en het werkt waarschijnlijk. Wat je nu hebt is een char* naar een immutable string. De pointer kun je zonder problemen aanpassen maar de character string dus niet

[evilnapster]

Helder mensen. dit heeft me geholpen.

Dank

[farlane]

String literals are not modifiable (and in fact may be placed in read-only memory such as .rodata). If a program attempts to modify the static array formed by a string literal, the behavior is undefined.

Ik heb mezelf aangewend om per default een string literal een "const char*" type te geven.

[dejoma]

Ik zie dat je het type char* niet begrijpt, wat essentieel is. Ik probeer het uit te leggen,

char*, of char POINTER, wijst naar het begin van een array van characters. Deze array eindigt ergens, misschien na 3 characters misschien na 100, dat kan je misschien weten maar de computer ziet dit als er \0 staat. Dus de string "hallo" staat eigenlijk in geheugen als "hallo\0" en char* wijst naar het adres in het geheugen waar de eerste character van deze string staat.

char b, is dus de inhoud van een locatie in het geheugen (in dit geval je stack). Als jij b-- (char = char - 1) doet krijg je iets willekeurigs want character 'S' is 84, dus je krijgt dan het character '83' terug. Dit heeft niets met memory adressen te maken.

Wat je wil is die pointer van de character array laten wijzen naar een nieuwe locatie in je geheugen. Ik raad je aan om deze lecture te kijken van Harvard over memory YouTube: CS50 2019 - Lecture 4 - Memory , deze professor legt het erg goed uit.

[DJMaze]

dejoma schreef op dinsdag 24 december 2019 @ 13:46:
de computer ziet dit als er \0 staat. Dus de string "hallo" staat eigenlijk in geheugen als "hallo\0"

dat hoeft niet zo te zijn. je kan best een alloc(1000) doen waar je "hallo" in stopt.
dan hoeft char[5] nog steeds niet \0 te zijn.
En al is er ergens wel een \0 dan nog kan de string langer zijn (binary data, een hash of jpeg bijvoorbeeld).
Een char is namelijk gewoon een byte.
Met tchar wordt het leuker...

[dejoma]

DJMaze schreef op dinsdag 24 december 2019 @ 21:42:
[...]

dat hoeft niet zo te zijn. je kan best een alloc(1000) doen waar je "hallo" in stopt.
dan hoeft char[5] nog steeds niet \0 te zijn.

Met die alloc maak je Volgens mij alleen ruimte voor 1000 bitjes, en staat Dat verder los van het char array verhaal. Als ik in die alloc een klasse ga opslaan, dan zal nog altijd de laatste character van een “string” in die klasse een 0 zijn (in jouw geval &char[5] = 0 of “\0” en &char[4] ergens in die 1000 bitjes.

[Matis]

dejoma schreef op maandag 30 december 2019 @ 00:39:
Met die alloc maak je Volgens mij alleen ruimte voor 1000 bitjes, en staat Dat verder los van het char array verhaal. Als ik in die alloc een klasse ga opslaan, dan zal nog altijd de laatste character van een “string” in die klasse een 0 zijn (in jouw geval &char[5] = 0 of “\0” en &char[4] ergens in die 1000 bitjes.

Bytes!
Daarnaast bestaat alloc niet in (standaard) C. Daarvoor moet je malloc of calloc gebruiken.
Welke overigens volledig verschillende input en uitkomsten hebben.