This article mainly tests the class size, including empty classes, static and non-static variables, virtual and non-virtual single inheritance and multi-inheritance classes, and class or object
Test whether the virtual table and virtual pointer are the same, and give a simple explanation. If there is anything inappropriate, please point out that we will exchange and make progress together!
/*************************************** *****************************
** Created by Cai guowu
** Date: 2009/5/22
** Version 1.0
** Description: test the class size and explain the reason: NULL Class, Class with static or virtual table, inheritance, virtual inheritance, and other tests
Conclusion:
1: The empty class size is 1, not 0. The reason is very simple. If it exists, it will occupy space.
2: Virtual tables and virtual functions: A class corresponds to a virtual table, and each object contains a virtual function pointer (_ vptr) pointing to the virtual table.
3: verified: whether virtual inheritance and nested virtual inheritance can also share the memory mechanism and other tests
** Application:
********** ********************
** Modifier:
** Date:
** Description:
**************************************** ****************************/
Namespace testSizeOfClass
{
/////// The size of the test class start ////////
Class CEmptyClass
{
};
// Sizeof (CEmptyClass) = 1 = "The Empty class size is 1, not 0. The reason is very simple. If it exists, it will occupy space.
Class
{
Virtual void (){}
};
// Sizeof (A) = 4 // indicates A class with A virtual table pointer, which occupies 4 bytes.
Class A1
{
Virtual void (){}
};
// Sizeof (A1) = 4 // indicates a class with a virtual table pointer, which occupies 4 bytes.
Class A2
{
Static int m_sNum;
};
// Sizeof (A2) = 1 // = "static variables do not belong to a class and are shared
Class A3
{
Virtual void (){}
Static int m_sNum;
};
// Sizeof (A3) = 4 // = "static variables do not belong to a class, but virtual pointers consume 4 bytes
Class A4
{
Bool m_bValue;
Int m_nValue;
Static int m_sNum;
};
// Sizeof (A4) = 8 // Note: Memory alignment
Class B: public
{
};
// Sizeof (B) = 4
Class B1: virtual public A // single virtual inheritance
{
};
// Sizeof (B2) = 8 // Note: a virtual pointer is added for virtual inheritance.
// If you do not take the test, perform more inheritance:
// The size of B and B1, = "virtual inheritance is four bytes larger than non-virtual inheritance, which is actually a virtual pointer, continue Test
Class B2: public A, public A1 // multiple inheritance parent classes are all with virtual classes
{
};
// Sizeof (B2) = 4
Class B3: public A1, public A2 // multiple inheritance parent classes only have one with virtual class
{
};
// Sizeof (B3) = 4 // Note: a virtual pointer is added for virtual inheritance.
// If you do not take the test, perform more inheritance:
// The size of B, B2, and B3, =, so a class has only one virtual table and has nothing to do with multi-inheritance. An object corresponds to only one virtual pointer.
// Continue the test below.
Class B4: public A, virtual public A1 // multi-inheritance, single-virtual inheritance
{
};
// Sizeof (B4) = 12 // 12 = sizeof (A) + sizeof (A1) + virtual inheritance A virtual table pointer = 4 + 4 + 4
Class B5: public virtual A, virtual public A1 // All are virtual inheritance
{
};
// Sizeof (B5) = 12 // 12 = sizeof (A) + sizeof (A1) + virtual inheritance A virtual table pointer = 4 + 4 + 4
// Virtual Multi-inheritance:
// The size of B4 and B5, = as long as it is virtual inheritance, each virtual inheritance and multiple virtual inheritance, only four bytes are added, that is, a virtual table pointer
// Class C: public A1, virtual public A1 // error. The same class can only have one inheritance method.
//{
//};
Class C1: public B, virtual public
{
};
// Sizeof (C) = 12
Class C2: public B1, virtual public
{
};
// Sizeof (C2) = 8 // Note: virtual inheritance can share memory, so class C2: public B1, virtual public A is equivalent to class C2: public B1
Class C3: public B1 // verification: Virtual inheritance can share the memory mechanism, because B1 already has virtual inheritance
{
};
// Sizeof (C3) = 8 // Note: Virtual inheritance can share memory.
Class C4: virtual public B1 // because B1 already has virtual inheritance
{
};
// Sizeof (C4) = 12 // Note: Virtual inheritance can share memory.
// Verify: whether the virtual inheritance nesting mechanism can also share the memory, because the virtual pointer of virtual B1 also points to its own virtual inherited
Class C5: virtual public B1, virtual public
{
};
// Sizeof (C5) = 12 // Note: virtual inheritance can share memory, so class C2: public virtual B1, virtual public A is equivalent to class C2: virtual public B1
////// Size of the test class end ////////
Void testSizeof (void)
{
A a1, a2;
// Virtual table pointers of different objects of the same class are the same. The test is as follows:
If (& a1 = & a2) // This is true
{
Cout <"virtual table pointers vptr of different objects of the same class are the same ";
}
Else
{
Cout <"virtual table pointer vptr of different objects of the same class is different ";
}
Int nSizeof;
CEmptyClass
NSizeof = sizeof (CEmptyClass );
NSizeof = sizeof ();
NSizeof = sizeof (A1 );
NSizeof = sizeof (A2 );
NSizeof = sizeof (A3 );
NSizeof = sizeof (A4 );
NSizeof = sizeof (B );
NSizeof = sizeof (B1 );
NSizeof = sizeof (C );
NSizeof = sizeof (C1 );
NSizeof = sizeof (C2 );
NSizeof = sizeof (C3 );
NSizeof = sizeof (C4 );
NSizeof = sizeof (C4 );
}
}
Author: caiguowu