新标准C++程序设计读书笔记_类和对象

面向对象的程序设计方法

抽象：将某类客观事物共同特点（属性）归纳出来，形成一个数据结构（可以用多个变量描述事物的属性）；将这类事物所能进行的行为也归纳出来，形成一个个函数，这些函数可以用来操作数据结构。

封装：通过某种语法形式，将数据结构和操作该数据结构的函数“捆绑”在一起，形成一个“ 类”，从而使得数据结构和操作该数据结构的算法呈现出显而易见的紧密关系。

从客观事物抽象出类

写一个程序，输入矩形的长和宽，输出面积和周长。

比如对于“矩形”这种东西，要用一个类来表示，该如何做“抽象”呢？
矩形的属性就是长和宽。因此需要两个变量，分别代表长和宽。

一个矩形，可以有哪些行为呢（或可以对矩形进行哪些操作）？
矩形可以有设置长和宽，算面积，和算周长这三种行为（当然也可以有其他行为）。这三种行为，可以各用一个函数来实现，他们都需要用到长和宽这两个变量。

将长、宽变量和设置长，宽，求面积，以及求周长的三个函数“封装”在一起，就能形成一个“矩形类”。
长、宽变量成为该“矩形类”的“成员变量” ，三个函数成为该类的“成员函数” 。 成员变量和成员函数统称为类的成员。

下面就是一个最简单的类

 class CRectangle
 {
 public:
     int w, h;

     int Area()
     {
         return w * h;
     }

     int Perimeter()
     {
         return  * ( w + h);
     }

     void Init( int w_,int h_ )
     {
         w = w_; h = h_;
     }
 }; 

类成员的可访问范围

在类的成员函数内部，能够访问：
（1）当前对象的全部属性、 函数；
（2）同类其它对象的全部属性、 函数。

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

 class CEmployee
 {
 private:
     char szName[]; //名字
 public :
     int salary; //工资
     void setName(char * name);
     void getName(char * name);
     void averageSalary(CEmployee e1,CEmployee e2);
 };

 void CEmployee::setName( char * name)
 {
     strcpy( szName, name); //ok
 }

 void CEmployee::getName( char * name)
 {
     strcpy( name,szName); //ok
 }

 void CEmployee::averageSalary(CEmployee e1, CEmployee e2)
 {
     cout << e1.szName; //ok，访问同类其他对象私有成员
     salary = (e1.salary + e2.salary ) / ;
 }

 int main()
 {
     CEmployee e;

     strcpy(e.szName,"Tom1234567889"); //编译错，不能访问私有成员
     e.setName( "Tom"); // ok
     e.salary = ; //ok

     return ;
 }

构造函数

成员函数的一种，名字与类名相同，可以有参数，不能有返回值(void也不行)，作用是对对象进行初始化，如给成员变量赋初值。

（1）如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数，默认构造函数无参数，不做任何操作
（2）如果定义了构造函数，则编译器不生成默认的无参数的构造函数
（3）对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数
（4）一个类可以有多个构造函数
（5）构造函数最好是public的， private构造函数不能直接用来初始化对象

下面看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 = );
 };

 Complex::Complex( double r, double i)
 {
     real = r; imag = i;
 }

 Complex c1; // error, 缺少构造函数的参数
 Complex * pc = new Complex; // error, 没有参数
 Complex c1(); // OK
 Complex c1(,), c2(,);
 Complex * pc = new Complex(,);

 构造函数在数组中的使用

 class Test
 {
 public:
     Test( int n) { } //(1)
     Test( int n, int m) { } //(2)
     Test() { } //(3)
 };

 // 三个元素分别用(1),(2),(3)初始化
 Test array1[] = { , Test(,) };
 // 三个元素分别用(2),(2),(1)初始化
 Test array2[] = { Test(,), Test(,) , };
 //两个元素分别用(1),(2) 初始化
 Test * pArray[] = { new Test(), new Test(,) };

复制构造函数

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

（1）如果没有定义复制构造函数，那么编译器生成默认复制构造函数。默认的复制构造函数完成复制功能。

 class Complex
 {
 private :
     double real,imag;
 };

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

（2）如果定义的自己的复制构造函数，则默认的复制构造函数不存在。

 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);//调用自己定义的复制构造函数，输出 Copy Constructor called

（3）当用一个对象去初始化同类的另一个对象时会调用复制构造函数

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

 CMyclass c1,c2;
 c2 = c1; //赋值语句

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

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

（5）如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用

类型转换构造函数

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

 class Complex {
 public:
     double real, imag;

     //类型转换构造函数
     Complex( int i)
     {
         cout << "IntConstructor called" << endl;
         real = i; imag = ;
     }

     Complex(double r,double i) {real = r; imag = i; }
 };

 int main ()
 {
     Complex c1(,);
     Complex c2 = ;
     c1 = ; // 9被自动转换成一个临时Complex对象
     cout << c1.real << "," << c1.imag << endl;
     return ;
 }

析构函数

（1）名字与类名相同，在前面加‘ ~’ ， 没有参数和返回值，一个类最多只能有一个析构函数。
（2）析构函数对象消亡时即自动被调用。可以定义析构函数来在对象消亡前做善后工作，比如释放分配的空间等。
（3）如果定义类时没写析构函数，则编译器生成缺省析构函数。缺省析构函数什么也不做。
（4）如果定义了析构函数，则编译器不生成缺省析构函数。
（5）析构函数在对象作为函数返回值返回后被调用。

下面看个析构函数的例子：

 #include <iostream>

 using namespace std;

 class CMyclass
 {
 public:
     CMyclass() {}
     CMyclass(const CMyclass & sobj) { cout << "copy constructor" << endl; }
     ~CMyclass() { cout << "destructor" << endl; }
 };

 CMyclass obj;

 //参数对象消亡也会导致析构函数被调用
 CMyclass fun(CMyclass sobj )
 {
     cout << "here_2" << endl;

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

 int main()
 {
     cout << "here_1" << endl;

     //函数调用的返回值（临时对象）被用过后，该临时对象析构函数被调用
     obj = fun(obj);

     cout << "here_3" << endl; 

     return ;
 }

运行结果：

here_1：main函数最开始

copy constructor：调用函数fun，传入的参数是一个对象

here_2：进入了函数fun中

copy constructor：返回的是一个对象

destructor：退出函数fun，参数被析构

destructor：函数fun的返回值是个临时对象，被使用后，也被析构

here_3：没什么好说的

destructor：析构全局的obj对象

再来看一个综合的例子：

 #include <iostream>

 using namespace std;

 class Demo {
     int id;
 public:
     Demo(int i)
     {
         id = i;
         cout << "id=" << id << " constructed" << endl;
     }
     ~Demo()
     {
         cout << "id=" << id << " destructed" << endl;
     }
 };

 Demo d1();

 void Func()
 {
     static Demo d2();
     Demo d3();
     cout << "func" << endl;
 }

 int main ()
 {
     Demo d4();
     d4 = ;
     cout << "main" << endl;
     {
         Demo d5();
     }
     Func();
     Func();
     cout << "main ends" << endl;
     return ;
 }

运行结果：

就解释一下id=6 constructed和id=6 destructed，这是因为调用了类型转换构造函数，生成了临时的对象

this指针

其作用就是指向成员函数所作用的对象

（1）非静态成员函数中可以直接使用this来代表指向该函数作用的对象的指针。
（2）静态成员函数中不能使用 this 指针！因为静态成员函数并不具体作用与某个对象!因此，静态成员函数的真实的参数的个数，就是程序中写出的参数个数！

 #include <iostream>

 using namespace std;

 class A
 {
     int i;
 public:
     //void Hello(A * this ) { cout << "hello" << endl; }
     void Hello() { cout << "hello" << endl; }
 }; 

 int main()
 {
     A * p = NULL;

     //Hello(p);
     p->Hello();

     return ;
 } 

运行结果：

 #include <iostream>

 using namespace std;

 class A
 {
     int i;
 public:
     //void Hello(A * this ) { cout << this->i << "hello" << endl; }
     void Hello() { cout << i << "hello" << endl; }
 }; 

 int main()
 {
     A * p = NULL;

     //Hello(p);
     p->Hello();

     return ;
 } 

运行结果：

静态成员变量

静态成员：在定义前面加了static关键字的成员。

（1）普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。
（2）普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用于某个对象。
（3）sizeof 运算符不会计算静态成员变量。
（4）基于（1）和（2）的缘故，静态成员不需要通过对象就能访问。
（5）静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。静态成员函数本质上是全局函数。
（6）设置静态成员这种机制的目的是将和某些类紧密相关的全局变量和函数写到类里面，看上去像一个整体，易于维护和理解。
（7）必须在定义类的文件中对静态成员变量进行一次说明或初始化。否则编译能通过，链接不能通过。

 #include <iostream>

 using namespace std;

 class CRectangle
 {
 private:
     int w, h;
     static int nTotalArea;
     static int nTotalNumber;
 public:
     CRectangle(int w_,int h_);
     ~CRectangle();
     static void PrintTotal();
 };

 CRectangle::CRectangle(int w_,int h_)
 {
     w = w_;
     h = h_;
     nTotalNumber ++;
     nTotalArea += w * h;
 }
 CRectangle::~CRectangle()
 {
     nTotalNumber --;
     nTotalArea -= w * h;
 }
 void CRectangle::PrintTotal()
 {
     cout << nTotalNumber << "," << nTotalArea << endl;
 }

 int main()
 {
     CRectangle r1(,), r2(,);
     //cout << CRectangle::nTotalNumber; // Wrong , 私有
     CRectangle::PrintTotal();
     r1.PrintTotal();
     return ;
 }

编译结果：

需要改为如下：

 int CRectangle::nTotalNumber = ;
 int CRectangle::nTotalArea = ;

即使这样编译通过了，上面的例子还有有缺陷的。

在使用CRectangle类时，有时会调用复制构造函数生成临时的隐藏的CRectangle对象（调用一个以CRectangle类对象作为参数的函数时或者调用一个以CRectangle类对象作为返回值的函数时）；临时对象在消亡时会调用析构函数，减少nTotalNumber 和nTotalArea的值，可是这些临时对象在生成时却没有增加nTotalNumber 和 nTotalArea的值

这时我们需要再自己写一个复制构造函数

 CRectangle::CRectangle(CRectangle & r )
 {
     w = r.w; h = r.h;
     nTotalNumber ++;
     nTotalArea += w * h;
 }

（8）在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

常量成员函数
如果不希望某个对象的值被改变，则定义该对象的时候可以在前面加 const关键字。

（1）常量对象只能使用构造函数、析构函数和有const说明的函数(常量方法）
（2）在类的成员函数说明后面可以加const关键字，则该成员函数成为常量成员函数。
（3）常量成员函数内部不能改变属性的值，也不能调用非常量成员函数。

 class Sample {
 private :
     int value;
 public:
     void func() { };
     Sample() { }
     void SetValue() const
     {
         value = ; // wrong
         func(); //wrong
     }
 };

 const Sample Obj;
 Obj.SetValue (); //常量对象上可以使用常量成员函数

（4）在定义常量成员函数和声明常量成员函数时都应该使用const 关键字。

 class Sample {
 private :
     int value;
 public:
     void PrintValue() const;
 };

 //此处不使用const会导致编译出错
 void Sample::PrintValue() const
 {
     cout << value;
 }

 void Print(const Sample & o)
 {
     o.PrintValue(); //若 PrintValue非const则编译错
 }

（5）mutable成员变量可以在const成员函数中修改的成员变量

 class CTest
 {
 public:
     bool GetData() const
     {
         m_n1++;
         return m_b2;
     }
 private:
     mutable int m_n1;
     bool m_b2;
 };

友元
（1）友元函数：一个类的友元函数可以访问该类的私有成员

 class CCar ; //提前声明 CCar类，以便后面的CDriver类使用
 class CDriver
 {
 public:
     void ModifyCar( CCar * pCar) ; //改装汽车
 };

 class CCar
 {
 private:
     int price;
     friend int MostExpensiveCar( CCar cars[], int total); //声明友元
     friend void CDriver::ModifyCar(CCar * pCar); //声明友元
 };

 void CDriver::ModifyCar( CCar * pCar)
 {
     pCar->price += ; //汽车改装后价值增加
 }

 //求最贵汽车的价格
 int MostExpensiveCar( CCar cars[],int total)
 {
     int tmpMax = -;
     for( int i = ; i < total; ++i )
         if( cars[i].price > tmpMax)
             tmpMax = cars[i].price;
     return tmpMax;
 }

（2）可以将一个类的成员函数(包括构造、析构函数)说明为另一个类的友元

 class B {
 public:
     void function();
 };

 class A {
     friend void B::function();
 };

（3）友元类：如果A是B的友元类，那么A的成员函数可以访问B的私有成员

 class CCar
 {
 private:
     int price;
     friend class CDriver; //声明CDriver为友元类
 };

 class CDriver
 {
 public:
     CCar myCar;

     //改装汽车
     void ModifyCar()
     {
         myCar.price += ;//因CDriver是CCar的友元类，故此处可以访问其私有成员
     }
 };

（4）友元类之间的关系不能传递，不能继承