C++ 中的 sizeof() 运算符

2025年6月29日 | 阅读 8 分钟

在 C++ 中，sizeof() 是一个运算符，用于计算数据类型、常量和变量的大小。它是一个编译时运算符，因为它在编译时返回任何变量或常量的占用空间。它在系统级编程、内存管理和可移植性检查方面非常有用。

大小是指计算机中占用的 RAM 量，由 sizeof() 运算符计算。

语法

它具有以下语法：

在上面的语法中，data_type 代表数据、变量、常量、联合体、结构体或任何其他用户定义数据类型的数据类型。

sizeof() 运算符在操作数中的用法

sizeof() 运算符可应用于以下操作数类型：

当操作数是数据类型时

如果 sizeof() 运算符的参数包含变量的数据类型，则 sizeof() 运算符将返回该数据类型的占用空间。让我们通过一个例子来理解这种情况。

示例

#include <iostream>  
using namespace std;   //using standard namespace
int main()   //main function
{  
  // Determining the space in bytes occupied by each data type.  
  cout << "Size of integer data type : " <<sizeof(int)<< endl;  
  cout << "Size of float data type : " <<sizeof(float)<< endl;  
  cout << "Size of double data type : " <<sizeof(double)<< endl;  
  cout << "Size of char data type : " <<sizeof(char)<< endl;  
  return 0;  
} 

编译并运行

输出

Size of integer data type : 4
Size of float data type : 4
Size of double data type : 8
Size of char data type : 1

说明

在此示例中，我们使用 sizeof() 运算符计算了内置数据类型的占用空间。我们知道，int 占用 4 字节，float 占用 4 字节，double 占用 8 字节，char 占用 1 字节，sizeof() 运算符显示了相同的结果。

当操作数是类类型时

在 C++ 中，如果 sizeof() 运算符的操作数是类类型，则该运算符返回该类对象的总占用空间（以字节为单位）。让我们通过一个例子来理解这种情况。

示例

#include <iostream>  
using namespace std;    //using standard namespace
class Base  
{  
int a;  
};  
int main()    //main function
{  
Base b;  
std::cout << "Size of class base is : "<<sizeof(b) << std::endl;  
return 0;  
} 

编译并运行

输出

Size of class base is : 4

说明

在此示例中，我们计算了一个仅包含一个整数变量的类的占用空间。之后，输出将是 4 字节，因为 int 变量占用 4 字节。

如果我们向类中添加一个 char 变量和多个整数值，代码将如下所示：

示例

#include <iostream>  
using n#include <iostream>  
using namespace std;    //using standard namespace
class Base  
{  
    int a;  
    int d;  
    char ch;  
};  
int main()    //main function
{  
  Base b;  
  cout << "Size of class base is : "<<sizeof(b) << endl;  
    return 0;  
}
amespace std;    //using standard namespace
class Base  
{  
int a;  
};  
int main()    //main function
{  
Base b;  
std::cout << "Size of class base is : "<<sizeof(b) << std::endl;  
return 0;  
} 

编译并运行

输出

Size of class base is : 12

说明

在此示例中，我们有一个类，其中包含两个整数变量和一个 char 变量。根据计算，类的大小应为 9 字节（int+int+char），但这由于结构体填充的概念是错误的。

当操作数是数组类型时

在 C++ 中，如果 sizeof 运算符的操作数是数组，则 sizeof 运算符返回整个数组占用的总字节数，而不仅仅是指向数组的指针。让我们通过一个例子来理解这种情况。

示例

#include <iostream>  
using namespace std;   //using standard namespace
 int main()   //main function
{  
  int arr[]={10,20,30,40,50};  
  cout << "Size of the array 'arr' is : "<<sizeof(arr) << endl;  
  return 0;  
}  

编译并运行

输出

Size of the array 'arr' is : 20

说明

在此示例中，我们声明了一个包含五个元素的整数类型数组。我们使用 sizeof() 运算符计算了数组的大小。根据计算，数组的大小应为 20 字节，因为 int 数据类型占用 4 字节，数组包含 5 个元素，因此该数组占用的总内存空间为 5*4 = 20 字节。

当操作数是指针类型时

在 C++ 中，如果 sizeof 运算符使用了指针类型的操作数，则该运算符返回指针本身的占用空间，而不是它指向的对象的占用空间。让我们通过一个例子来理解这种情况。

示例

#include <iostream>  
using namespace std;    //using standard namespace
int main()    //main function
{  
    int *ptr1=new int(10);  
    cout << "size of ptr1 : " <<sizeof(ptr1)<< endl;                                                                                                                                                                                                                                  
   cout << "size of *ptr1 : " <<sizeof(*ptr1)<< endl;  
   char *ptr2=new char('a');  
   cout <<"size of ptr2 : " <<sizeof(ptr2)<< endl;  
   cout <<"size of *ptr2 : "<<sizeof(*ptr2)<< endl;  
   double *ptr3=new double(12.78);  
    cout <<"size of ptr3 : " <<sizeof(ptr3)<< endl;  
   cout <<"size of *ptr3 : "<<sizeof(*ptr3)<< endl;  
    return 0;  
} 

编译并运行

输出

size of ptr1 : 8
size of *ptr1 : 4
size of ptr2 : 8
size of *ptr2 : 1
size of ptr3 : 8
size of *ptr3 : 8

说明

在此示例中，我们确定了指针的大小。对于所有数据类型，指针的大小都将保持不变。如果计算机是 32 位操作系统，指针的大小将是 4 字节。如果计算机是 64 位操作系统，指针的大小将是 8 字节。

当操作数是表达式时

在 C++ 中，如果 sizeof 运算符的操作数是表达式，则该表达式不会被计算。它仅用于确定表达式的类型，并且 sizeof() 运算符在编译时进行计算。让我们通过一个例子来理解这种情况。

示例

#include <iostream>  
using namespace std;     //using standard namespace
int main()    //main function
{  
   int num1;  
   double num2;  
   cout << sizeof(num1+num2);  
     return 0;  
} 

编译并运行

输出

说明

在此示例中，我们声明了两个变量，num1 和 num2，类型分别为 int 和 double。int 的大小是 4 字节，而 double 的大小是 8 字节。之后，结果将是一个变量，类型为 double，占用 8 字节。

联合体的大小

在 C++ 中，联合体是一种独特的数据类型，其中所有成员占用相同的内存位置。这意味着，一个联合体一次只能容纳一个成员。联合体的大小将等于其最大成员的大小，因为空间必须能容纳该最大成员。

这一特性使得联合体在内存受限的环境中（例如嵌入式应用程序或硬件编程）非常有用，因为在这些环境中，需要在单个内存位置中存储多种数据类型。

C++ 联合体大小示例

让我们举一个例子来说明 C++ 中联合体的大小。

示例

#include <iostream>
using namespace std;  //using standard namespace
union Data {
    int i;
    float f;
    double d;
    char c;
};
int main() {   //main function
    Data data;
    cout << "Size of union Data: " << sizeof(data) << " bytes" << endl;
    cout << "Size of int: " << sizeof(data.i) << " bytes" << endl;
    cout << "Size of float: " << sizeof(data.f) << " bytes" << endl;
    cout << "Size of double: " << sizeof(data.d) << " bytes" << endl;
    cout << "Size of char: " << sizeof(data.c) << " bytes" << endl;
    return 0;
}

编译并运行

输出

Size of union Data: 8 bytes
Size of int: 4 bytes
Size of float: 4 bytes
Size of double: 8 bytes
Size of char: 1 bytes

说明

在此示例中，我们使用了类型为 int、float、double 和 char 的联合体成员 data。在 main() 函数中，它使用 sizeof 来显示整个联合体的大小以及每个成员的大小。由于联合体占用共享内存，因此其大小与最大成员的大小相同，在本例中为 double。

常量的大小

在 C++ 中，常量是固定值，在程序执行期间不会改变其值。常量可以是不同的类型，例如 int、float、double、char 等。常量的占用空间基于其数据类型，与变量类似。sizeof 运算符可以直接应用于常量值以确定常量的大小。这在考虑内存使用或处理计算过程中的类型提升时非常有用。

C++ 常量大小示例

让我们举一个例子来说明 C++ 中常量的大小。

示例

#include <iostream>
using namespace std;   //using standard namespace
int main() {   //main function
    cout << "Size of integer constant 10: " << sizeof(25) << " bytes" << endl;
    cout << "Size of float constant 10.5f: " << sizeof(9.5f) << " bytes" << endl;
    cout << "Size of double constant 10.5: " << sizeof(10.5) << " bytes" << endl;
    cout << "Size of char constant 'T': " << sizeof('T') << " bytes" << endl;
    cout << "Size of string constant \"Hello\": " << sizeof("Hello") << " bytes" << endl;
    return 0;
}

编译并运行

输出

Size of integer constant 10: 4 bytes
Size of float constant 10.5f: 4 bytes
Size of double constant 10.5: 8 bytes
Size of char constant 'T': 1 bytes
Size of string constant "Hello": 6 bytes

说明

在此示例中，我们使用了 sizeof 运算符来显示各种常量的占用空间：整数（25）、浮点数（9.5f）、双精度浮点数（10.5）、字符（'T'）和字符串字面量（Hello）。

嵌套的 sizeof() 运算符

在 C++ 中，嵌套的 sizeof() 运算符指的是在另一个 sizeof 运算符内部使用 sizeof 运算符。由于 sizeof 本身返回 size_t 类型（无符号整数类型），因此嵌套的 sizeof() 帮助我们确定在系统中表示该大小值占用了多少内存。

C++ 嵌套的 sizeof() 运算符示例

让我们举一个例子来说明 C++ 中的嵌套的 sizeof() 运算符。

示例

#include <iostream>
using namespace std;   //using standard namespace
int main() {   //main function
    int a = 5;
    double b = 12.5;
    cout << "Size of sizeof(a + b): " << sizeof(sizeof(a + b)) << " bytes" << endl;
    cout << "Size of (sizeof(char) * 5): " << sizeof(sizeof(char) * 5) << " bytes" << endl;
    return 0;
}

编译并运行

输出

Size of sizeof(a + b): 8 bytes
Size of (sizeof(char) * 5): 8 bytes

说明

在此示例中，我们演示了嵌套的 sizeof 运算符的用法。在这里，第一行确定了 sizeof(a + b) 结果的大小；也就是说，a + b 是一个 double，而 sizeof(.) 是一个整数类型。之后，第二行计算了 sizeof(char) * 5 结果的大小，这是一个整数表达式。