当前位置：首页 > news >正文

五道口网站建设公司北京培训seo哪个好

news 2025/8/1 10:50:35

五道口网站建设公司,北京培训seo哪个好,团队做网站分工,建设网站模板前言类占内存空间是只类实例化后占用内存空间的大小，类本身是不会占内存空间的。用 sizeof 计算类的大小时，实际上是计算该类实例化后对象的大小。空类占用1字节原因：C要求每个实例在内存中都有一个唯一地址，为了达到这个目的&am…

前言

类占内存空间是只类实例化后占用内存空间的大小，类本身是不会占内存空间的。用 sizeof 计算类的大小时，实际上是计算该类实例化后对象的大小。空类占用1字节原因：C++要求每个实例在内存中都有一个唯一地址，为了达到这个目的，编译器会给空类隐含添加1字节，保证空类实例化后在内存中得到的地址是独一无二的。

在C++里空类占的存储空间是0吗？类的成员函数占存储空间吗？类的虚成员函数占存储空间吗？如果对这几个问题的回答不是很确定的话，此篇内容可供参考。

1.空类占用1个字节的存储空间

#include <iostream>
using namespace std;class A {};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;// 定义两个对象a1,a2A a1;A a2;cout << "由类A实例化后的对象a1的地址：" << &a1 << endl;cout << "由类A实例化后的对象a2的地址：" << &a2 << endl;system("pause");return 0;
}

输出结果：（每次运行程序时系统为对象 a1、a2 分配的地址不唯一）

原因：类中没有任何成员变量，占用的存储大小本该为0，但是如果是0，类实例化出的对象就不会在内存上占用空间，没有地址，也就无法区分这些对象。为了解决这个问题，编译器会给空类隐含加一个字节，保证用此类定义的对象都有一个独一无二的地址。

2.类中的普通变量占用存储空间

#include <iostream>
using namespace std;class A {int a; // int类型变量achar p; // char类型变量p
};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;system("pause");return 0;
}

输出结果：

记得对齐的问题，这点和 struct 的对齐原则很像！int 占 4 字节，char 占 1 字节，补齐 3 字节。因此类 A 占8字节！

3.类的成员函数（非虚函数）不占用存储空间

在1的基础上增加类的成员函数做测试：

#include <iostream>
using namespace std;class A {
public:A(){} // 构造函数~A(){} // 析构函数int func1(){ return 0;} // 普通成员函数int func2(){ return 0;} // 普通成员函数
};int main(){cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;return 0;
}

输出结果：

原因：成员函数（包括构造和析构函数）编译后存放在代码区，不占用类的存储空间。

4.类的静态成员变量不占用存储空间

在3的基础上定义一个静态成员变量做测试：

#include <iostream>
using namespace std;class A {
public:A() {} // 构造函数~A(){} // 析构函数int func1() { return 0; } // 普通成员函数int func2() { return 0; } // 普通成员函数private:static int num; // 类的静态成员变量
};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;system("pause");return 0;
}

输出结果：

原因：类里的静态成员变量在全局数据区中分配空间，不占用类的存储空间，全局只有一份，不会随着类的实例化存储在每个对象里。

5.类中的虚函数占用存储空间，但所占的空间不会随着虚函数的个数增长

在4的基础上定义3个虚成员函数做测试：

#include <iostream>
using namespace std;class A {
public:A() {} // 构造函数~A(){} // 析构函数int func1() { return 0; } // 普通成员函数int func2() { return 0; } // 普通成员函数// 3个虚函数virtual int func3() { return 0; }virtual int func4() { return 0; }virtual int func5() { return 0; }virtual int func6() { return 0; }
private:static int num; // 类的静态成员变量
};int main() {cout << "类A所占空间大小：" << sizeof(A) << "byte" << endl;system("pause");return 0;
}

输出结果：

(1) x86<32位> 情况下：

(2)x64<64位> 情况下：

原因：C++ 类中有虚函数的时候有一个指向虚函数的指针，在 32 位系统分配指针大小为 4 字节，而在 64 位系统分配指针大小为 8 字节。无论多少个虚函数，只有这一个指针，4 字节（32位系统）或者8字节（64位系统）。注意一般的函数是没有这个指针的，而且也不占类的内存。

6.继承 — 子类所占空间

#include<iostream>
class CBase // 基类
{
public:CBase(void); // 构造函数不占空间virtual ~CBase(void); // 虚析构函数占空间，所占空间根据系统位数而定private:int  a; // 普通变量占空间（4字节）char* p; // 指针类型变量占空间，根据系统位数而定
};class CChild : public CBase // 子类CChild继承Cbase
{
public:CChild(void); // 不占空间~CChild(void); // 不占空间virtual void test();// 父类子类共享一个虚函数指针private:int b;
};int main() {char* str;std::cout << sizeof(str) << std::endl;std::cout << sizeof(CBase) << std::endl;std::cout << sizeof(CChild) << std::endl;
}/*
32位系统下：
4 // 指针类型变量占4字节
12 // 虚析构函数指针占4字节+int a变量占4个字节+char* p占4个字节
16 // int类型变量b占4个字节+基类所占的12个字节// virtual void test();此时不占空间，原因是：父类子类共享一个虚函数指针
*//*
64位系统下：
8 // 指针类型变量占8字节
24 // 虚析构函数指针占8字节+(int a变量占4个字节+对齐另需4字节)+(char* p占4个字节+对齐另需4字节)
32 // (int类型变量b占4个字节+对齐另需4个字节)+基类所占的24个字节
*/

可见子类的大小是本身成员变量的大小加上父类的大小。其中有一部分是虚函数表的原因，父类子类共享一个虚函数指针。

7.空类与多重继承的空类占用内存空间

#include <iostream>using namespace std;class A {};class A2 {};class B : public A {};class C : public A, public A2 {};class D : public virtual B {}; // 虚继承int main()
{cout << sizeof(A) << endl;cout << sizeof(B) << endl;cout << sizeof(C) << endl;cout << sizeof(D) << endl;return 0;}// 32位系统输出：
/*
1
1
1
4
*/// 64位系统输出：
/*
1
1
1
8
*/

空类所占内存空间为1；单一继承或多重继承空类的空类所占空间还是1；但虚继承涉及虚指针，指针大小为4（32位系统），故虚继承后空类所占空间为4（32位系统）。

8.单一继承或多重继承时类占用内存空间

#include <iostream>using namespace std;class A {};class A1 {};class B : public A {int b;
};class C : public A, public A1 {int c;
};int main()
{cout << sizeof(A) << endl;cout << sizeof(B) << endl;cout << sizeof(C) << endl;return 0;}// 32位系统输出：
/*
1
4
8
*/// 64位系统输出：
/*
1
4
8
*/

9.共有继承

#include <iostream>class A {
};class A1 : public A {
};class B : public A{virtual void fun() = 0; // 定义虚函数
};// 共有继承，共用虚函数指针，没有虚基指针
class C : public B{
};class D : public A, public B{
};int main()
{std::cout << "sizeof(A):" << sizeof(A) << std::endl;std::cout << "sizeof(A1):" << sizeof(A1) << std::endl;std::cout << "sizeof(B):" << sizeof(B) << std::endl; std::cout << "sizeof(C):" << sizeof(C) << std::endl; std::cout << "sizeof(D):" << sizeof(D) << std::endl; return 0;
}/*
32位系统下输出：
sizeof(A):1 // 空类A(1)
sizeof(A1):1 // 空类A(0) + A1(1)
sizeof(B):4 // 空类A(0) + 虚函数指针(4)
sizeof(C):4 // 与B共用虚函数指针(4)
sizeof(D):8 // A(1+3<对齐>) + 与B共用虚函数指针(4)
*//*
64位系统下输出：
sizeof(A):1 // 空类A(1)
sizeof(A1):1 // 空类A(0) + A1(1)
sizeof(B):8 // 空类A(0) + 虚函数指针(8)
sizeof(C):8 // 与B共用虚函数指针(8)
sizeof(D):16 // A(1+7<对齐>) + 与B共用虚函数指针(8)
*/

共有继承，共用虚函数指针，没有虚基指针。

10.虚继承

#include<iostream>/*
虚继承与继承的区别：
1.多了一个虚基指针
2.虚基类位于派生类存储空间的最末尾
3.不会共用虚函数指针
*/class A
{char a[3];
public:virtual void fun1() {};
};// 测试一：单个虚继承，不带虚函数
class B : public virtual A
{char b[3];
};// 测试二：单个虚继承，带自己的虚函数
class C : public virtual A
{char c[3];
public:virtual void fun2() {};
};// 测试三：双重继承
class D : public virtual C
{char d[3];
public:virtual void fun3() {};
};int main()
{std::cout << sizeof(A) << std::endl; std::cout << sizeof(B) << std::endl; std::cout << sizeof(C) << std::endl; std::cout << sizeof(D) << std::endl; return 0;
}/*
32位系统输出：
8 // 8【虚函数指针占4个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个】
16 // 8(A) + 8(B)【8 == (3+1)+虚基指针】
20 // 8(A) + 12(C)【12 == (3+1)+自己的虚函数指针+虚基指针】
32 // (char d[3]占3个字节+对齐另需1个字节)+类D自己的虚函数指针(4个字节)+虚基指针(4个字节)+(char c[3]占3个字节+对齐另需1个字节)+类C自己的虚函数指针(4个字节)+虚基指针(4个字节)+(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加1个字节) + 类A自己的虚函数指针占4个字节*//*
64位系统输出：
16 // 【虚函数指针占8个字节；char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个】
32 // 16(A) + 16【16 == (char b[3]占3个字节+对齐另需5个字节)+虚基指针(8个字节)】
40 // 16(A) + 24【24 == <(char c[3]占3个字节+对齐另需5个字节)+自己的虚函数指针(8个字节)+虚基指针(8个字节)>】
64 // (char d[3]占3个字节+对齐另需5个字节)+类D自己的虚函数指针(8个字节)+虚基指针(8个字节)+(char c[3]占3个字节+对齐另需5个字节)+类C自己的虚函数指针(8个字节)+虚基指针(8个字节)+(char a[3]占3个字节，跟虚函数指针所占空间对齐需要另外加5个字节) + 类A自己的虚函数指针占8个字节
*/

注意，虚继承的时候 A B C D 四个类不仅不会共享虚基类指针，也不会共享虚函数指针，要和普通继承区分开来。

具体分析如下：

 class A size(8):+---0    | {vfptr}4    | a| <alignment member> (size=1)8    +---class B size(16):+---0    | {vfptr}4    | {vbptr}8    | b| <alignment member> (size=1)+---+--- (virtual base A)
12    | a| <alignment member> (size=1)
16    +---class C size(20):+---0    | {vfptr}4    | {vbptr}8    | b| <alignment member> (size=1)+---+--- (virtual base A)
12    | {vfptr}
16    | a| <alignment member> (size=1)
20    +---    class D size(32):+---0    | {vfptr}4    | {vbptr}8    | c| <alignment member> (size=1)+---+--- (virtual base A)
12    | {vfptr}
16    | a| <alignment member> (size=1)+---+--- (virtual base B)
20    | {vfptr}
24    | {vbptr}
28    | b| <alignment member> (size=1)
32    +---