2018-09-03 765 views 评论

C++面向对象程序设计课程笔记（第二周）

标签：C++ C++慕课学习笔记

第一节类和对象的基本概念（2）

1.类的成员函数和类的定义分开写

例如我们在类里面定义了一个类别还有函数，那么类的定义可以写在类的外面，以例子给出格式（仍以上一节CRectangle类为例）：

int CRectangle::Area(){

return w*h;

}

void CRectangle::Init(int w_, int h_)

{

w = w_;

h = h_;

}

一定要通过对象或对象的指针或对象的引用才能引用。

2.类成员的可访问范围

（1）private：私有成员，只能在成员函数内访问；

（2）public：公有成员，可以在任何地方访问；

（3）protected：保护成员。

具体用法如下：

class className{

private:

私有属性和函数

public:

公有属性和函数

protected:

保护属性和函数

}

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

例如：

class Man{

int nAge;//私有成员

int szName[20];//私有成员

public:

void SetName(char * szName){

strcpy(Man::szName,szName);

}

};

3.类成员的可访问范围

在类的成员函数内部，能够访问：

（1）当前对象的全部属性、函数；

（2）同类其它对象的全部属性、函数。

在类的成员函数以外的地方，只能访问该类的公有成员。

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

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

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

第二节构造函数

1.基本概念

构造函数是成员函数的一种它的名字与类名相同，可以有参数，但不能有返回值（void也不行）。作用是对对象进行初始化，如给成员变量赋初值。如果定义类时没有写构造函数，则编译器生成一个默认的无参数的构造函数，默认的构造函数不做任何操作。如果我们定义了构造函数，那么系统就不生成构造函数。

对象生成时构造函数自动被调用，对象一旦生成，就再也不能在其上执行构造函数。一个类可以有多个构造函数。

打个比方，我们新建成员变量是建房子，那么构造函数只能做装修房子，不能做建房子的操作。

为什么需要构造函数呢？

（1）构造函数执行必要的初始化工作，有了构造函数，就不必专门再写初始化函数，也不用担心忘记调用初始化函数。

（2）有时对象没被初始化就使用，会导致程序出错。

例如：

class Complex{

private:

double real,imag;

public:

void Set(double r, double i);

};//编译器自动生成默认构造函数

Complex c1;//默认构造函数被调用

Complex *pc = new Complex;//默认构造函数被调用，生成一个可变的

自己写出构造函数，例如：

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;//错误，缺少构造函数的参数

Complex *pc = new Complex;//错误，缺少构造函数的参数

Complex c1(2);//Ok，第二个参数使用缺省参数i=0

Complex c1(2,4),c2(3,5);//OK

Complex *pc = new Complex(3,4);//OK

多个构造函数举例：

class Complex{

private:

double real,imag;

public:

void Set(double r, double i);

Complex(double r, double i);

Complex(double r);

Complex(Complex c1, Complex c2);

};

Complex::Complex(double r, double i){

real = r;

imag = i;

}

Complex::Complex(double r){

real = r;

imag = 0;

}

Complex::Complex(Complex c1, Complex c2){

real = c1.real + c2.real;

imag = c1.imag + c2.imag;

}

Complex d1(3),d2(1,0),d3(d1,d2);

//d1 = {3,0}, d2 = {1,0}, d3 = {4,0}

注意：构造函数最好是public的，private构造函数不能直接用来初始化对象。

2.构造函数在数组中的使用

以例子来讲解。例1如下：

class CSample {

int x;

public:

CSample() {

cout << "Constructor 1 Called" << endl;

}

CSample(int n) {

x = n;

cout << "Constructor 2 Called" << endl;

}

};

int main(){

CSample array1[2];//由于数组为空，当作一个无参来初始化。

//然后数组里面是两个空的元素，实际上相当于初始化然后数组里面是两个空的元素，

//实际上相当于初始化了两边。输出结果是两遍Constructor 1 Called

cout <<"step1"<<endl;//输出step1

CSample array2[2] = {4,5};//此时是有参构造，相当于创建两个对象，一个对象里面x为4，一个为5

//所以输出是两遍Constructor 2 Called

cout <<"step2"<<endl; //输出step2

CSample array3[2] = {3};//此时是有参构造和无参构造结合，相当于创建另两个对象，一个里面x=3

//另一个无参数，输出一遍Constructor 2 Called，Constructor 1 Called

cout <<"step3"<<endl;//step3

CSample *array4 = new CSample[2];//与array1[2]同理

delete []array4;//回收

return 0;

例2：

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)初始化

Test array2[3] = { Test(2,3), Test(1,2) , 1};

// 三个元素分别用(2),(2),(1)初始化

Test * pArray[3] = { new Test(4), new Test(1,2) };

//两个元素分别用(1),(2) 初始化

注意，指针不会被初始化。例如：假设 A 是一个类的名字，下面的语句生成了几个类A的对象？

A * arr[4] = { new A(), NULL,new A() };

答案是2个。因为new A()会生成对象，NULL为空，所以它还是一个指针，没有指向一个对象的地址，故无法生成对象，第四个元素同理。因为只有两个new A()，故有2个对象。

第三节复制构造函数

1.基本概念

只有一个参数，即对同类对象的引用。形如 X::X(X&)或X::X(const X &)，二者选一，参数地方必须为引用！。后者能以常量对象作为参数。

如果没有定义复制构造参数，那么编译器生成默认复制构造函数。默认的复制构造函数完成对象间的复制功能。例如：

class Complex{

private:

double real,imag;

};

Complex c1;//调用缺省无参构造参数

Complex c2(c1);//调用缺省的复制构造函数，将c2初始化成和c1一样

如果自己写，例如：

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一样

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

1)当用一个对象去初始化同类的另一个对象时。例如：

Complex c2(c1);

Complex c2 = c1; //初始化语句，非赋值语句

2)如果某函数有一个参数是类 A 的对象， 那么该函数被调用时，类A的复制构造函数将被调用。

class A

{

public:

A(){ };

A( A & a)

{

cout << "Copy constructor called" <<endl;

}

};

void Func(A a1){}

int main(){

A a2;

Func(a2);//参数为类A的对象

return 0;

}

输出：Copy constructor called

3) 如果函数的返回值是类A的对象时，则函数返回时， A的复制构造函数被调用:

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

复制构造函数的参数是b。Func().v是b.v的一个复制品。

注意：对象间赋值并不导致复制构造函数被调用。

例如：

class CMyclass {

public:

int n;

CMyclass() {};

CMyclass( CMyclass & c) { n = 2 * c.n ; }

};

int main() {

CMyclass c1,c2;

c1.n = 5; c2 = c1; CMyclass c3(c1);

cout <<"c2.n=" << c2.n << ",";

cout <<"c3.n=" << c3.n << endl;

return 0;

}

在这里c2=c1不是一个初始化语句，而是一个赋值语句，所以并不导致复制构造函数被调用。因此输出的结果c2.n = 5，c3.n = 10（因为复制构造函数所计算值是2*c.n）。

3.常量引用参数的使用

void fun(CMyclass obj_)

{

cout << "fun" << endl;

}

这样的函数，调用时生成形参会引发复制构造函数调用，开销比较大。所以可以考虑使用 CMyclass & 引用类型作为参数，实际上形参成为了实参的应用，成为了一回事（原来的时候在调用函数时，形参实际上是复制了一份实参，这个太浪费时间）。如果希望确保实参的值在函数中不应被改变，那么可以加上const 关键字：

void fun(const CMyclass & obj) {

//函数中任何试图改变 obj值的语句都将是变成非法

}

第四节类型转换构造函数和析构函数

1.什么是类型转换构造函数

它定义转换构造函数的目的是实现类型的自动转换。如果只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数。当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象(或临时变量)。

实例如下：

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; //它调用Complex( int i)

c1 = 9; // 9被自动转换成一个临时Complex对象

cout << c1.real << "," << c1.imag << endl;

return 0;

}

解析：c1=9这里经历的这样一个过程：首先新建一个临时的Complex对象，我假定为m，那么这个m进行初始化（即相当于执行Complex a(9)，或者Complex a=9），然后调用Complex(int i)这个类型转换构造函数，构造一个m里面的real=9，imag=0，然后把m复制给c1。

习题：类A定义如下：

class A

{

int v;

public:

A(int i) { v = i; }

A() { }

};

下面段程序不会引发类型转换构造函数被调用？

A) A a1(4);
B) A a2 = 4;
C) A a3; a3 = 9;
D) A a1,a2; a1 = a2;

答案：D。解析如下：A、B、C都显然调用了A(int i)，而D里面a1=a2是赋值语句。

2.析构函数

名字与类名相同，在前面加‘~’， 没有参数和返回值，一个类最多只能有一个析构函数。析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。

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

析构函数实例：

class String{

private:

char * p;

public:

String () {

p = new char[10];

}

~ String ();

};

String ::~ String()

{

delete [] p;

}

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

class Ctest {

public:

~Ctest() { cout<< "destructor called" << endl; }

};

int main () {

Ctest array[2];

cout << "End Main" << endl;

return 0;

}

输出结果：

End Min

destructor called

数组的两个元素都用完了，所以构造了析构函数两遍。

3.析构函数和运算符delete

（1）delete运算导致析构函数调用。

Ctest * pTest;

pTest = new Ctest; //构造函数调用

delete pTest; //析构函数调用

---------------------------------------------------------

pTest = new Ctest[3]; //构造函数调用3次

delete [] pTest; //析构函数调用3次

前面说过：若new一个对象数组，那么用delete释放时应该写 []。否则只delete一个对象(调用一次析构函数)。

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

例如：

class CMyclass {

public:

~CMyclass() { cout << "destructor" << endl; }

};

CMyclass obj;

CMyclass fun(CMyclass sobj ) {//次数对象作为了形参，调用复制构造函数

//参数对象消亡也会导致析构函数被调用

return sobj; //函数调用返回时生成临时对象返回

}

int main()

{

obj = fun(obj); //函数调用的返回值（临时对象）被

return 0; //用过后，该临时对象析构函数被调用

}

第五节构造函数析构函数调用时机

构造函数和析构函数什么时候被调用呢？见课本P190的这个例子：

class Demo {

int id;

public:

Demo(int i) {//这个也可以看做是类型转换构造函数

id = i;

cout << "id=" << id << " constructed" << endl;

}

~Demo() { cout << "id=" << id << " destructed" << endl; }

};

Demo d1(1);//全局对象，在main运行前先运行构造函数，因此输出id=1 constructed

void Func() {

static Demo d2(2);//静态局部变量

Demo d3(3);

cout << "func" << endl;

}

int main () {

Demo d4(4);//先运行构造函数，输出id=4 constructed

d4 = 6;//运行类型转换构造函数，输出id=6 constructed

//临时对象调用完之后，就会消亡。输出id=6 destructed。但是消亡的是临时对象

cout << "main" << endl;

{ Demo d5(5);

}//局部对象。输出id=5 constructed。因为是局部对象，花括号结束后就消亡。

//因此输出id=5 destructed

Func();//调用Func函数，输出id=2 constructed和id=3 constructed，然后输出func

//局部静态变量在函数结束的时候仍然存在，仅此只有d3(3)消亡，输出

id=3 destructed

cout << "main ends" << endl;

return 0;//整个程序结束后，局部变量消亡，输出id=6 destructed。main的变量d4和全局变量d1消亡，输出id=2 destructed和id=1 destructed

}

输出结果为：

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

形象举例，析构函数在拆房子过程中不是负责拆房子，而是在拆房子之前在房子里面做一些善后工作，比如说把东西都搬走。

习题：假设A是一个类的名字，下面的程序片段会类A的调用析构函数几次？

int main()

{

A * p = new A[2];

A * p2 = new A;

A a;

delete [] p;

}

答案：3次。第一句话new出来2个，第二句话new出来1个。new出来的东西，如果你不delete它，主程序结束它也不会消亡。所以调用西沟函数是A a在最后调用1次，delete调用2次，一共3次。

复制构造函数在不同编译器中的表现不一定相同！

例如下：

class A {

public:

int x;

A(int x_):x(x_)

{ cout << x << " constructor called" << endl; }

A(const A & a ) { //本例中dev需要此const其他编译器不要

x = 2 + a.x;

cout << "copy called" << endl;

}

~A() { cout << x << " destructor called" << endl; }

};

A f( ){ A b(10); return b; }

int main( ){

A a(1);

a = f();

return 0;

}

正常情况下执行过程如下，以下为在Visula Studio中输出情况：

首先执行main函数里面的第一句话，输出1 constructor called。然后执行第二句话，调用函数f()，生成b，调用构造函数使m=10，因此输出10 constructor called，b返回后，任务结束，调用析构函数，输出10 destructor called。接着f的返回值是一个临时对象，需要进行初始化，所以调用A(const A & a )，首先执行加法操作，临时对象的值变为12，然后输出copy called。将临时对象赋值给a后，临时对象消亡，调用析构函数，输出12 destructor called，然后主程序执行完毕，a也消亡，调用析构函数，输出12 destructor called。

而在dev C++则输出：

1 constructor called

10 constructor called

10 destructor called

说明dev出于优化目的并未生成返回值临时对象。