C++ 知识总结 P06：面向对象

move 语义

左值与右值

在C++中可以取得内存地址的、有名字的变量就是左值，左值在使用时可以放在等号左侧；右值则是指不能取得内存地址的、没有名字的变量，只能在等号的右侧使用。右值直观上就是临时变量，如执行 a = b + c 时，等号右侧优先计算，加和结果会被保存在临时变量中，这个临时变量就是右值。
在C++中，使用左值的方式，可以是通过其“本名”访问，也可以通过引用访问，此时使用的引用是左值引用。但是右值没有关联名字，为了能够使用右值，C++引入了右值引用的概念。

void func(string& str);    // 这是一个左值引用
void func(string&& str);   // 这是一个右值引用

问题是我们为什么要直接使用右值？可以看下面这个例子

struct Node {
    int val;
    Node(const int& _val) : val(_val) {}
};
int input = 10;
Node node_a(input);
Node node_b(10);

上述例子中，两个实例的构造过程基本相同；区别在于 node_a 中传入的是左值引用，在使用完后 input 变量仍然存活，而 node_b 中传入的是一个临时变量，临时变量的值会被复制到 val 中，临时变量使用完后就被销毁了。如果传入的临时变量空间占用非常大，复制过程就是一笔很大的开销，何不保留临时变量并直接将 val 指向临时变量呢？

move 语义

C++中提供了 move 语义，可以将“将亡值”（即将被销毁的临时变量）有效期的有效期延长，直接保留临时变量而避免上述的拷贝过程。

struct Node {
    int val;
    Node(const int& _val) : val(_val) {}
    Node(int&& _val) { val = std::move(_val); }
};
int input = 10;
Node node_a(input);
Node node_b(10);

a = std::move(b) 可以理解为将 b 这个名字擦掉，以 a 这个名字替换，此时将再也无法使用 b 访问该变量。

指针与智能指针

使用指针

C++ 提供了 new 和 delete 关键字来分配和释放内存（堆）

// 或者直接用 auto
string* p_str = new string{"hello, world"}; // 这种花括号的使用也是可以的
delete p_str;

使用智能指针

智能指针是C++为了能够更安全地使用动态内存而产生的一种指针，与传统指针不同的地方，智能指针在不使用时会自动释放所指向的对象，避免内存空间浪费。

智能指针使用模板创建：

• share_ptr 允许多个指针指向同一个对象；
• unique_ptr 独占指向的对象；
• weak_ptr 指向 share_ptr 指向的对象，但是不参与其生存期的计数，因此使用前要检查。

share_ptr<int> p_int = make_shared<int>(10);  // 无须手动释放

类的定义

关键字 struct 与 class 搜可以由于类的创建，struct 中的所有成员都是公开的，而 class 中的所有成员权限默认是私有的。

构造函数

默认构造函数

默认构造函数没有参数，会对类的成员进行默认初始化：如果成员变量有默认初始值，则使用默认初始值，如果成员有默认初始化的方法，则使用这些方法；否则，默认构造函数会报错。

如果没有在类中声明任何构造函数，编译器会自动创建一个默认构造函数，但是如果有声明构造函数，编译器就不会自动生成默认构造函数了。此时如果需要默认构造函数，可以手工指定 classname() = default。

普通的构造函数

使用带有参数的构造函数，为类的成员变量赋初始值，以及进行一些其它的初始化动作。这里可以使用初始值列表：

classname(const type& _a, const type& _b) : var_a(_a), var_b(_b), var_c(0) {}

初始值列表即函数参数之后、函数体之前的部分，还可以在这一部分使用默认初始值来初始化成员变量。

对于类内的 const 成员变量，只能使用初始值列表进行初始化。
使用列表初始化构建类的实例时，会使用该初始值列表，按照成员变量的声明顺序进行初始化操作。

委托构造函数

在构造函数中使用同一类的其它构造函数，就是委托构造函数。委托构造函数的形式：

classname(const type& _a) : classname(_a, 0) {}

这个构造函数使用了上述的带有初始值列表的构造函数。

转换构造函数
由于 C++ 提供的隐式转换，使得构造函数能够使用的参数类型范围更大。如果不想要这种隐式类型转换，可以使用 explicit 修饰构造函数，只能使用在声明处。

拷贝构造函数
拷贝构造函数的参数是类本身，用来实现类的拷贝行为。此外，还有拷贝赋值也实现了类的拷贝，是通过重载 = 运算符实现的。

classname(const classname& _c) : var_a(_c.a), var_b(_c.b), var_c(_c.c) {}
classname& operator=(const classname& _c) { return *this; }

classname p1(p2);        // 拷贝
classname p1 = p2;       // 赋值

如果没有手工定义拷贝构造函数和拷贝赋值函数，编译器会自动合成；如果想显式地要求编译器合成拷贝构造函数和拷贝赋值函数，使用 =default；如果想禁止类有拷贝的能力，阻止任何的拷贝构造函数和拷贝赋值函数，使用 =delete。

移动构造函数
移动构造函数与拷贝构造函数很类似，用来实现类的移动行为。同样的，也有移动赋值运算符。

classname(classname&& _c) : /* 这里不写了 */ {}
classname& operator=(classname&& _c) { return *this; }

编译器不会为类合成移动构造函数和移动赋值函数。

析构函数

析构函数用于销毁实例。如使用 delete p 是会调用 p 的析构函数进行销毁。

友元

友元是用来控制其它的函数或对象，访问本对象的非公开成员的方法。比如使用打印函数将本对象打印到屏幕，本对象中的某些成员变量是私有的，通过对打印函数添加 friend 前缀，使它可以访问这些私有成员变量。

操作符重载

在类中重载运算符可以丰富类的行为，使类更方便使用。如

• 重载 = 运算符来实现各种赋值的行为。
• 重载比较运算符实现实例的比较，这样实例就可以使用标准算法库进行查找排序等操作。
• 重载 () 使类成为一个函数对象。
• 重载 [] 使类表现地向容器一样可以通过下标访问。

重载运算符以符合日常使用的经验为佳。

类的类

虚函数

虚函数为允许基类调用的派生类的函数。在派生类中不一定要重新定义基类的虚函数，但是重新定义后，基类和派生类就会对该函数拥有各自的版本，在调用该函数时动态绑定。借助指针或引用，虚函数能够实现多态的效果。

class base {
    virtual type func() {}
}
class deriver : public base {
    virtual type func() {}
}

// 此时使用 base 类型的指针定义 deriver 的对象
base* obj = new deriver();
obj.func();    // 此时会使用 deriver 中的 func，而不是 base 中的 func

从上面的例子可以看出，析构函数最好定义成虚函数，否则 obj 可能不能正确地析构。

纯虚函数为没有实现的函数。纯虚函数的目的是要求派生类必须实现这一函数，主要是为了规范派生类的功能。带有纯虚函数的类称为抽象类，因为纯虚函数没有实现，无法进行实例化。

virtual type function(args) = 0;    // 纯虚函数

面向对象

面向对象编程的三个特征是：封装、继承、多态。

对于 C++ 而言，封装的概念很好理解：通过类的抽象，许多细节被隐藏在了类的内部，使类的用户只需要关心接口如何使用即可；以及使用 public, private, protected 对类成员的权限控制，使类的使用者不会触及他们不该访问的类成员。

C++ 支持单一继承或多重继承，提供的抽象类的概念，以及使用 public, private, protected 进行继承中权限的控制，都是对继承的支持。在继承中比较容易混淆的是普通成员函数、虚函数、纯虚函数，这里以类指针下的三个函数调用说明区别：

class base {
public:
    string f() { return "base.f"; }            // 普通函数
    virtual string g() { return "base.g"; }    // 虚函数
    virtual string h() = 0;                    // 纯虚函数
};
class deriver : public base {
public:
    string f() { return "deriver.f"; }
    virtual string g() { return "derivr.g"; }
    string h() { return "deriver.h"; }
};
int main() {
    base*     pb = new deriver();
    deriver*  pd = new deriver();
    // 普通的成员函数
    cout << pb->f() << endl;  // -> base.f
    cout << pd->f() << endl;  // -> deriver.f
    // 虚函数
    cout << pb->g() << endl;  // -> deriver.g
    cout << pd->g() << endl;  // -> deriver.g
    // 纯虚函数
    cout << pb->h() << endl;  // -> deriver.h
    cout << pd->h() << endl;  // -> deriver.h
}

从上面的比较可以看出：

• 对于普通的成员函数，对它的调用取决与实例声明的类型，声明为一个 base 类型时，就会使用 base 的普通成员函数，声明为一个 deriver 类型时，就会使用 deriver 的普通成员函数。
• 对于虚函数，对它的调用取决与实例的实质类型，这里实质上两个指针指向的都是 deriver 类型的，所有都会使用 deriver 类型的。
• 对于纯虚函数，抽象类不会实现，只会使用派生类的。

上面的比较可以看出，使用普通成员函数时，基类更像是多种类型相同点的抽象，使用中直接使用派生类会比较合适（实现继承）。而使用虚函数和纯虚函数时，基类看上去更像是多种派生类的统一接口，通过使用基类调用接口相同但行为不同的派生类的功能（接口继承）。这样对于同一基类下的派生类，使用基类作为某个函数的参数就能定义出所有派生类的行为，否则就需要每一个派生类单独定义。这种方式是多态的体现。

C++ 知识总结 P06：面向对象

原文：https://www.cnblogs.com/ixtwuko/p/cc-p06.html