Difference between using character pointers and character arrays

Question

Basic question.

char new_str[]="";

char * newstr;

If I have to concatenate some data into it or use string functions like strcat/substr/strcpy, what's the difference between the two?

I understand I have to allocate memory to the char * approach (Line #2). I'm not really sure how though.

And const char * and string literals are the same?

I need to know more on this. Can someone point to some nice exhaustive content/material?

Solution 1

Please go through this article below:

Also see in case of array of char like in your case, char new_str[] then the new_str will always point to the base of the array. The pointer in itself can't be incremented. Yes you can use subscripts to access the next char in array eg: new_str[3];

But in case of pointer to char, the pointer can be incremented new_str++ to fetch you the next character in the array.

Also I would suggest this article for more clarity.

Solution 2

The excellent source to clear up the confusion is Peter Van der Linden, Expert C Programming, Deep C secrets - that arrays and pointers are not the same is how they are addressed in memory.

With an array,

char new_str[];

[]

new_str[4]

new_str

[4]

Whereas, with a pointer, the compiler gives the symbol

char *newstr

newstr = malloc(10);

The char new_str[] and char *newstr are used interchangeably, since an zeroth element index of the array decays into a pointer and that explains why you could newstr[5] or *(newstr + 5) Notice how the pointer expression is used even though we have declared char *newstr, hence

*(new_str + 1) = *newstr;

*(new_str + 1) = newstr[1];

In summary, the real difference between the two is how they are accessed in memory.

Get the book and read it and live it and breathe it. Its a brilliant book! :)

Solution 3

This is a character array:

char  buf [1000];

So, for example, this makes no sense:

buf = &some_other_buf;

This is because buf, though it has characteristics of type pointer, it is already pointing to the only place that makes sense for it.

char *ptr;

On the other hand, ptr is only a pointer, and may point somewhere. Most often, it's something like this:

ptr = buf;              // #1:  point to the beginning of buf, same as &buf[0]

or maybe this:

ptr = malloc (1000);    // #2:  allocate heap and point to it

or:

ptr = "abcdefghijklmn"; // #3:  string constant

For all of these, *ptr can be written to—except the third case where some compiling environment define string constants to be unwritable.

*ptr++ = 'h';          // writes into #1: buf[0], #2: first byte of heap, or
                       //             #3 overwrites "a"
strcpy (ptr, "ello");  // finishes writing hello and adds a NUL

Solution 4

The difference is that one is a pointer, the other is an array. You can, for instance, sizeof() array. You may be interested in peeking here

Solution 5

The type of the first is char[1], the second is char *. Different types.

Allocate memory for the latter with malloc in C, or new in C++.

char foo[] = "Bar";  // Allocates 4 bytes and fills them with
                     // 'B', 'a', 'r', '\0'.

The size here is implied from the initializer string.

The contents of foo are mutable. You can change foo[i] for example where i = 0..3.

OTOH if you do:

char *foo = "Bar";

The compiler now allocates a static string "Bar" in readonly memory and cannot be modified.

foo[i] = 'X';  // is now undefined.

View more solutions