C++ 快速入门笔记：面向对象编程

类 & 对象

1. 类定义

   class Box
   {
      public:
         double length;   // Length of a box
         double breadth;  // Breadth of a box
         double height;   // Height of a box
   };
   

2. 对象定义

   Box Box1;          // 声明 Box1，类型为 Box
   Box Box2;          // 声明 Box2，类型为 Box
   

3. 用 . 运算符访问数据成员

类成员函数

1. 在类的外部使用范围解析运算符 :: 定义函数

   double Box::getVolume(void)
   {
       return length * breadth * height;
   }
   

类访问修饰符

1. public
   公有成员在程序中类的外部是可访问的，可以不使用任何成员函数来设置和获取公有变量的值。
2. protected
   私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的，只有类和友元函数可以访问私有成员。
3. private
   保护成员变量或函数与私有成员十分相似，但有一点不同，保护成员在派生类（即子类）中是可访问的。

构造函数 & 析构函数

1. 类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void 。构造函数可用于为某些成员变量设置初始值。

2. 使用初始化列表来初始化字段

   Line::Line( double len): length(len)
   {
       cout << "Object is being created, length = " << len << endl;
   }
   

   等价于

   Line::Line( double len)
   {
       cout << "Object is being created, length = " << len << endl;
       length = len;
   }
   

3. 类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号（~）作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

拷贝构造函数

1. 拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

   • 通过使用另一个同类型的对象来初始化新创建的对象。
   • 复制对象把它作为参数传递给函数。
   • 复制对象，并从函数返回这个对象。

2. 如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。

   Line::Line(const Line &obj)
   {
       cout << "Copy constructor allocating ptr." << endl;
       ptr = new int;
       *ptr = *obj.ptr; // copy the value
   }
   Line::~Line(void)
   
   {
   
   cout << "Freeing memory!" << endl;
   
   delete ptr;
   
   }
   
   

友元函数

1. 类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。

2. 友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend 。

   #include <iostream>
   using namespace std;
   class Box
   {
       double width;
       public:
           friend void printWidth( Box box );
           void setWidth( double wid );
   };
   // 成员函数定义
   void Box::setWidth( double wid )
   {
       width = wid;
   }
   // 请注意：printWidth() 不是任何类的成员函数
   void printWidth( Box box )
   {
   /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
       cout << "Width of box : " << box.width <<endl;
   }
   // 程序的主函数
   int main( )
   {
       Box box;
   // 使用成员函数设置宽度
       box.setWidth(10.0);
   // 使用友元函数输出宽度
       printWidth( box );
       return 0;
   }
   

内联函数

1. C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。
2. 如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。

this 指针

1. 在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。

指向类的指针

1. 一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 -> ，就像访问指向结构的指针一样。

类的静态成员

1. 我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。
2. 静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。
3. 静态函数成员
   • 如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。

继承

1. 基类 & 派生类

• 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：

  class derived-class: access-specifier base-class
  

其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。

2. 访问控制和继承

   • 派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。
   • 我们可以根据访问权限总结出不同的访问类型，如下所示：（表格炸了）

   访问	public	protected	private
   同一个类	yes	yes	yes
   派生类	yes	yes	no
   外部的类	yes	no	no

   • 一个派生类继承了所有的基类方法，但下列情况除外：
     • 基类的构造函数、析构函数和拷贝函数。
     • 基类的重载运算符。
     • 基类的友元函数。

3. 继承类型

   • 当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
   • 几乎不使用 protected 或 private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：
     • 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
     • 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
     • 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

4. 多继承

   class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
   {
       <派生类类体>
   };
   

重载运算符和重载函数

1. C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
2. 当调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。
3. 函数重载
   • 在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。
4. 运算符重载

   • 重载的运算符是带有特殊名称的函数，函数名是由关键字 operator 和其后要重载的运算符符号构成的。与其他函数一样，重载运算符有一个返回类型和一个参数列表。

     Box operator+(const Box& b)
     {
          Box box;
          box.length = this->length + b.length;
          box.breadth = this->breadth + b.breadth;
          box.height = this->height + b.height;
          return box;
     }
     

多态

1. C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

2. 静态链接 / 静态多态 / 早绑定

3. 虚函数

   • 虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

   • 我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

     class Shape {
     protected:
         int width, height;
     public:
           Shape( int a=0, int b=0)
           {
              width = a;
              height = b;
           }
           virtual int area()
           {
              cout << "Parent class area :" <<endl;
              return 0;
           }
     };
     

4. 纯虚函数

   • 可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

     class Shape {
     protected:
         int width, height;
     public:
           Shape( int a=0, int b=0)
           {
              width = a;
              height = b;
           }
         // pure virtual function
         virtual int area() = 0;
     };
     

   • = 0 告诉编译器，函数没有主体，上边的虚函数是纯虚函数。

数据抽象

1. 数据抽象是指，只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。
2. 访问标签强制抽象
   • 使用访问标签来定义类的抽象接口。一个类可以包含零个或多个访问标签
     • 使用公共标签定义的成员都可以访问该程序的所有部分。一个类型的数据抽象视图是由它的公共成员来定义的。
     • 使用私有标签定义的成员无法访问到使用类的代码。私有部分对使用类型的代码隐藏了实现细节。

接口

1. 接口描述了类的行为和功能，而不需要完成类的特定实现。
2. 如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。

      </div>