C++ 入门笔记 OOP与类1

类的实例化(instantiation), 构造器 (constructors), 销毁器 (destructors)

例子：实现一个2x2的矩阵 Matrix2x2。
为简单起见，矩阵的四个元素定义为a1, a2, a3, a4. 均为私有变量。根据代码规范，我们在私有变量后添加下划线。

class Matrix2x2(){

private: // Private members
    double a1_;
    double a2_;
    double a3_;
    double a4_; 
}

类的构造器 (constructors) 可以看作一种特殊的成员函数，其作用主要是对类对象成员的初始化。通常来说，C++内部整合了默认的构造器，可以在类中没有定义任何构造器的情况下初始化类：

Matrix2x2 M1; // Synthesized Default Constructor

但是最好不要依赖C++的整合构造器，应当在类内自己定义。原因有三：
1. C++只会在没有任何构造器被定义时使用默认构造器。也就是说，如果你在类里定义了其他构造器（但没有定义默认构造器），C++就不会实现整合构造器；
2. 类的成员变量是复合(compound)或内置(built-in)类型的时候，整合构造器可能会给出和你预期有差距的结果；
3. 有些类可能没有整合构造器。

几种构造器的结构如下：

class Matrix2x2(){
    public:
      Matrix2x2() = default; // Using sythesized constructor
      Matrix2x2(){ //Overloaded default constructor
          a1_ = 0.0;
          a2_ = 0.0; 
          a3_ = 0.0;
          a4_ = 0.0;
      }
     Matrix2x2(double a1, double a2, double a3, double a4){   
          a1_ = a1;
          a2_ = a2; 
          a3_ = a3;
          a4_ = a4;
      }
     Matrix2x2(double a1, double a2, double a3, double a4): // Initializer List
                     a1_(a1), a2_(a2), a3_(a3), a4_(a4){  }
      Matrix2x2(const Matrix2x2 &a){ // Copy constructor
          a1_ = a.geta1();
          a2_ = a.geta2(); 
          a3_ = a.geta3();
          a4_ = a.geta4();
      }
...
}

类的销毁器 (destructors) 在类被销毁时（例如类在函数内被使用，而函数执行完毕时）自动执行。和构造器一样，销毁器同样有C++的整合版本。当类的成员变量是在内存中动态分配 (dynamic allocated memory, DMA) 的时候，需要手动重载销毁器。此处我们把Matrix2x2的成员变量改为C数组/指针。

class Matrix2x2(){
  public:
    Matrix2x2(){ //Constructor using DMA
        a_ = new double[4];
        a_[0] = 0.0;
        a_[1] = 0.0; 
        a_[2] = 0.0;
        a_[3] = 0.0;
    }
    ~Matrix2x2(){
        delete[] a_;
    }
  private:
    double* a_;
}

类成员属性

private

带有private的类成员只能被类成员访问，无法被其他变量或函数访问。

Matrix2x2 Mat;
double a3 = Mat.a_[3]; // Compiler error
double geta3(Matrix2x2 Mat){
    return Mat.a_[3];
} // Compiler error

public

带有public的类成员可以被程序内的任何部分访问。

struct和class

如果一个类被定义为struct, 其成员默认为public；如果一个类被定义为class，其成员默认为private。

friend

friend关键字给予外部函数访问private成员的权限。

class Matrix2x2(){
  friend double geta3(Matrix2x2);
  public:
    Matrix2x2(){ //Constructor using DMA
        a_ = new double[4];
        a_[0] = 0.0;
        a_[1] = 0.0; 
        a_[2] = 0.0;
        a_[3] = 0.0;
    }
    ~Matrix2x2(){
        delete[] a_;
    }
  private:
    double* a_;
}

最好把所有的friend函数放在一起定义，而且最好是放在类声明的最前或者最后。