sizeof运算符是如何在c ++中实现的？

有人能指出我在C++中实现sizeof运算符,还有一些关于它的实现的描述.

sizeof是无法重载的运算符之一.

那么这意味着我们无法改变其默认行为？

sizeof在C++中不是真正的运算符.它只是特殊的语法,它插入一个等于参数大小的常量.sizeof不需要或没有任何运行时支持.

编辑:您想知道如何确定查看其定义的类/结构的大小吗？对此的规则是ABI的一部分,编译器只是实现它们.基本上规则包括

原始类型的大小和对齐定义;

各种指针的结构,大小和对齐方式;

包装领域的规则;

有关虚拟表相关内容的规则(更深奥).

但是,ABI的是平台,往往供应商特定的,即在x86和(说)IA64的大小A下面会有所不同,因为IA64不允许未对齐的数据访问.

struct A
{
    char i ;
    int  j ;
} ;

assert (sizeof (A) == 5)  ; // x86, MSVC #pragma pack(1)
assert (sizeof (A) == 8)  ; // x86, MSVC default
assert (sizeof (A) == 16) ; // IA64

http://en.wikipedia.org/wiki/Sizeof

基本上,引用Bjarne Stroustrup的C++ FAQ:

Sizeof不能重载,因为内置操作(例如将指针递增到数组中)隐含地依赖于它.考虑:

X a[10];
X* p = &a[3];
X* q = &a[3];
p++;    // p points to a[4]
    // thus the integer value of p must be
    // sizeof(X) larger than the integer value of q

因此,在不违反基本语言规则的情况下,程序员不能给出sizeof(X)新的和不同的含义.

不,你不能改变它.您希望从实现它的过程中学到什么？

sizeof使用更基本的操作无法用C++编写什么.它不是函数,也不是库标题的一部分,例如printf或malloc.它在编译器中.

编辑:如果编译器本身是用C或C++编写的,那么你可以认为实现是这样的:

size_t calculate_sizeof(expression_or_type)
{
   if (is_type(expression_or_type))
   {
       if (is_array_type(expression_or_type))
       {
           return array_size(exprssoin_or_type) * 
             calculate_sizeof(underlying_type_of_array(expression_or_type));
       }
       else
       {
           switch (expression_or_type)
           {
                case int_type:
                case unsigned_int_type:
                     return 4; //for example
                case char_type:
                case unsigned_char_type:
                case signed_char_type:
                     return 1;
                case pointer_type:
                     return 4; //for example

                //etc., for all the built-in types
                case class_or_struct_type:
                {
                     int base_size = compiler_overhead(expression_or_type);
                     for (/*loop over each class member*/)
                     {
                          base_size += calculate_sizeof(class_member) +
                              padding(class_member);
                     }
                     return round_up_to_multiple(base_size,
                              alignment_of_type(expression_or_type));
                }
                case union_type:
                {
                     int max_size = 0;
                     for (/*loop over each class member*/)
                     {
                          max_size = max(max_size, 
                             calculate_sizeof(class_member));
                     }
                     return round_up_to_multiple(max_size,
                            alignment_of_type(expression_or_type));
                }
           }
       }
   }
   else
   {
       return calculate_sizeof(type_of(expression_or_type));
   }
}

注意,这是非常多的伪代码.我没有包括很多东西,但这是一般的想法.编译器可能实际上并不这样做.它可能会计算类型(包括类)的大小并存储它,而不是每次写入时重新计算sizeof(X).还允许例如具有不同大小的指针,这取决于它们指向的内容.

sizeof在编译时完成它的工作.运算符重载只是函数,并且在运行时执行它们的操作.因此,即使C++标准允许,也不可能使sizeof重载.