第二章 类和对象基础

类成员的可访问范围

在类的定义中，用下列访问范围关键字来说明类成员可被访问的范围：

1
2
3
– private: 私有成员，只能在成员函数内访问
– public : 公有成员，可以在任何地方访问
– protected: 保护成员

以上三种关键字出现的次数和先后次序都没有限制。

定义一个类:

1
2
3
4
5
6
7
8
class className {
	private:
		私有属性和函数
	public:
		公有属性和函数
	protected:
		保护属性和函数
};

如过某个成员前面没有上述关键字，则缺省地被认为是私有成员。

注意：在类的成员函数以外的地方，只能够访问该类对象的公有成员。

“隐藏”的目的是强制对成员变量的访问一定要通过成员函数进行，那么以后成员变量的类型等属性修改后，只需要更改成员函数即可。否则，所有直接访问成员变量的语句都需要修改。

用struct定义类：

1
2
3
4
5
6
7
8
struct CEmployee { 
	char szName[30]; //缺省即公有
	public :
		int salary;
		void setName(char * name); 
		void getName(char * name);
		void averageSalary(CEmployee e1,CEmployee e2);
};

和用”class”的唯一区别，就是未说明是公有还是私有的成员，就是公有

成员函数的重载及参数缺省

1
2
3
4
5
6
7
8
class Location {
	private :
		int x, y;
	public:
		void init( int x=0 , int y = 0 );
		void valueX( int val ) { x = val ;}
		int valueX() { return x; }//重载
};

成员函数可以重载,可以带缺省参数。

1
2
3
4
void valueX( int val = 0) { x = val; }
int valueX() { return x; }
......
A.valueX();//存在二义性，编译器无法判断调用哪个valueX

构造函数 (constructor)

1
2
3
4
5
6
7
class Complex {
	private :
		double real, imag;
	public:
		void Set( double r, double i);
}; //编译器自动生成默认构造函数
Complex c1; //默认构造函数被调用

成员函数的一种，名字与类名相同，可以有参数，不能有返回值(void也不行)

作用是对对象进行初始化，如给成员变量赋初值

如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数，默认构造函数无参数，不做任何操作，如果定义了构造函数，则编译器不生成默认的无参数的构造函数

对象生成时构造函数自动被调用，对象一旦生成，就再也不能在其上执行构造函数

为什么需要：

不必专门再写初始化函数，也不用担心忘记调用初始化函数

自己定义：

1
2
3
4
5
6
7
8
9
10
11
12
13
class Complex {
	private :
		double real, imag;
	public:
		Complex( double r, double i = 0);
}; 
		Complex::Complex( double r, double i) 
{
		real = r; imag = i;
}

Complex c1(2,4), c2(3,5);
Complex * pc = new Complex(3,4);

一个类可以有多个构造函数，类似重载

构造函数在数组中的使用

1
2
CSample array2[2] = {4,5};
CSample array3[2] = {3};//注意这里只对array3[0]初始化成3，array3[1]默认初始化成0

还可以这样写：

1
2
3
4
5
6
7
8
class Test {
	public:
		Test( int n) { } 		//(1)
		Test( int n, int m) { } //(2) 
		Test() { } 				//(3)
};
Test array1[3] = { 1, Test(1,2) };
// 三个元素分别用(1),(2),(3)初始化

复制构造函数 (copyconstructor)

只有一个参数,即对同类对象的引用。

形如 X::X( X& )或X::X(const X &), 后者能以常量对象作为参数

如果没有定义复制构造函数，那么编译器生成默认复制构造函数。默认的复制构造函数完成复制功能。如果定义的自己的复制构造函数，则默认的复制构造函数不存在。

1
2
3
4
5
6
7
8
9
10
11
12
class Complex {
	public :
		double real,imag;
	Complex(){ }
	Complex( const Complex & c ) {
		real = c.real;
		imag = c.imag;
		cout << “Copy Constructor called”;
	}
}; 
Complex c1; //调用缺省无参构造函数
Complex c2(c1);//调用缺省的复制构造函数,将 c2 初始化成和c1一样

复制构造函数起作用的三种情况

1)当用一个对象去初始化同类的另一个对象时
1
2
Complex c2(c1);
Complex c2 = c1; //初始化语句，非赋值语句
2)如果某函数有一个参数是类 A 的对象， 那么该函数被调用时，类A的复制构造函数将被调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class A 
{
	public:
	A() { };
	A( A & a) { 
		cout << "Copy constructor called" <<endl;
	}
};
void Func(A a1){ }
int main(){
	A a2;
	Func(a2);
	return 0;
}
输出结果: 
Copy constructor called
3) 如果函数的返回值是类A的对象时，则函数返回时， A的复制构造函数被调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A 
{
	public:
	int v;
	A(int n) { v = n; };
	A( const A & a) { 
		v = a.v;
		cout << "Copy constructor called" <<endl;
	}
};
A Func() { 
	A b(4); 
	return b; 
}
int main() { 
	cout << Func().v << endl; 
	return 0; 
}
输出结果：
Copy constructor called
4

注意：对象间赋值并不导致复制构造函数被调用,还有就是引用前加上const可以防止实参被误改

类型转换构造函数

定义转换构造函数的目的是实现类型的自动转换。

只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数。

当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象(或临时变量)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Complex {
	public: 
		double real, imag;
		Complex( int i) {//类型转换构造函数
			cout << "IntConstructor called" << endl;
			real = i; imag = 0; 
		}
		Complex(double r,double i) {real = r; imag = i; }
};
int main ()
{
	Complex c1(7,8);
	Complex c2 = 12;
	c1 = 9; //9不是对象不能初始化，所以9被自动转换成一个临时Complex对象
	cout << c1.real << "," << c1.imag << endl;
	return 0;
}

析构函数 (destructors)

名字与类名相同，在前面加‘~’ ，没有参数和返回值，一个类最多只能有一个析构函数。

析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。

如果定义类时没写析构函数，则编译器生成缺省析构函数。 缺省析构函数什么也不做。

1
2
3
4
5
6
7
8
9
10
11
12
13
class String{
	private :
		char * p;
	public:
		String () {
		p = new char[10];
	}
	~ String () ;
};
String ::~ String()
{
	delete [] p;
}

对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。

delete对象导致析构函数调用

析构函数在对象作为函数返回值返回后被调用

1
2
3
4
5
6
7
8
9
10
11
12
13
class CMyclass {
	public:
		~CMyclass() { cout << "destructor" << endl; }
};
	CMyclass obj;
	CMyclass fun(CMyclass sobj ) { //参数对象消亡也会导致析
//构函数被调用
    return sobj; //函数调用返回时生成临时对象返回
}
int main(){
	obj = fun(obj); //函数调用的返回值（临时对象）被
	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
class Demo {
	int id;
public:
	Demo(int i) {
		id = i;
		cout << "id=" << id << " constructed" << endl;
}
	~Demo() {
		cout << "id=" << id << " destructed" << endl;
	}
};
Demo d1(1);
void Func() 
{
	static Demo d2(2);
	Demo d3(3);
	cout << "func" << endl;
}
int main () {
	Demo d4(4);
	d4 = 6;
	cout << "main" << endl;
{ 	
    Demo d5(5); 
}
	Func();
	cout << "main ends" << endl;
	return 0;
}

看一看输出是不是和你想的一样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
输出结果:
id=1 constructed
id=4 constructed
id=6 constructed
id=6 destructed
main
id=5 constructed
id=5 destructed
id=2 constructed
id=3 constructed
func
id=3 destructed
main ends
id=6 destructed
id=2 destructed
id=1 destructed