char a[SIZE]; // declares an char array of size SIZE
char *a; // declares a char pointer
// each of these declare an array of char pointers of size SIZE
ARE char *a[SIZE]; and char (*a[SIZE]); EQUIVALENT ?
And we also say string a; is actually char *a;. So the later is a
pointer to a character , which when initialised stores address of char
a. So how it acts as a string?
Well, a string is just an array of chars that terminates with a the a '\0' (which is of course a char by itself).
Array elements are stored in contiguous places in memory. The address of an array (the whole memory block), whether that's a string or just a regular char array, is the same as the address of the first byte in the array which is also the same as the address of the first element in the array as well.
You may have now concluded how a variable of type
char * is capable of storing an address of a string. And the answer, to make that clear, is that the address of a string is the same as the address of the first char in the string and thus, it is an address of a char. Therefore, a variable of type
char * has no problem storing that.
Now the question is, if a
char * variable stores an address of a char, how does the computer know whether this char is part of a string/an array or just a single char. And the short answer is that the computer doesn't bother caring about that.
What should care about that is the code that uses this
char * variable. So if I have some function that expects an argument of type string (aka
char *) and the client code passed a pointer to a char that is not '\0', then the behavior of my function will be undefined. Here's a quick example:
char src = 'a';
strcpy(dest, &src); // NOTICE a pointer to a single char is passed
Isn't it just a variable storing address of a single character.
Similar to int *i. Which is a pointer to an integer not an array of
You should have learned now that a variable of a pointer type (let's call that
T *) in general can point to either a value of type
T or an array of
Update: answering your questions in the comment
While using int array[Size]; we have to allot the size in advance. And
while using int *array; we need not allocate the size..Is that true ?
Not really. When you declare an int array
int array[size], you get size * 4 bytes (typically on most 32-bit systems) allocated for you automatically.
When using an
int * on the other hand, you may either set it to point to an address of already allocated piece of memory (whether this was allocated manually or automatically). For example:
int i = 10;
int *p = &i; // points to i
or you may allocate memory for it manually using a function like
int p0 = malloc(sizeof (int)); // allocate memory for an int and point to it
If you chose the latter though, you'll need to manually free the memory that you've allocated manually.
If we are not allocating memory to the *array; pointer variable, how
can we say that it will allocate contiguous memory,as the next memory
address might be already occupied, as we have not reserved for the
As the answer to the previous question shows, a pointer in general or an int pointer in particular does not point to anything initially (does not have memory allocated for it).
Here's another thing: the word contiguous does NOT mean that multiple calls to a function like
malloc allocate contiguous blocks in memory. It basically means that that each call allocates one block of the size provided as an argument. For example:
malloc(4 * sizeof (int));
allocates a block for 4 int values (or you could say for an array of 4 ints). These ints will live contiguously in memory.
It is not guaranteed that multiple calls to a function like
malloc will allocate contiguous blocks so you shouldn't consider that.