void myfunc(char* passedArray)
{
cout << sizeof(passedArray) << endl; // prints 4
}
int main(void)
{
char charArray[] = "abcdefghiklmop";
cout << sizeof(charArray) << endl; // prints 15
myfunc(charArray);
cout << sizeof(charArray) << endl; // prints 15
}
I believe it should still print 15 inside that function...
This is a classic problem with pointers and arrays. The issue is that arrays decay to pointers, as you can see. Pointer types hold no metadata about the data it points to except for the size of the pointed to type. All other metadata, such as array length is lost.
The issue therefore is that you have called myfunc with a pointer to the array; all metadata about the array is then invisible to the myfunc function. This then triggers a subtle difference in the sizeof operator, which is that when it is applied to a pointer, it gives the size of the pointer type, not the length of the array. When applied to an array however, it gives the length of the array, as you can see in the main function.
Short fix, use strlen instead.
Although you defined your array as char charArray[], when you pass it to your function that takes char*, the charArray is being converted into the pointer to the first element, thus when you call sizeof in the body of your function, it prints the size of the pointer (which is 4 bytes on 32bit machines) as expected.
Even if your function took char passedArray[] as an argument, original charArray would be decayed into pointer to the first element and ability to retrieve the size of this array by calling sizeof would be lost. (see What is array decaying?).
So you can call strlen() to retrieve the size of this C-style string but since you are writing C++ code then the most reasonable solution is to use std::string instead of C-style strings.
First, what do you expect? You've defined passedArray to be
a pointer, so sizeof(passedArray) will return the size of
a pointer on your machine. What else could it do? I could
understand some confusion if your function was:
void myFunc( char passedArray[15] )
A reasonable person could expect sizeof(passedArray) to be 15
in this case (but he'd be wrong, because when used as
a parameter, and array is converted by the compiler into
a pointer, and this definition is exactly the same as yours).
The answer to all this is to use std::string:
void
myFunc( std::string const& passedValue )
{
std::cout << passedValue.size() << std::endl;
}
Unlike char[], std::string actually works. C style arrays,
whether used as strings or not, are broken, and should only be
used in a very limited set of cases, mostly related to objects
with static lifetime and order of initialization issues.
Use strlen(), not sizeof(), to get the length of your string.
In C, a string is just a zero-terminated character array. There is no special String type in C. strlen() is a function which counts the number of characters until the terminating zero byte.
sizeof() is an operator which can be used to determine the size of a variable or of a datatype. In your case, sizeof() returns the size of the char* pointer (which seems to be 4 bytes on your platform).
Inside the function, this
cout << sizeof(passedArray) << endl;
is printing the size of a passedArray, which is achar*. A pointer is size 4 on your platform. If you pass a pointer to a function, the function has no way of knowing that it is pointing to the first element of a fixed size array. If you want the size of a fixed array, then pass an array, not a pointer:
template< class T, size_t N >
void myfunc( const T (&passedArray)[N] )
{
std::cout << N << "\n";
}
sizeof(char*) gives the size of the pointer, not of the pointed-to string.
What you really want is strlen.
The reason why it gives the string size in main() is because it's defined as a char[] (an array which size is known at compile-time) not a char*.
sizeof(passedArray) returns size of the pointer passedArray, which is of type char *, and in your system, apparently 4 bytes.
use strlen instead, or rather, use std::string
