C char pointer vs pointer to char array, increment dynamic allocation

Question

I am new to C, and I am having difficulty understanding the reason why the block of code below is not working.

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

int main()
{
    char *src = "http://localhost";

    /* THIS WORKS
       char scheme[10];
       char *dp = scheme;
     */

    //DOESN'T WORK
    char *dp = malloc(10);

    while (*src != ':') {
        *dp = *src;
        src++;
        dp++;
    }
    *dp = '\0';

    /* WORKS
       puts(scheme)
     */

    //DOESN'T WORK
    puts(dp);
}

The expected output is http to stdout. In both cases dp should be a pointer to an array of char pointers (char **). However it is printing nothing when using malloc method. I ran the code through GDB and my src and dp are getting erased 1 character at a time. If I enclose the while loop into a function call it works. I figured that the reason was because parameters are evaluated as a copy. However, then I read that arrays are the exception and passed as pointers. Now I am confused. I can work around this, but I am trying to understand why this way doesn't work.

pmg · Accepted Answer · 2011-05-31 21:10:21Z

10

You are changing dp inside the loop

dp = malloc(10);

let's say dp has the value 0x42000000

while () {
    dp++;
}

let's say the loop went 4 times, so dp has the value 0x42000004

*dp = 0;

now you put a null character at the address pointed to by dp

puts(dp);

and then you try to print that null :)

Save dp and print the saved value

dp = malloc(10);
saveddp = dp;
/* ... */
puts(saveddp);
free(saveddp); /* for completeness */

It works with scheme because scheme is an array and you cannot change that address!

answered May 31, 2011 at 21:10

pmg

109k14 gold badges132 silver badges203 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Blagovest Buyukliev · Accepted Answer · 2011-05-31 21:08:09Z

4

After the end of the loop, dp points to the end of the allocated string. You need to save dp right after the malloc and increment the copy, not the original pointer to the beginning.

answered May 31, 2011 at 21:08

Blagovest Buyukliev

43.7k14 gold badges96 silver badges135 bronze badges

1 Comment

Nemo Over a year ago

And maybe declare it as char *const dp = malloc(10); so the compiler won't let you make this mistake.

phoxis · Accepted Answer · 2011-06-01 05:35:15Z

Before the loop starts the dp points to the start of the memory you have allocated. At each iteration you copy the character pointed by src into the currently pointed location of dp and step forward one memory location pointed by dp. At the end of the loop dp is pointing at the memory location right after the character p where you have assigned a '\0'. When you attempt to print the string with puts (dp) because the contents of dp has changed and now points to a location right after the last character copied, it will start printing from that location. It will print an empty string as the very first location pointed by dp is a null character.

Before Loop

+----------+
|   src    |
+----------+
   |
   | 
   V
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+
|  h  |  t  |  t  |  p  |  :  |  /  |  /  |     . . .   ? |  ? |
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+

+----------+
|    dp    |
+----------+
   |
   | 
   V
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+
|     |     |     |     |     |     |     |     . . .     |    |
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+

After Loop (with dp = malloc (10))

                      +----------+
                      |   src    |
                      +----------+
                           |
                           | 
                           V
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+
|  h  |  t  |  t  |  p  |  :  |  /  |  /  |     . . .     |  ? |
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+

                      +----------+
                      |    dp    |
                      +----------+
                           |
                           | 
                           V
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+
|  h  |  t  |  t  |  p  |  \0 |     |     |     . . .     |    |
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+

Note puts (dp) will start printing print from the location pointed above. This will not get the intended output. Also because you have not saved the original address of dp which you have actually allocated. You are not able to restore it after the loop.

After Loop (with dp = &scheme)

                      +----------+
                      |   src    |
                      +----------+
                           |
                           | 
                           V
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+
|  h  |  t  |  t  |  p  |  :  |  /  |  /  |     . . .     |  ? |
+-----+-----+-----+-----+-----+-----+-----+----       ----+----+

                              +----------+
                              |    dp    |
                              +----------+
                                   |
                                   | 
                                   V
        +-----+-----+-----+-----+-----+-----+-----+----       ----+----+
scheme[ |  h  |  t  |  t  |  p  |  \0 |     |     |     . . .     |    | ]
        +-----+-----+-----+-----+-----+-----+-----+----       ----+----+

puts (scheme) will work because it still refers to the base of the array
puts (dp) will not work because it does not point to the base of the array
         and currently points to a location pointing to null character

In the above commented solution of yours works because, you use the scheme array to print the string. scheme refers to the array you want to print and scheme refers to the base address of the array because you have not modified it (and it cannot be modified). This is why it starts from the base and prints upto the '\0' you have assigned after the loop.

You can either do

 int i;
 for (i=0; (src[i] != ':') && (src[i] != '\0'); i++)
 {
    dp[i] = src[i];
 }

or do the below

 char *dp_bak;
 char *dp = malloc(10);
 dp_bak = dp; /* Backup the base address */

 while (*src != ':')
 {
     *dp = *src;
     src++;
     dp++;
 }
 *dp = '\0';
 dp = db_bak; /* Restore the base address */

 puts (dp);

jbruni · Accepted Answer · 2011-05-31 21:11:38Z

-2

Indeed, as pointed out above, "scheme" was your pointer to the beginning of the string, and dp was your iterator.

char *scheme = malloc(10), *dp = scheme;

...

puts(scheme);

answered May 31, 2011 at 21:11

jbruni

1,2398 silver badges12 bronze badges

Collectives™ on Stack Overflow

C char pointer vs pointer to char array, increment dynamic allocation

4 Answers 4

Comments

1 Comment

Before Loop

After Loop (with dp = malloc (10))

After Loop (with dp = &scheme)

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

1 Comment

Before Loop

After Loop (with dp = malloc (10))

After Loop (with dp = &scheme)

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related