说到面向对象，大家第一反应应该就是它的三大特性：封装性、继承性和多态性。那么我们先简单的了解一下这三大特性：

     （1）封装性：封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。

在C++中类中成员的属性有：public， protected， private，这三个属性的访问权限依次降低。

     （2）继承性：继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

     （3）多态性：多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。实现多态，有二种方式，覆盖，重载。

覆盖，是指子类重新定义父类的虚函数的做法。

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。

下面开始我们今天的学习。

1、C++中空类默认产生哪些类成员函数？

答案：

对于一个空类，编译器默认产生4个成员函数：

（1）默认构造函数

（2）析构函数

（3）拷贝构造函数

（4）赋值函数

 

2、结构是否可以有构造函数、析构函数及成员函数？如果可以，那么结构和类还有什么区别吗？

答案：

区别是class中变量默认是private，struct中的变量默认是public。class继承默认是private继承，而struct继承默认是public继承。struct可以有构造函数、析构函数，之间也可以继承甚至是多重继承，等等。C++中的struct其实和class意义一样，唯一不同就是struct里面默认的访问控制是public，class中默认访问控制是private。C++中存在struct关键字的唯一意义就是为了让C程序员有个归属感，是为了让C++编译器兼容以前用C开发的项目。

 

3、下面程序打印出的结果是什么？

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

#include<iostream> using  namespace  std;   class  base { private :      int  m_i;      int  m_j; public :      base( int  i ) : m_j(i),m_i(m_j) {}      base() : m_j(0),m_i(m_j){}      int  get_i() { return  m_i;}      int  get_j() { return  m_j;} };   int  main () {      base obj(98);      cout << obj.get_i() <<endl<< obj.get_j() <<endl;      return  0; }

解析：本题想得到的结果是“98，98”。但是成员变量的声明是先 m_i ，然后是 m_j；初始化列表的初始化变量顺序是根据成员变量的声明顺序来执行的，因此，先初始化 m_i，但此时 m_j 还未初始化，m_i 会被赋予一个随机值。改变一下成员变量的声明顺序可以得到预想的结果。

答案：

输出结果第一个为随机数，第二个是98。

 

4、下面这个类声明正确吗？为什么？

1 2 3 4

class  A {      const  int  Size = 0; };

解析：这道程序题存在着成员变量问题。常量必须在构造函数的初始化列表里初始化或者将其设置成static。

答案：

正确的程序如下:

 

1 2 3 4 5 6 7

class  A {      A()      ｛          const  int  Size = 1;      ｝ };

 

或者：

1 2 3 4

class  A {      static  const  int  Size = 1; };

 

5、析构函数可以为 virtual 型，构造函数则不能，为什么？

答案：

虚函数采用一种虚调用的办法。虚调用是一种可以在只有部分信息的情况下工作的机制，特别允许我们调用一个只知道接口而不知道其准确对象类型的函数。但是如果要创建一个对象，你势必要知道对象的准确类型，因此构造函数不能为 virtual。

 

6、如果虚函数是非常有效的，我们是否可以把每个函数都声明为虚函数？

答案：

不行，这是因为虚函数是有代价的：由于每个虚函数的对象都必须维护一个 v 表，因此在使用虚函数的时候会产生一个系统开销。如果仅是一个很小的类，且不行派生其他类，那么根本没必要使用虚函数。

 

7、请看下面一段程序：

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<iostream> using  namespace  std;   class  B { private :      int  data; public :      B()      {          cout<< "defualt constructor" <<endl;      }        ~B()      {          cout<< "destructed " <<endl;      }        B( int  i) : data(i)      {          cout<< "constructed by parameter" <<data<<endl;      } };   B Play( B b ) {      return  b; }   int  main () {      B temp = Play(5);      return  0; }

问题：

       （1）该程序输出结果是什么？为什么会有这样的输出？

      （2）B( int i ) : data( i )，这种用法的专业术语叫什么？

      （3）Play( 5 )，形参类型是类，而5是个常量，这样写合法吗？为什么？

答案：

（1）输出结果如下：

1 2 3

constructed by parameter //在Play(5)处，5通过隐含的类型转换调用了B::B( int i )         destructed          //Play(5) 返回时，参数的析构函数被调用         destructed           //temp的析构函数被调用；temp的构造函数调用的是编译器生存的拷贝构造函数

（2）待参数的构造函数，冒号后面的是成员变量初始化列表（member initialization list）

（3）合法。单个参数的构造函数如果不添加explicit关键字，会定义一个隐含的类型转换；添加explicit关键字会消除这种隐含转换。

 

8、编写类 String 的构造函数、析构函数和赋值函数。

      已知类 String 的原型为：

1 2 3 4 5 6 7 8 9 10

class  String { public :      String( const  char  *str = NULL);           //普通构造函数      String( const  String &other);              //拷贝构造函数      ~String( void );                            //析构函数      String & operate =( const  String &other);  //赋值函数 private :      char  *m_data;                             //用于保存字符串 };

答案：

1、 String 的析构函数：

1 2 3 4

String::~String( void ) {      delete  [] m_data; }

2、String 的构造函数：

1 2 3 4 5 6 7 8 9 10 11 12 13 14

String::String( const  char  *str) {      if (NULL==str)      {          m_data = new  char [1];          *m_data = '\0' ;      }      else      {          int  length = strlen (str);          m_data = new  char [length+1];          strcpy (m_data,str);      } }

3、String的拷贝构造函数：

1 2 3 4 5 6

String::String( const  String &other) {      int  length = strlen (other.m_data);      m_data = new  char [length+1];      strcpy (m_data,other.m_data); }

4、String的赋值函数：

1 2 3 4 5 6 7 8 9 10 11 12

String & String::operate =( const  String &other) {      if ( this == &other) //检查自复制      {          return  * this ;      }      delete  [] m_data; //释放原有的内存资源      int  length= strlen (other.m_data); //分配新内存资源，并复制内容      m_data = new  char [length+1];      strcpy (m_data,other.m_data);      return  * this ;     //返回本对象的引用 }

 

 

9、重载与覆盖有什么不同？

答案：

     虚函数总是在派生类中被改写，这种改写被称为“override”（覆盖）。

     override 是指派生类重写基类的虚函数，重写的函数必须有一致的参数表和返回值。Override这个单词好像一直没什么合适的中文词汇来对应。有些人译为“覆盖”，还贴切一些。

     overload约定成俗地被翻译为“重载”，是指编写一个与自己已有函数同名但是参数表不同的函数。例如一个函数既可以接受整型数作为参数，也可以接收浮点数作为参数。重载不是一种面向对象的编程，而是一种语法规则，重载与多态没什么直接关系。