初始化列表（const和引用成员）、拷贝构造函数

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

#include<iostream>
usingnamespacestd;

classObject
{
public:
Object(intnum):num_(num)
{
cout<<"Object"<<num_<<"..."<<endl;
}
~Object()
{
cout<<"~Object"<<num_<<"..."<<endl;
}
private:
intnum_;
};

classContainer
{
public:
Container(intobj1=0,intobj2=0):obj2_(obj2),obj1_(obj1)
{
cout<<"Container..."<<endl;
}
~Container()
{
cout<<"~Container..."<<endl;
}

private:
Objectobj1_;
Objectobj2_;
};

intmain(void)
{
Containerc(10,20);
return0;
}

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
42
43
44
45
46
47
48
49

#include<iostream>
usingnamespacestd;

//const成员的初始化只能在构造函数初始化列表中进行
//引用成员的初始化也只能在构造函数初始化列表中进行
//对象成员（对象成员所对应的类没有默认构造函数）的初始化，也只能在构造函数初始化列表中进行
classObject
{
public:
enumE_TYPE
{
TYPE_A=100,
TYPE_B=200
};
public:
Object(intnum=0):num_(num),kNum_(num),refNum_(num_)
{
//kNum_=100;
//refNum_=num_;
cout<<"Object"<<num_<<"..."<<endl;
}
~Object()
{
cout<<"~Object"<<num_<<"..."<<endl;
}

voidDisplayKNum()
{
cout<<"kNum="<<kNum_<<endl;
}
private:
intnum_;
constintkNum_;
int&refNum_;
};

intmain(void)
{
Objectobj1(10);
Objectobj2(20);
obj1.DisplayKNum();
obj2.DisplayKNum();

cout<<obj1.TYPE_A<<endl;
cout<<obj2.TYPE_A<<endl;
cout<<Object::TYPE_A<<endl;

return0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

#ifndef_TEST_H_
#define_TEST_H_

classTest
{
public:
//如果类不提供任何一个构造函数，系统将为我们提供一个不带参数的
//默认的构造函数
Test();
explicitTest(intnum);
Test(constTest&other);
voidDisplay();

Test&operator=(constTest&other);

~Test();
private:
intnum_;
};
#endif//_TEST_H_

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
42

#include"Test.h"
#include<iostream>
usingnamespacestd;

//不带参数的构造函数称为默认构造函数
Test::Test():num_(0)
{
//num_=0;
cout<<"InitializingDefault"<<endl;
}

Test::Test(intnum):num_(num)
{
//num_=num;
cout<<"Initializing"<<num_<<endl;
}

Test::Test(constTest&other):num_(other.num_)
{
//num_=other.num_;
cout<<"Initializingwithother"<<num_<<endl;
}

Test::~Test()
{
cout<<"Destroy"<<num_<<endl;
}

voidTest::Display()
{
cout<<"num="<<num_<<endl;
}

Test&Test::operator=(constTest&other)
{
cout<<"Test::operator="<<endl;
if(this==&other)
return*this;

num_=other.num_;
return*this;
}

1
2
3
4
5
6
7
8
9
10

#include"Test.h"

intmain(void)
{
Testt(10);
//Testt2(t);//调用拷贝构造函数
Testt2=t;//等价于Testt2(t);

return0;
}

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

#include"Test.h"
#include<iostream>
usingnamespacestd;

voidTestFun(constTestt1)
{

}

voidTestFun2(constTest&t1)
{

}

TestTestFun3(constTest&t1)
{
returnt1;
}

constTest&TestFun4(constTest&t1)
{
//returnconst_cast<Test&>(t1);
returnt1;
}

intmain(void)
{
Testt(10);
TestFun(t);

cout<<"........"<<endl;

return0;
}