When declare char Str[16] then Str is a pointer?

char str[16];

isn't a pointer, it's an array of 16 characters. A array is a block of contiguous things in memory, a pointer is a variable that contains the address of something else.

Where you might be getting confused is that the name of an array is synonymous with the address of the first element of the array. So you can use the name of an array to initialise or assign to pointers.

So if you have a pointer you can use array style indexing on it, but if you have an array name you CAN'T do pointer style assignment on it. If you do something like:

char str[16];
char *p = str;

str and p refer to the same location in memory. You can then do something like:

p++;

and p will now point to the memory location of str[ 1 ]. However if you try:

str++;

the compiler will tell you take a walk as you can't modify the value str represents, it's a constant (it's an rvalue in standard speak if you ever try reading it, at least in C90, not sure about C99).

So the differences between array names and pointers are:

- pointers contain addresses
- array names are addresses
- doing a sizeof array_name gives you the number of bytes in the array
- doing a sizeof a pointer returns the number of bytes it takes to hold an address on your system

Now there's another source of confusion. When you pass an array to a function the compiler takes the address of the first element in the array and converts it to a pointer. So when you see a function prototype like:

void test( char b[ 20 ] );

you can read it like:

void test( char *b );

and if you do a sizeof on b within the function it'll come back as 4 or 8 (perhaps 2 on very old or embedded systems) depending on you compiler.

So we can add to the rules a bit:

- pointers contain addresses
- array names are addresses
- doing a sizeof array_name gives you the number of bytes in the array
- doing a sizeof a pointer returns the number of bytes it takes to hold an address on your system
- read all array names passed to functions as pointers within the scope of that function

Cheers,

Ash

The question if not correct: a pointer or not a pointer -- still a variable, or a function parameter. A str is a pointer in both cases.

The difference between your first and last line: if first line, the pointer is not yet initialized: on what character is points? In second line, a memory is allocated for 16 characters. If this is a local declaration, it is allocated on local stack when a function is executed, if not -- in the process static memory. The pointer is already initialized and point to the first character of the array of 16.

[EDIT]
Well, due to harsh arguments on this page, I admit I need to elaborate on the topic "array vs pointer".

Of course I understand that array and pointer are not exactly the same. In the above paragraph I described the difference in memory layout: with array, memory is always taken during initialization (stack or static). There is more to it. Consider the sample:

char arr[16];
	
//will not compile: unknown size:
//char arr2[];
	
for(int index = 0; index < 16; index++)
   arr[index] = index + (int)'0';char* ptr;
ptr = arr;
ptr = &arr[0]; //same thing as before
char third = ptr[3]; //returns '3'
ptr[3] = '?'; //mutable

//makes no sense, compiler does not
//perform static check but it could
//can cause corruption during run-time:
ptr[9000] = '!';
	
//will not compile: "arr is a constant pointer",
//can be initialized, not assigned:
//arr = ptr;

So, during run-time arr behaves as a constant pointer, but the memory area it points to is mutable (pointer arr is constant, character arr[3] is not). There is not direct way to modify err as a pointer: it won't compile (last line of the sample).

During design time, there are more essential differences. In particular, array length is statically known, etc.

Your first example creates a pointer str (with unknown value).
Your second example creates an array of 16 chars, and sets the value of str to the address of (the first char in) the array.
In both cases, str works as a pointer; in the second case it is actually pointing to something.