C++中类的普通对象,指针对象初始化详解,何时表示对象，何时表示函数。

建议直接将下方代码放到编译器里面运行， 能够更快理解。

#include 
using namespace std;

class test {
public:
	test(){}
	test(int a) {
		val = a;
	}
	int val;
};

int main() {
 test p0;			//对
 test p1 = test();  //对


 test p2(test());	// 不是对象			        被当作函数
 //p2特别注意， 跟p3做对比， p2 不 等价于test p2 = test();
 test p4(); //错		不是对象		 			被当作函数
 test* ppp();//错误								被当作函数

 

 test p5 = test(1);//对，									是对象
 test p3(test(1));  //对 等价于 test p3 = test(1);		    是对象
 test p6(1);	//对	等价于 test p6 = test(1);			是对象

 //可以看出对于隐式的构造加不加test都可以， 但对于指针类型， 因为有new关键字所以一定得加test


 //test p = test;//错误写法		test* p = new test; //正确写法，是一个指针对象
 
 
 test* p7 = new test(); //等价于 test* p7 = new test; 前提是要有默认构造函数,   注意如果是普通对象只可以 test p = test()对， 但test p = test是错误的
 test* p8(new test());  //等价于 test* p8(new test);	等价于 test* p8 = new test; 等价于 test* p8 = new test();


//举例 unique_ptr(new string("xixi")); //unique_ptr只能隐式，因为他的拷贝构造和拷贝赋值被删除了，但还有特殊情况(用函数返回对象)
 return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

总结(建议好好看，将无参和有参的每一个点对比)：

无参情况（普通对象）：

1.test aa;//正确, 是普通对象
2.test aa(); //错误， 是函数

3.test aa = test; //错误 ， 写法就是错误的， 不是对象也不是函数。
4.test aa = test();//正确， 是普通对象

无参情况（指针对象）：

1.test* aa;正确， 是指针对象
2.test* aa();错误， 是指针函数

3.test* aa = new test ; //正确， 是指针对象
4.test* aa = test();//正确， 是指针对象

注意（普通对象）：
5.test aa(test()) ; //不是对象， 而是函数, 并不等价于 test aa = test();
建议理解方式，生成一个对象时一般都是 new + 类型名， 如下边的new test(), 这里可以把test()理解为一个类型名
注意（指针对象）：
5.test* aa(new test()); //是对象， 等价于 test* aa = new test; 等价于test* aa = new test();

有参情况（普通对象）

当然都需要加上括号， 首先排除test aa() ; 这是函数对象。
1.test aa(1); //正确， 是普通对象
2.test aa = test(1); //正确， 是普通对象
3.test aa(test(1)); //正确， 是普通对象，等价于test aa = test(1); 对比上边普通对象第5小点

有参情况（指针对象）

当然都需要加上括号， 首先排除test aa() ; 这是函数对象。
1.对应普通对象的情况没有。
2.test* aa =new test(1); //正确， 是指针对象
3.test* aa(new test(1)); //正确， 是普通对象，等价于test* aa =new test(1); 对比上边第5小点

括号问题（普通对象）

普通对象中只有test aa; 这种情况不加括号()，其他情况都需要加上括号(排除test aa())，当然对于有参情况必须加上括号。

括号问题（指针对象）

指针对象中加不加括号都可以(排除test* aa())， 当然对于有参情况必须加上括号。

二、拓展：

拷贝构造函数调用的三个时机
1.传参， 2.函数返回临时对象时， 3.将一个对象作为参数构造时， 如 test a(100); test b(a); 这个a调用默认构造函数，这个b的初始化就会调用拷贝构造函数；

一些对象的使用细节： 注意观察vector对象和string对象的初始化
使用vector时：实现一个n*n的矩阵
如果初始化一个二维数组(int类型)
vector> arr(n, vector(n, 0)）;
而如果是需要模拟一个n * n地图，，矩阵内全是’.’
vector< string> arr2(n, string(n, ‘.’));
注意二者的使用 ，都达到了二维地图的需求。