为什么VC为单个delete也生成scalar deleting destructor?

cdsfiui

对于对象数组而言，C++编译器会生成隐藏的代理函数，来用一个for循环初始化new出来的数组，用for循环来析构delete[]的对象。
这个在C++对象模型相关的书籍和文章里面都已经讲得比较清楚了。

但是我有个问题，我发现VC的debug版本，为单个delete对象，也生成一个scalar deleting destructor代理函数。
这个让我觉得不明白，因为我觉得没有这样的必要，单个对象的析构没有for循环，也没有析构到一半处理异常的问题。
  
为什么VC会这样? 我贴了一下代码在这里，很简单的:

1. struct C{
   
2.      C(){
   
3.          cout << "ctor\n";
   
4.      }
   
5.      ~C(){
   
6.          cout << "dtor\n";
   
7.      }
   
8. };
   
9. int main(int argc, char *argv[])
   
10. {
    
11.      C obj;//栈对象的析构没有涉及到scalar deleting destructor
    
12.      C*p = new C();
    
13.      delete p;//这里是我的问题所在,单个对象为什么需要scalar deleting destructor?
    
14.      return 0;
    
15. }

复制代码

debug版下面生成的汇编代码如下，在main函数的尾部:

1.     delete p;
   
2. 00E55D3F  mov         eax,dword ptr [p]   
   
3. 00E55D42  mov         dword ptr [ebp-0F8h],eax   
   
4. 00E55D48  mov         ecx,dword ptr [ebp-0F8h]   
   
5. 00E55D4E  mov         dword ptr [ebp-104h],ecx   
   
6. 00E55D54  cmp         dword ptr [ebp-104h],0   
   
7. 00E55D5B  je          main+0D2h (0E55D72h)   
   
8. 00E55D5D  push        1   
   
9. 00E55D5F  mov         ecx,dword ptr [ebp-104h]   
   
10. 00E55D65  call        C::`scalar deleting destructor' (0E514E7h)   
    
11. 00E55D6A  mov         dword ptr [ebp-124h],eax   
    
12. 00E55D70  jmp         main+0DCh (0E55D7Ch)   
    
13. 00E55D72  mov         dword ptr [ebp-124h],0   
    
14.      return 0;
    
15. 00E55D7C  mov         dword ptr [ebp-0ECh],0   
    
16. 00E55D86  mov         dword ptr [ebp-4],0FFFFFFFFh   
    
17. 00E55D8D  lea         ecx,[obj]   
    
18. 00E55D90  call        C::~C (0E514DDh)   
    
19. 00E55D95  mov         eax,dword ptr [ebp-0ECh]   
    
20. }

复制代码

看到C obj的析构是在地址00E55D90 call        C::~C
而delete p的析构是在地址00E55D65 call        C::`scalar deleting destructor' (0E514E7h)   
我尝试编译这个程序的release版，未优化的版本，一样的结论。
  
问题
1. 为什么有这个区别? 如果堆上面的对象需要一个代理函数来调用析构+free，为什么构造的时候不需要一个代理函数来malloc+构造，而在析构的时候却需要。这个显得不对称。
2. 我用gcc也测试了一下这个程序，不加优化选项，也没有看到有个scalar deleting destructor之类的结构，加上调试信息，看反汇编也是直接callq xxxx <C::~C()>
  
还请板上朋友解释解释哈!

windoze

这是VC的特性，也叫bug。
VC是可以用delete p来析构new T[xx]创建出来的数组的，这么做其实不符合标准，但VC在标准明确这一点之前就这么做了，所以只好留到今天。

bruceteen

windoze 发表于 2016-09-28 11:28
这是VC的特性，也叫bug。
VC是可以用delete p来析构new T[xx]创建出来的数组的，这么做其实不符合标准，但 ...

VC不标准的地方真多，比如通过基类指针删除派生类数组

1. #include <iostream>
   
2. 
   
3. struct base
   
4. {
   
5.     virtual ~base() { std::clog<<"~base("<<base_value<<")\n"; }
   
6. 
   
7.     int base_value;
   
8. };
   
9. struct derived : base
   
10. {
    
11.     virtual  ~derived() { std::clog<<"~derived("<<derived_value<<")\n"; }
    
12. 
    
13.     int derived_value;
    
14. };
    
15. 
    
16. int main( void )
    
17. {
    
18.     derived* pd = new derived[3];
    
19.     pd[0].base_value=0, pd[0].derived_value=1;
    
20.     pd[1].base_value=2, pd[1].derived_value=3;
    
21.     pd[2].base_value=4, pd[2].derived_value=5;
    
22. 
    
23.     base* pb = pd;
    
24.     delete[] pb;
    
25. }

复制代码

输出竟然是正常的，不可思议

~derived(5)
~base(4)
~derived(3)
~base(2)
~derived(1)
~base(0)

MMMIX

回复 3# bruceteen

这个 GCC 也是允许的……

cdsfiui

bruceteen 发表于 2016-09-28 12:16
VC不标准的地方真多，比如通过基类指针删除派生类数组

析构函数不加virtual的话，就都挂了。

cokeboL

就在各位大神讨论标准的时候我已经用好几种非c/c++语言写了hello world

bruceteen

MMMIX 发表于 2016-09-28 13:01
回复 3# bruceteen

这个 GCC 也是允许的……

不可能吧，我用mingw和gcc都试过
我代码中删除的数组，假如A派生了B
B* pb = new B[100];
A* pa = pb;
中pb[1]和pa[1]的地址是不一样的，因为A和B的size不一样大。

MMMIX

回复 5# cdsfiui

析构函数不加virtual的话，就都挂了。

destructor 不加 virtual 的话就是 undefined behavior 了。

MMMIX

回复 7# bruceteen

源码 c04.cpp:

1. 
   
2. #include <iostream>
   
3. 
   
4. struct base
   
5. {
   
6.         virtual ~base() { std::clog<<"~base("<<base_value<<")\n"; }
   
7. 
   
8.         int base_value;
   
9. };
   
10. struct derived : base
    
11. {
    
12.         virtual  ~derived() { std::clog<<"~derived("<<derived_value<<")\n"; }
    
13. 
    
14.         int derived_value;
    
15. };
    
16. 
    
17. int main( void )
    
18. {
    
19.         derived* pd = new derived[3];
    
20.         pd[0].base_value=0, pd[0].derived_value=1;
    
21.         pd[1].base_value=2, pd[1].derived_value=3;
    
22.         pd[2].base_value=4, pd[2].derived_value=5;
    
23. 
    
24.         base* pb = pd;
    
25.         delete[] pb;
    
26. }
    
27. 
    

复制代码

$ g++ --version
g++ (GCC) 6.1.1 20160621 (Red Hat 6.1.1-3)


$ g++ -g -Wall -std=c++14    c04.cpp   -o c04

$ ./c04
~derived(5)
~base(4)
~derived(3)
~base(2)
~derived(1)
~base(0)

MMMIX

回复 7# bruceteen

倒是 clang++ 好像只调用了 base 的 destructor：
$ clang++ --version
clang version 3.8.0 (tags/RELEASE_380/final)
Target: x86_64-unknown-linux-gnu
Thread model: posix


$ clang++ -std=c++14 -Wall -g c04.cpp -o c04.clang

$ ./c04.clang
~base(4)
~base(2)
~base(0)