我通过编辑以下程序测试c++创建对象加不加括号的区别，编译器为：g++-4.8.1：

#include<iostream>
#include<string.h>
using namespace std;
class cat{
 
    private:
        char name[10];
        int age;
    public:
        cat(){
            cout<<"created no argument"<<endl;
        }
        cat(const char name[],int age){
            memset(this->name,0,sizeof(this->name));
            strcpy(this->name,name);
            this->age=age;
            cout<<"created with arguments"<<endl;
        }
        
        void get_info(){
            cout<<"name:"<<name<<",age:"<<age<<endl;
        }
};
class dog{
 
    private:
        char name[10];
        int age;
    public:
        void get_info(){
            cout<<"name:"<<name<<",age:"<<age<<endl;
        }
};
int main(){
    cout<<"creating cats"<<endl;
    cat c1;
    cat c2();
    cat c3("z",3);
    cat *pc1=new cat;
    cat *pc2=new cat();
    cat *pc3=new cat("a",4);
 
    cout<<"creating dogs"<<endl;
    dog d1;
    dog d2();
    dog *pd1=new dog;
    dog *pd2=new dog();
 
    int *p1=new int;
    int *p2=new int();
    int *p3=new int(5);
 
    cout<<"cats info"<<endl;
    c1.get_info();
    c3.get_info();
    pc1->get_info();
    pc2->get_info();
    pc3->get_info();
 
    cout<<"dogs info"<<endl;
    d1.get_info();
    pd1->get_info();
    pd2->get_info();
 
    cout<<"int"<<endl;
    cout<<*p1<<' '<<*p2<<' '<<*p3<<endl;
    
    return 0;
}

运行结果：

creating cats
created no argument
created with arguments
created no argument
created no argument
created with arguments
creating dogs
cats info
name:￰R@,age:43
name:z,age:3
name:?=,age:1359435378
name:?=,age:954365541
name:a,age:4
dogs info
name:?b柯= M+@,age:446520252
name:？=,age:95723850
name:,age:0
int
4007824 0 5

通过运行结果可以看到：

有构造函数的猫

c1的name和age成员变量是随机数据，没有得到初始化，

c2没有实际对象的创建，

c3通过定义的构造函数对成员变量进行了初始化，

pc1，pc2同样没有对成员变量进行初始化，

pc3使用定义的构造函数对成员变量进行了初始化。

对于有定义构造函数的类，对象的创建会调用相应的构造函数，类成员变量是否被初始化取决于自己编写的构造函数是否对成员变量进行初始化。

pc1调用cat()函数，函数未进行成员变量的初始化，因此pc1的成员变量的值是不确定的，而pc3调用cat(const char name[],int age)，该构造函数对成员变量进行了初始化，因此pc3的成员变量值是确定的。

没有构造函数的狗

d1的成员变量没有进行初始化，为随机值，

d2没有被创建，

pd1的成员变量没有进行初始化，为随机值，

pd2的成员变量被初始化为0

对于没有定义构造函数的类，对象的创建会调用默认构造函数。使用类名+对象名创建对象时，不带括号时不会对成员变量初始化，带括号则只是被编译器当成了函数声明。

而使用new+类名的方式创建，不加括号时不会对成员变量初始化，而加括号会初始化为0。

结论：

有构造函数的类：

cat c1;//在栈中创建对象，调用cat()构造函数

cat c2();//被编译器认为是返回值为cat对象的c2()函数声明，因此没有实际对象的创建

cat c3(”z",3);//在栈中创建对象，调用cat(const char name[],int age)构造函数

cat *pc1=new cat;//在堆中创建实例，调用cat()构造函数

cat *pc2=new cat();//在堆中创建实例，调用cat()构造函数

cat *pc3=new cat("a",4);//在堆中创建实例，调用cat(const char name[],int age)构造函数

对于没有构造函数的类：

dog d1;//在栈中创建对象，不进行成员初始化

dog d2();//被编译器认为是返回值为dog 对象的d2()函数声明，没有实际对象的创建

dog *pd1=new dog;//在堆中创建实例，不进行成员初始化

dog *pd2=new dog();//在堆中创建实例，成员初始化为0

额外测试了对于内置类型的情况：

int *p=new int;//不进行初始化。

int *p=new int();//初始化为0

int *p=new int(4);//初始化为4