如何检索数据类型的大小？

Question

Let a be an array. So what is the difference between a.size() and sizeof(a) ?

Answer 1

.size() can return anything, depends on how it is implemented.

Anyway, .size() usually returns the size of an container , in other words - the number of elements, that the container contains.

The sizeof operator is integrated operator, that returns the number of bytes, allocated on the stack. For example

        char a[50];
        char* b = new char[50];
        cout << sizeof( a ) << '\n';
        cout << sizeof( b );

prints 50 (which is 50 * sizeof( char ) = 50 * 1 = 50 ), and the second line prints 8 - as this is the size of the pointer ( my machine is x64 , that's why it's 8, if I had 32bit CPU, it would be 4).

cout << sizeof( *b ); would print 1, as *b dereferences the pointer and returns the first element of the array (it's the same as sizeof( b[0] ) which is sizeof( char ) )

In other words, you'd better rely on .size() if you want to see the number of elements, if it's a container and if it provides such method, of course.

---

Other example:

class A
{
        int a;
        char b[100];
};

class B
{
        int a;
        char* b;
public:
        B()
        {
                b = new char[100];
        }
        ~B()
        {
                delete[] b;
        }
};
int main()
{
        cout << sizeof( A ) << '\n';
        cout << sizeof( B ) << '\n';
        B b;
        cout << sizeof( b ) << '\n';
        return 0;
}

The first one, on a x64 plarform, will print 104, as we have 100*sizeof(char) + sizeof(int) (=4 ) ( note 104 mod 8 == 0 , you'll see why );

The second one and the third one will print the same. But note , we have alignment here! On x64, the alignment is on 8B, so sizeof( char * ) gives 8, sizeof( int ) gives 4 and this makes 12. BUT 12 mod 8 == 4 which is != 0, so because of the alignment, sizeof( B ) prints 16 ( 16 mod 8 == 0 ).

So, when you use sizeof , be very careful..
Hope that helps (:

---

For your question about list, take a look at this:

        list< int > lint;
        list< char > lchar;
        cout << sizeof( lint ) << '\n';
        cout << lint.size() << '\n';
        cout << sizeof( lchar ) << '\n';
        lint.push_back( 10 );
        lint.push_back( 10 );
        cout << lint.size() << '\n';
        cout << sizeof( lint ) << '\n';

All operators sizeof will print the same, depends on the implementation of std::list . But the first .size() will return 0, as there're no elements, and the second one will return 2, as we have 2 elements in the list.

Answer 2

sizeof(a) is the number of bytes used by a , not including any dynamically allocated memory. This is a compile time constant. You can also use it with types, sizeof(int) gives you the number of bytes in an int.

a.size() is usually defined for container types, and gives the number of elements currently in the container (not the number of bytes). This is a runtime value, that changes as you add or remove objects from the container.

Answer 3

a.size() gives you value that is special for class. For example length of a string or a list. It depends on type of a class and person who implemented it. But usually size is meaningful like in lists.

Sizeof is an operator that you should avoid if you are a beginner programmer. It was widely used in C to alloc memory. It returns how much space your object occupies in memory. In C++ we use new to dynamically allocate memory. It is much easier. More about sizeof: http://en.wikipedia.org/wiki/Sizeof

Answer 4

Not sure about a.size(), but sizeof(a) returns its length in bytes . If you want the number of elements in the array, divide it by the size of each element. For example:

int size = sizeof(myArray) / sizeof(*myArray);

Answer 5

If a is an array -

int a[5] ; // Taking it as an array that can hold integers.

Now -

a.size(); // Error. `a` is not a class type to use `.` operator on it. 

sizeof(a); // Correct. It returns 20 because 5*4 bytes.

Answer 6

sizeof is a unary operator that returns the size of the datatype , in number of bytes.

sizeof(std::array<int, 3>) == sizeof(int[3]) == 3 * sizeof(int)
class Foo
{
  int a, b;
};
sizeof(Foo) == sizeof(int) * 2

size() is a method of template<typename T, size_t S> std::array<T,S> returning the number of elements in the array.

std::array<int, 3> a = {1,2,3};
a.size() == 3;