Can't Modify Char* - Memory Access Violation

can't modify char* - Memory access violation

String literals are stored in read only section of memory. Any attempt to modify the contents of a string literal invokes Undefined Behaviour (segmentation fault on most implementations).

Use an array of characters rather

char str[] = "HelloGuys";

cpp dll char pointer assignment, writting memory access violation

char *strOu = ""; is a pointer to an empty string (char array of length 1).

When, in the function, you write strOut += 17; , that advances the pointer by 17 characters. Now the pointer is pointing into the wilderness . It's likely that this is in a read-only data area which is why the call to strcpy_s causes an access violation.

To fix this you need to only write to memory that has been correctly allocated. You will need to design a contract between this function and its caller; for example specify that the caller must pass a writable buffer of at least a particular size.

Access violation writing location when working with pointers to char

You're attempting to modify a string literal. You can't do that.

char *str = "abcad";

That's a string literal. It's created in read-only memory therefore attempting to write to it is an access violation.

Why can't I edit a char in a char*?

Your code sets a to a pointer to "abc", which is literal data that can't be modified. The Bus error occurs when your code violates this restriction, and tries to modify the value.

try this instead:

char a[] = "abc";
a[0] = 'c';

That creates a char array (in your program's normal data space), and copies the contents of the string literal into your array. Now you should have no trouble making changes to it.

Memory access violation. What's wrong with this seemingly simple program?

If you change this, which makes someString a pointer to a read-only string literal:

char *someString = "Hi there, I'm bad at this.";

to this, which makes someString a modifiable array of char, initialized from a string literal:

char someString[] = "Hi there, I'm bad at this.";

You should have better results.

While the type of someString in the original code (char*) allows modification to the chars that it points to, because it was actually pointing at a string literal (which are not permitted to be modified) attempting to do any modification through the pointer resulted in what is technically known as undefined behaviour, which in your case was a memory access violation.

Access violation when overwriting c string

char* c = "Hello World!"; is a pointer to a string literal which is typically stored in a read-only memory segment. Attempting to modify it is undefined behaviour. Pointers to string literals such as this should more properly be defined as

const char *c = "Hello World!";

but the const is often omitted (in C, at least).

C toLowerCase Function won't work - Access violation

In a comment you say that you pass in a literal string to the function, like this:

palindrome("In girum imus nocte et consumimur igni")

where palindrome passes its argument to toLower. This won't work because string literals are read-only and you are trying to modify it. Instead, you can use:

char str[] = "In girum imus nocte et consumimur igni";
palindrome(str);

Or you can have palindrome copy its argument into an array and call toLower on that.

C Access Violation error

it happens when I try to modify a string literal which is a read only

That's just one of the many ways it can happen. Another is trying to store into NULL, which is what you're doing here:

char str[80] = "Hello, there!";
char *strPtr = NULL;

my_strcpy (strPtr, str); 

You want to copy str to somewhere, but where? You haven't provided any memory to store into.
Consider

char str[80] = "Hello, there!";
char str2[sizeof str];

my_strcpy (str2, str); 

or

char str[80] = "Hello, there!";
char* strptr = malloc(sizeof str);
if (!strptr)
    /* do something on out-of-memory */;

my_strcpy (strptr, str); 

Also, my_strcpy is looping until it finds the NUL in the destination, which is of course wrong ... you can't look at the destination until you've stored something there. And, you aren't storing the NUL into the destination. Consider the simple loop

while ((*dest++ = *source++) != '\0')
    ;

Finally, you probably don't want to return dest, which now points past the NUL. Either declare my_strcpy to return void and don't return anything, or if you want it to have the same semantics as strcpy, save the original value of dest and return that, e.g.,

char* retval = dest;

while ((*dest++ = *source++) != '\0')
    ;

return retval;

or

for (char* destp = dest; (*destp++ = *source++) != '\0';)
    ;

return dest;

Pick the style you prefer.

Stack throws memory access violation

You're probably writing past the end of the deck array in loadCards(), corrupting memory.

Even if you have exactly 52 lines of data, cardlist.good() will return true until after an EOF indication.

You might want to try the following loop instead (untested):

string line;
while(getline(cardList, line) && (index < 52))
{
    char * context = NULL;
    CARD card = CARD();

    char * s = strtok_s(&line[0], ", ", &context);

    card.value = *s;

    s = strtok_s(NULL, ", ", &context);

    card.suit = s;
    card.drawn = false;

    deck[index] = card;

    index++;
}

---

Related Topics