收录日期:2019/10/22 15:04:24 时间:2012-12-20 12:03:48 标签:c,pointers,char,segmentation-fault,access-violation

With c-style strings, how do you assign a char to a memory address that a character pointer points to? For example, in the example below, I want to change num to "123456", so I tried to set p to the digit where '0' is located and I try to overwrite it with '4'. Thanks.

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char* num = (char*)malloc(100);
    char* p	= num;

    num = "123056";

    p = p+3;	//set pointer to where '4' should be
    p = '4';

    printf("%s\n", num );

    return 0;
}

That code won't work, simply because the line:

num = "123056";

changes num to point away from the allocated memory (and p remains pointing to the that memory so they're no longer the same location) to what is most likely read-only memory. You are not permitted to change the memory belonging to string literals, it's undefined behaviour.

You need the following:

#include <stdio.h>
#include <stdlib.h>
int main (void) {
    char *num = malloc (100); // do not cast malloc return value.
    char *p = num;

    strcpy (num, "123056");   // populate existing block with string.

    p = p + 3;                // set pointer to where '0' is.
    *p = '4';                 // and change it to '4'.

    printf ("%s\n", num );    // output it.

    return 0;
}

First of all, when you do:

num = "123056";

You are not copying the string "123056" to the area of heap allocated by malloc(). In C, assigning a char * pointer a string literal value is equivalent to setting it as a constant - i.e. identical to:

char str[] = "123056";

So, what you've just accomplished there is you've abandoned your sole reference to the 100-byte heap area allocated by malloc(), which is why your subsequent code doesn't print the correct value; 'p' still points to the area of heap allocated by malloc() (since num pointed to it at the time of assignment), but num no longer does.

I assume that you actually intended to do was to copy the string "123056" into that heap area. Here's how to do that:

strcpy(num, "123056");

Although, this is better practice for a variety of reasons:

strncpy(num, "123056", 100 - 1);  /* leave room for \0 (null) terminator */

If you had just done:

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

int     main(void) {
        char    *num = malloc(100);
        char    *p = num;

        strncpy(num, "123056", 100 - 1);

        p = p + 3;
        *p = '4';

        printf("%s\n", num);

       return 0;
}

You would have gotten the correct result:

123456

You can contract this operation:

p = p + 3;
*p = '4';

... and avoid iterating the pointer, by deferencing as follows:

*(p + 3) = '4';

A few other notes:

  • Although common stylistic practice, casting the return value of malloc() to (char *) is unnecessary. Conversion and alignment of the void * type is guaranteed by the C language.

  • ALWAYS check the return value of malloc(). It will be NULL if the heap allocation failed (i.e. you're out of memory), and at that point your program should exit.

  • Depending on the implementation, the area of memory allocated by malloc() may contain stale garbage in certain situations. It is always a good idea to zero it out after allocation:

    memset(num, 0, 100);
    
  • Never forget to free() your heap! In this case, the program will exit and the OS will clean up your garbage, but if you don't get into the habit, you will have memory leaks in no time.

So, here's the "best practice" version:

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

int     main(void) {
        char    *num, *p;

        /*
         * Don't take 1-byte chars for granted - good habit to get into.
         */

        num = malloc(sizeof(char) * 100);

        if(num == NULL)
                exit(1);

        memset(num, 0, sizeof(char) * 100);

        p = num;

        strncpy(num, "123056", 100 - 1);

        *(p + 3) = '4';

        printf("%s\n", num);

        free(num);

        return 0;
}

In addition to the *p issue others have pointed out, you also have memory usage issues. You have one buffer of 100 bytes, with unknown contents. You have another buffer of 7 bytes, containing the string "123056" and a null terminator. You're doing this:

  1. num is set to point to the 100 byte buffer
  2. p is set to point to num; ie, it points to the 100 byte buffer
  3. you reset num to point to the 7 byte buffer; p is still pointing to the 100 byte buffer
  4. You use p to modify the 100 byte buffer
  5. then you use num to print out the 7 byte buffer

So you're not printing the same buffer that you are modifying.

Well, you know p is pointer type. It stores the address of char '0'. If you assign p the value of '4'. It will take '4' as the address. However, the address '4' is illegal. You can use '*' operator to get the value the address which is stored in p stored .

Just use *p = '4';...!