Thread: char * array and sizeof

Hi there. I'm trying to understand this code to get a better idea of pointers.
My question is why the value of sizeof(pstr[0]) is 4 rather than 15 ("Robert Redford" + '\0')?
And strlen works fine here. Should I trust it more than sizeof?

Code:

#include <iostream>
using std::cout;


#include<cstring>
using std::strlen;

int main()
{
   char* pstr[] =  { "Robert Redford",      
                     "Hopalong Cassidy",
                     "Lassie",
                     "Slim Pickens",
                     "Boris Karloff",
                     "Oliver Hardy"
                   };
   
  
  cout<<pstr[0]; //pstr[0] is non-const pointer to const char array "Robert Redford"
  cout<<sizeof(pstr[0]);  
  cout<<strlen(pstr[0]);
  
  
  
    getchar();
   return 0;
}

Notice that this program works fine in DEV-C++
(while in MS Visual I get an error that strlen is not member of std; weird)

Code:

2.2: But I heard that char a[] was identical to char *a.

Not at all.  (What you heard has to do with formal parameters to functions; see question 2.4.)  Arrays are not pointers.  The array declaration "char a[6];" requests that space for six characters be set aside, to be known by the name "a."  That is, there is a location named "a" at which six characters can sit. The pointer declaration "char *p;" on the other hand, requests a place which holds a pointer.  The pointer is to be known by the name "p," and can point to any char (or contiguous array of chars) anywhere.

As usual, a picture is worth a thousand words.  The statements

	char a[] = "hello";
	char *p = "world";

would result in data structures which could be represented like this:

	   +---+---+---+---+---+---+
	a: | h | e | l | l | o |\0 |
	   +---+---+---+---+---+---+

	   +-----+     +---+---+---+---+---+---+
	p: |  *======> | w | o | r | l | d |\0 |
	   +-----+     +---+---+---+---+---+---+

It is important to realize that a reference like x[3] generates different code depending on whether x is an array or a pointer. Given the declarations above, when the compiler sees the expression a[3], it emits code to start at the location "a," move three past it, and fetch the character there.  When it sees the expression p[3], it emits code to start at the location "p," fetch the pointer value there, add three to the pointer, and finally fetch the character pointed to.  In the example above, both a[3] and p[3] happen to be the character 'l', but the compiler gets there differently.  (See also questions 17.19 and 17.20.) 

2.6: Why doesn't sizeof properly report the size of an array which is a parameter to a function?

The sizeof operator reports the size of the pointer parameter which the function actually receives (see question 2.4).

Basically, you're taking the sizeof a pointer, rather than the array that it points to.

Thanks for your help. Although your answer is well stated I can't understand it very well.

It sounds funny but I think I get everything
except for your last sentence(and most important)

Can you give me a link for the "see question" that you write?

pstr is an array of pointers. So, every element in the pstr array is a pointer. When you write:

sizeof(pstr[0]);

you are asking for the size of the first pointer in the array. Pointers store addresses in memory. Try this:

Code:

int num = 10;
int* ptr = #
cout<<ptr<<endl;

You won't get 10 as the output--you'll get the address in memory where 10 is stored as the output--something like 006BFDC8. The sizeof a pointer is the sizeof the address 006BFDC8, which is an integer written in hexidecimal notation.

Of course to get the thing a pointer points to, you can dereference the pointer with '*', like so:

*pstr[0]

So you might try:

cout<< sizeof *pstr[0];

However, a pointer to a string points to the first char in the string, so you will end up getting the size of the first character, which is 1.

The botton line is: when you want to get the length of a cstyle string, you should use strlen().

Thanx both of you for your answers.
The helped me get a better idea.