在不考虑用new动态创建对象的情况下，用最普通的

类名对象名(参数);

的方法创建对象

先贴上最正常最普通的代码

#include<iostream>
using namespace std;

class C{
public:
    C(){
        cout<<"Hello C++\n";
    };
    C(int m){
        cout<<"I love C++\n";
    };
private:
    int n;
};

int main(){
    C c;

    return 0;
}

OK，现在我们看看运行结果：

OK，预期地运行了第一个构造函数。但如果我们在创建对象时不用原来的句子：

C c；

而是在对象名后面加()：

C c();

那会成怎样呢？

修改后代码：

#include<iostream>
using namespace std;

class C{
public:
    C(){
        cout<<"Hello C++\n";
    };
    C(int m){
        cout<<"I love C++\n";
    };
private:
    int n;
};

int main(){
    C c();

    return 0;
}

没有运行构造函数！也就是说根本就没有在内存中创建对象，只是创建了一个“对象名”！

如果创建时给它赋一个参数：

#include<iostream>
using namespace std;

class C{
public:
    C(){
        cout<<"Hello C++\n";
    };
    C(int m){
        cout<<"I love C++\n";
    };
private:
    int n;
};

int main(){
    C c(1);

    return 0;
}

OK，一切正常。

所以，现在问题就很清楚了，当我们以以下形式创建类对象时：

i)类名对象名

默认调用“对象名()”这个构造函数，在栈内存中存在对象名，在堆内存中存在实际对象；

ii)类名对象名(一个或以上个参数)

默认调用相应的构造函数，在栈内存中存在对象名，在堆内存中也是存在实际对象的；

iii)类名对象名()

不调用任何构造函数创建对象，仅在栈内在中存在对象名，在堆内存中并不存在实际的对象；

C++中定义对象的语法，带括号与不带括号有什么区别？

 
    #include <iostream>  
class MyClass  
{  
public:  
    MyClass()   
    {   
        std::cout << "Hello MyClass!" << std::endl;   
    }  
public:  
    void MyMethod()   
    {   
        std::cout << "Hello MyMethod!" << std::endl;   
    }  
};  
 
   

如果这样定义对象：MyClass obj; 那么它的构造函数将会被执行，如果调用obj.MyMethod();也会执行正确。
可是如果带有括号：MyClass obj(); 那么它的构造函数不会被执行，调用obj.MyMethod();也会出现语法错误，请问这种语法是把obj定义成什么了？

MyClass obj()把obj定义成什么从语法上看是定义了一个名为obj，类型为MyClass类（也就是返回值为MyClass类型）的无参数函数。

另外如果进行动态的堆分配的话是要带括号的，比如 MyClass *obj = new MyClass() 不加会报错(但是，在vc6.0中不加（）并没有报错，而且结果是一样的，原因待解？但是有一条，如果类中定义了带参数的构造函数，定义类时不用括号肯定是错误的#add 为避免错误,统一加括号

c++创建对象的语法有—–
1 在栈上创建 MyClass a;
2 在堆上创建加括号 MyClass *a= new MyClass();
3 不加括号 MyClass *a = new MyClass;
4.—————MyClass a();声明了一个返回值为MyClass类型的无参函数。

#include <iostream>  
class MyClass  
{  
public:  
    MyClass()   
    {   
        std::cout << "Hello MyClass!" << std::endl;   
    }  
    MyClass(int i):num(i)  
    {  
        std::cout << "Hello MyClass!------int" << std::endl;   
    }  

    void MyMethod()   
    {   
        std::cout << "输出成员num: " <<num << std::endl;   
    }  

private:  
    int num;  
};  
int main()  
{  
    //---------------对于调用构造函数  
    MyClass c1;//表示使用不带参数的构造函数，或者有默认参数值的构造函数。  
    MyClass c2();//不会调用无参构造函数,各种情况下该处是声明一个返回值为MyClass类型的函数而已  
    MyClass c3(1);//调用参数为int的构造函数  
    /*---------------对于new关键字加括号和不加括号的区别--- 
    1.对于自定义类型来说没有区别，都是使用默认构造函数 
    2.对于内置类型来说加括号会初始化 
    */  
    std::cout<<std::endl;  
    MyClass *c4 = new MyClass();  
    c4->MyMethod();  
    MyClass *c5 = new MyClass(1);  
    c5->MyMethod();  
    MyClass *c6 = new MyClass;  
    c6->MyMethod();  

    //内置类型  
    std::cout<<std::endl;  
    int *pint1 = new int(1);  
    int *pint2 = new int();  
    int *pint3 = new int;  

    std::cout<<*pint1<<" "<<*pint2<<" "<<*pint3<<std::endl;  
    return 0;  
}

C++创建类对象时（无参）后不加括号与加括号的区别 C++中定义对象的语法，带括号与不带括号有什么区别？

C++中定义对象的语法，带括号与不带括号有什么区别？

猜你喜欢