विषय पर बढ़ें

💡 सारांश：/ @file blackclass.cpp @brief खाली क्लास का आकार 1 बाइट होता है @author 光城 @version v1 @date 2019-07-21 / using namespace std; class A{}; int main cout<<sizeofA<<endl; r

अंतिम अद्यतन：2026-10-13

C++ sizeof: टाइप साइज़ और खाली क्लास

पहले एक सारांश, फिर नीचे वास्तविक उदाहरण दिए गए हैं। अभ्यास शुरू करें!

  • खाली क्लास का आकार 1 बाइट होता है
  • एक क्लास में, वर्चुअल फ़ंक्शन स्वयं, मेंबर फ़ंक्शन (स्टैटिक और नॉन-स्टैटिक दोनों) तथा स्टैटिक डेटा मेंबर क्लास ऑब्जेक्ट की स्टोरेज स्पेस नहीं घेरते।
  • वर्चुअल फ़ंक्शन युक्त क्लास के लिए, चाहे कितने ही वर्चुअल फ़ंक्शन क्यों न हों, केवल एक ही वर्चुअल पॉइंटर होता है — vptr का आकार।
  • सामान्य इनहेरिटेंस में, डिराइव्ड क्लास बेस क्लास के सभी फ़ंक्शन और मेंबर इनहेरिट करती है, और आकार बाइट अलाइनमेंट के अनुसार गणना करना होता है
  • वर्चुअल फ़ंक्शन इनहेरिटेंस में, सिंगल या मल्टीपल इनहेरिटेंस हो, बेस क्लास का vptr ही इनहेरिट होता है। (32-बिट ऑपरेटिंग सिस्टम पर 4 बाइट, 64-बिट ऑपरेटिंग सिस्टम पर 8 बाइट)!
  • वर्चुअल इनहेरिटेंस में, बेस क्लास का vptr इनहेरिट होता है। ध्यान दें कि परिणाम कंपाइलर पर निर्भर करता है: GCC वर्चुअल बेस पॉइंटर को वर्चुअल फ़ंक्शन तालिका पॉइंटर के साथ मिला देता है (जैसे 8/8/16), जबकि MSVC/Windows उन्हें अलग-अलग संग्रहीत करता है (जैसे 8/8/32); देखें issue #246।

1. सिद्धांत 1

/**
 * @file blackclass.cpp
 * @brief 空类的大小为1字节
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */
#include<iostream>
using namespace std;
class A{};
int main()
{
    cout<<sizeof(A)<<endl;
    return 0;
}

2. सिद्धांत 2

/**
 * @file static.cpp
 * @brief 静态数据成员
 * 静态数据成员被编译器放在程序的一个global data members中，它是类的一个数据成员，但不影响类的大小。不管这个类产生了多少个实例，还是派生了多少新的类，静态数据成员只有一个实例。静态数据成员，一旦被声明，就已经存在。 
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */
#include<iostream>
using namespace std;
class A
{
    public:
        char b;
        virtual void fun() {};
        static int c;
        static int d;
        static int f;
};

int main()
{
    /**
     * @brief 16  字节对齐、静态变量不影响类的大小、vptr指针=8
     */
    cout<<sizeof(A)<<endl; 
    return 0;
}

3. सिद्धांत 3

/**
 * @file morevir.cpp
 * @brief 对于包含虚函数的类，不管有多少个虚函数，只有一个虚指针,vptr的大小。
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */
#include<iostream>
using namespace std;
class A{
    virtual void fun();
    virtual void fun1();
    virtual void fun2();
    virtual void fun3();
};
int main()
{
    cout<<sizeof(A)<<endl; // 8
    return 0;
}

4. सिद्धांत 4 और 5

/**
 * @file geninhe.cpp
 * @brief 1.普通单继承,继承就是基类+派生类自身的大小(注意字节对齐)
 * 注意：类的数据成员按其声明顺序加入内存，无访问权限无关，只看声明顺序。
 * 2.虚单继承，派生类继承基类vptr
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */

#include<iostream>

using namespace std;

class A
{
    public:
        char a;
        int b;
};

/**
 * @brief 此时B按照顺序：
 * char a
 * int b
 * short a
 * long b
 * 根据字节对齐4+4+8+8=24
 * 
 * 或编译器优化
 * char a
 * short a
 * int b
 * long b
 * 根据字节对齐2+2+4+8=16
 */
class B:A
{
    public:
        short a;
        long b;
};
/**
* 把A的成员拆开看，char为1，int为4，所以是1+（3）+4+1+（3）=12，（）为字节补齐
*/
class C
{
    A a;
    char c;
};

class A1
{
    virtual void fun(){}
};
class C1:public A1
{
};


int main()
{
    cout<<sizeof(A)<<endl; // 8
    cout<<sizeof(B)<<endl; // 16 或 24
    cout<<sizeof(C)<<endl; // 12

    /**
     * @brief 对于虚单函数继承，派生类也继承了基类的vptr，所以是8字节
     */
    cout<<sizeof(C1)<<endl; // 8 
    return 0;
}

5. सिद्धांत 6

/**
 * @file virnhe.cpp
 * @brief 虚继承
 * @author 光城
 * @version v1
 * @date 2019-07-21
 */

#include<iostream>
using namespace std;
class A
{
    virtual void fun() {}
};
class B
{
    virtual void fun2() {}
};
class C : virtual public  A, virtual public B
{
    public:
        virtual void fun3() {}
};

int main()
{
    /**
     * @brief 8 8 16  派生类虚继承多个虚函数，会继承所有虚函数的vptr
     */
    cout<<sizeof(A)<<" "<<sizeof(B)<<" "<<sizeof(C);

    return 0;
}

सामान्य प्रश्न

खाली क्लास का sizeof 1 क्यों है?

C++ चाहता है कि अलग ऑब्जेक्ट के अलग पते हों; साइज़ 0 होता तो ऐरे तत्वों के पते मिल जाते, इसलिए न्यूनतम 1 बाइट।

वर्चुअल फ़ंक्शन से sizeof कितना बढ़ता है?

एक vptr: 64-बिट प्लेटफ़ॉर्म पर 8 बाइट। मल्टीपल इनहेरिटेंस में कई vptr हो सकते हैं।

sizeof कंपाइल टाइम पर या रनटाइम पर?

C++ में हमेशा कंपाइल टाइम पर; परिणाम कॉन्स्टेंट एक्सप्रेशन है, ऐरे आयाम या टेम्पलेट तर्क में उपयोगी।

संबंधित विषय

टिप्पणियाँ