62

I know that arrays in C are just pointers to sequentially stored data. But what differences imply the difference in notation [] and *. I mean in ALL possible usage context. For example:

char c[] = "test";

if you provide this instruction in a function body it will allocate the string on a stack while

char* c = "test";

will point to a data (readonly) segment.

Can you list all the differences between these two notations in ALL usage contexts to form a clear general view.

Sergey K.
  • 24,894
  • 13
  • 106
  • 174
Alexander Reshytko
  • 2,126
  • 1
  • 20
  • 28
  • 2
    Even though the title is exactly the same, this question is actually a lot more informative. We should re-open it! – ltjax Jul 19 '12 at 07:42
  • @ltjax And you're correct. My fault for getting trigger happy. Voted reopen. – Mysticial Jul 19 '12 at 07:48
  • 3
    ``char* c = "test";`` is a non-standard code. The correct one is ``const char* c = "test";`` – Sergey K. Jul 19 '12 at 08:31
  • Arrays in C aren't pointers, unless passed as a parameter. As for your example, think of `sizeof c` when c is an array and when it's a pointer. P.S. After reading your whole question, no, I don't think I'm ready to list all differences, those are basically different types and that's it. You may want to read the standards. – Michael Krelin - hacker Jul 19 '12 at 07:37
  • [Possible duplicate](http://stackoverflow.com/questions/2096448/do-these-statements-about-pointers-have-the-same-effect) – BlueRaja - Danny Pflughoeft Jul 19 '12 at 16:48

5 Answers5

39

According to the C99 standard:

An array type describes a contiguously allocated nonempty set of objects with a particular member object type, called the element type.

  1. Array types are characterized by their element type and by the number of elements in the array. An array type is said to be derived from its element type, and if its element type is T, the array type is sometimes called array of T. The construction of an array type from an element type is called array type derivation.

A pointer type may be derived from a function type, an object type, or an incomplete type, called the referenced type. A pointer type describes an object whose value provides a reference to an entity of the referenced type. A pointer type derived from the referenced type T is sometimes referred to as a pointer to T. The construction of a pointer type from a referenced type is called pointer type derivation.

According to the standard declarations

char s[] = "abc", t[3] = "abc";
char s[] = { 'a', 'b', 'c', '\0' }, t[] = { 'a', 'b', 'c' };

are identical. The contents of the arrays are modifiable. On the other hand, the declaration

const char *p = "abc";

defines p with the type as pointer to constant char and initializes it to point to an object with type constant array of char (in C++) with length 4 whose elements are initialized with a character string literal. If an attempt is made to use p to modify the contents of the array, the behavior is undefined.

According to 6.3.2.1 Array subscripting dereferencing and array subscripting are identical:

The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))).

The differences of arrays and pointers are:

  • pointer has no information of the memory size behind it (there is no portable way to get it)
  • an array of incomplete type cannot be constructed
  • a pointer type may be derived from an incomplete type
  • a pointer can define a recursive structure (this one is the consequence of the previous two)

More helpful information on the subject can be found at http://www.cplusplus.com/forum/articles/9/

AksLolCoding
  • 157
  • 10
Sergey K.
  • 24,894
  • 13
  • 106
  • 174
  • 4
    "constant pointer to char" shouldn't that be "pointer to constant char"? After all the pointer is modifiable. – elmo Jul 19 '12 at 13:10
  • 2
    "and initializes it to point to an object with type ‘‘constant array of char’’". In C++, but not in C. In C, the object `"abc"` has type `char[4]`. Nevertheless, attempting to modify it is UB. Might be good to point out the difference. – Daniel Fischer Jul 19 '12 at 14:05
13
char c[] = "test";

This will create an array containing the string test so you can modify/change any character, say

c[2] = 'p';

but, 

char * c = "test"

It is a string literal -- it's a const char.
So doing any modification to this string literal gives us segfault. So 

c[2] = 'p';

is illegal now and gives us segfault.

neel
  • 8,399
  • 7
  • 36
  • 50
  • 4
    ``char * c = "test"`` is a bad C-code that yields warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings]. Use ``const char*`` instead. – Sergey K. Jul 19 '12 at 08:38
4

char [] denotes the type "array of unknown bound of char", while char * denotes the type "pointer to char". As you've observed, when a definition of a variable of type "array of unknown bound of char" is initialised with a string literal, the type is converted to "array[N] of char" where N is the appropriate size. The same applies in general to initialisation from array aggregate:

int arr[] = { 0, 1, 2 };

arr is converted to type "array[3] of int".

In a user-defined type definition (struct, class or union), array-of-unknown-bound types are prohibited in C++, although in some versions of C they are allowed as the last member of a struct, where they can be used to access allocated memory past the end of the struct; this usage is called "flexible arrays".

Recursive type construction is another difference; one can construct pointers to and arrays of char * (e.g. char **, char (*)[10]) but this is illegal for arrays of unknown bound; one cannot write char []* or char [][10] (although char (*)[] and char [10][] are fine).

Finally, cv-qualification operates differently; given typedef char *ptr_to_char and typedef char array_of_unknown_bound_of_char[], cv-qualifiying the pointer version will behave as expected, while cv-qualifying the array version will migrate the cv-qualification to the element type: that is, const array_of_unknown_bound_of_char is equivalent to const char [] and not the fictional char (const) []. This means that in a function definition, where array-to-pointer decay operates on the arguments prior to constructing the prototype,

void foo (int const a[]) {
    a = 0;
}

is legal; there is no way to make the array-of-unknown-bound parameter non-modifiable.

ecatmur
  • 152,476
  • 27
  • 293
  • 366
1

The whole lot becomes clear if you know that declaring a pointer variable does not create the type of variable, it points at. It creates a pointer variable.

So, in practice, if you need a string then you need to specify an array of characters and a pointer can be used later on.

Solomon Ucko
  • 5,724
  • 3
  • 24
  • 45
Shash
  • 4,160
  • 8
  • 43
  • 67
0

Actually arrays are equivalent to constant pointers.

Also, char c[] allocates memory for the array, whose base address is c itself. No separate memory is allocated for storing that address.

Writing char *c allocates memory for the string whose base address is stored in c. Also, a separate memory location is used to store c.

Cygnus
  • 3,222
  • 9
  • 35
  • 65
  • 4
    We obviously both know what we're talking about, but it's reckless to say they are equivalent. Arrays decay into pointers, but that's not the same as *being* a pointer. In the same way `MyClass` is not equivalent to `int`, even if there is an implicit conversion. – tenfour Jul 19 '12 at 09:22