logo头像

不忘初心,奋力前行

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

本文于617天之前发表,文中内容可能已经过时,如有问题,请联系我。

第一节 类和对象的基本概念(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 4 复制构造函数的参数是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(因为复制构造函数所计算值是2c.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() { } }; 下面段程序不会引发类型转换构造函数被调用?

  1. A) A a1(4);
  2. B) A a2 = 4;
  3. C) A a3; a3 = 9;
  4. 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 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 10 destructor called 说明dev出于优化目的并未生成返回值临时对象。

支付宝打赏 微信打赏 QQ钱包打赏

感觉不错?欢迎给我 打个赏~我将不胜感激!