Size of an array pointed to by a pointer

Question

So I've been searching on Stackoverflow for all the code that can find the size of a pointer to an array. I couldn't find it.

int main() {
    int array[] = {6,3, 4, 6, 2};
    int *sizes = array;
    cout << sizeof(sizes); // output is 8
}

Using sizeof doesn't work. Can anyone suggest a good solution? Thanks a lot!

**EDIT:

I want to find the size of the array using the pointer "sizes". I know how to find the size using the "array" variable

Answer 1

You can read in c++ doc http://www.cplusplus.com/reference/array/array/size/

For example:

// array::size
#include <iostream>
#include <array>

int main ()
{
  std::array<int,5> myints;
  std::cout << "size of myints: " << myints.size() << std::endl;
  std::cout << "sizeof(myints): " << sizeof(myints) << std::endl;

  return 0;
}

Answer 2

If you want C level answer, why did you tag this question as c++?

int main() {
    int array[] = {6,3, 4, 6, 2};
    cout << sizeof(array) / sizeof(int);
    return 0;
}

It might not be satisfy but it's impossible to find the array's size using a pointer to the array. Pointer unlike the array, can point to any type of variable with the right casting. It doesn't store a straight memory allocation places like the array. That's why you'll always get 8 bytes in 64bit OS architecture or 4 bytes in 32bit OS architecture of size when you do sizeof(pointer).

Read about the differences between pointers and arrays in c.

Answer 3

Within the scope that array was declared in, sizeof(array) is the number of bytes in the array.¹

If you want the number of elements in array, that’s (sizeof(array)/sizeof(array[0])).

Since sizes is declared as an int*, sizeof(sizes) is the size of a pointer. That will be 8 for a 64-bit program, 4 for a 32-bit program, or some other size on an unusual architecture.

There is one other wrinkle: if you pass array to a function, such as:

int* reverse_array( int a[], const size_t n )
{
  assert( sizeof(a) == sizeof(int*) );
  // ...
}

Then the array parameter, a, automatically degrades to a pointer, and the compiler forgets its actual size. This is for backward-compatibility with C.

To use an array within another function, you must pass the size as a separate parameter, in this case n, or use a type such as std::array<int>, std::vector<int>, or a struct. The latter is what Bjarne Stroustrup’s C++ guidelines recommend, although, if you use a STL template in the ABI of a library, you are introducing a dependency on a particular implementation of the STL.

¹ Since this community loves language-lawyering: some historical C compilers measured sizes in increments other than bytes. Some C++ compiler hypothetically might make char more than 8 bits wide (although not less!) and claim to be technically conforming to the standard. You don’t need to worry about that possibility right now. Seriously, you don’t.