new 对象加括号和不加括号的区别

在new对象的时候有加上(),有不加(),不知道这个到底是什么区别?

比如:

  1. CBase *base = new CDerived();  
  2. CBase *base = new CDeviced;  
CBase *base = new CDerived();
CBase *base = new CDeviced;

很多人都说,加括号调用没有参数的构造函数,不加括号调用默认构造函数或唯一的构造函数。这是有问题的。

对于自定义类类型:

       如果该类没有定义构造函数(由编译器合成默认构造函数)也没有虚函数,那么class c = new class;将不调用合成的默认构造函数,而class c = new class();则会调用默认构造函数。

       如果该类没有定义构造函数(由编译器合成默认构造函数)但有虚函数,那么class c = new class;和class c = new class();一样,都会调用默认构造函数。

       如果该类定义了默认构造函数,那么class c = new class;和class c = new class();一样,都会调用默认构造函数。

 

对于内置类型:

       int *a = new int;不会将申请到的int空间初始化,而int *a = new int();则会将申请到的int空间初始化为0

 以下两个语句的区别是:第一个动态申请的空间里面的值是随机值,第二个进行了初始化,里面的值为0:

    1. int *p1 = new int[10];    
    2. int *p2 = new int[10]();    
    int *p1 = new int[10];  
    int *p2 = new int[10]();  

结论:别使用不带括号的new。

  1. class A{  
  2. public:  
  3. //A(){a=1;}   
  4. public:  
  5. int a;  
  6. };  
  7. A *a1=new A;  
  8. A *a2=new A();  
  9.   
  10. cout<<a1->a<<endl; //输出:-842150451   
  11. cout<<a2->a<<endl; //输出0   
  12. A a3;  
  13. cout<<a3.a<<endl; //运行异常,a没有初始化。  
class A{
public:
//A(){a=1;}
public:
int a;
};
A *a1=new A;
A *a2=new A();

cout<<a1->a<<endl; //输出:-842150451
cout<<a2->a<<endl; //输出0
A a3;
cout<<a3.a<<endl; //运行异常,a没有初始化。

如果加上一个virtual,如virtual ~A(){},

  1. cout<<a1->a<<endl; //输出:-842150451   
  2. cout<<a2->a<<endl; //输出 -842150451  
cout<<a1->a<<endl; //输出:-842150451
cout<<a2->a<<endl; //输出 -842150451

-------------下面是网上找的帖子,对理解上面的现象可能会有帮助-------------------

一个类满足下列其中任何一个条件:
1.包含了一个类的对象,这个对象有一个构造函数(包括编译器合成的默认构造函数)
2.如果继承自一些基类,其中某些基类有一个构造函数(包括编译器合成的默认构造函数)
3.有一个虚函数,或者继承到了虚函数
4.有虚基类

如果这个类没有默认的构造函数,编译器就会合成一个默认的构造函数,分别做以下事情
如果这个类有构造函数,编译器就会扩张所有构造函数,做以下事情
1.调用这个对象的构造函数
2.调用基类的构造函数
3.设置正确的虚函数表指针
4.设置指向虚基类对象的指针





 先把结论放上来:

  1.  加括号调用没有参数的构造函数,不加括号调用默认构造函数或唯一的构造函数,看需求
  2.  C++在new时的初始化的规律可能为:对于有构造函数的类,不论有没有括号,都用构造函数进行初始化;如果没有构造函数,则不加括号的new只分配内存空间,不进行内存的初始化,而加了括号的new会在分配内存的同时初始化为0。

 

以下代码:

#include <iostream>

using namespace std;

int main()
{
    int *a=new int[1000];
    for(int i=0;i<1000;i++){
        a[i]=i+1;
    }
    delete[] a;
    int *b=new int[1000];
    for(int i=0;i<100;i++){
        cout<<b[i]<<endl;
    }

    return 0;
}

没有初始化,输出的结果是:

9437380

9443448

3

4

5

6

。。。

可见,new操作符并没有对内存进行初始化。

而稍微改变一下代码(在new之后添加括号()):

#include <iostream>

using namespace std;

int main()
{
    int *a=new int[1000];
    for(int i=0;i<1000;i++){
        a[i]=i+1;
    }
    delete[] a;
    int *b=new int[1000]();
    for(int i=0;i<100;i++){
        cout<<b[i]<<endl;
    }

    return 0;
}

输出结果为:

0

0

0

0

。。

可见,已经进行了初始化。

 =============================================================================

进一步思考:

定义类A:

class A{
public:
    int a;
    A():a(10){};
};

main函数中使用语句:

    A *b=new A;
    cout<<b->a<<endl;

    A *b=new A();
    cout<<b->a<<endl;

输出结果都是10,可见都进行了初始化。

但是,如果吧A的构造函数删掉,则两个语句输出的结果分别是:随机数,0。

 

由此可见,C++在new时的初始化的规律可能为:对于有构造函数的类,不论有没有括号,都用构造函数进行初始化;如果没有构造函数,则不加括号的new只分配内存空间,不进行内存的初始化,而加了括号的new会在分配内存的同时初始化为0。



阅读更多
个人分类: c/c++编程
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭