C++ 语言面向对象 on ClearSec Wiki

编程环境

Mon, 01 Jan 0001 00:00:00 +0000

编程环境

说明

从单个 C++ 代码文件到多个 C++ 代码文件

在讲解面向对象这个编程概念之前，我们认为有必要简单介绍我们是如何从 C++ 代码文件得到可执行文件的，以及如何编译多个 C++ 代码文件。简单了解这些知识有助于读者后续理解。

源程序的结构与预编译

源程序的结构

一个经典的 C++ 代码文件的结构为：

#include <iostream>
using namespace std; // 头文件与编译指令

int add(int a, int b) { return a + b; } // 辅助函数定义

int main() { // 主函数定义
 cout << add(3, 4);
 return 0;
}

预编译指令

定义

上文代码中提及的“头文件与编译指令”中的编译指令实际上是预编译指令的意思，而预编译与预处理是同一概念。

C/C++ 编译系统编译程序的过程为预编译、编译、链接。预处理器在程序源文件被编译之前根据预处理指令对程序源文件进行处理。

而预处理器指令以 # 号开头标识，并不是一句指令，末尾不包含分号。预处理命令不是 C/C++ 语言本身的组成部分，不能直接对它们进行编译和链接。C/C++ 语言的一个重要功能是可以使用预处理指令和具有预处理的功能。二者提供的预处理功能主要有文件包含、宏替换、条件编译等。

文件包含

预处理指令 #include 将被包含的文件代码，直接复制到当前文件，一般被用于包含头文件（实际也能包含任意代码）。有两种形式：#include <xxx.h> 以及 #include "xxx.h"。尖括号形式表示被包含的文件在系统目录中。如果被包含的文件不一定在系统目录中，应该用双引号形式（注意到是应该用，不是最好用）。

在双引号形式中可以指出文件路径和文件名。如果在双引号中没有给出绝对路径，则默认为用户当前目录中的文件，此时系统首先在用户当前目录中寻找要包含的文件，若找不到再在系统目录中查找。对于用户自己编写的头文件，应用双引号形式。对于系统提供的头文件，既可以用尖括号形式，也可以用双引号形式，都能找到被包含的文件，但使用用尖括号形式更直截了当，效率更高。

宏替换

意义

#define 是 C++ 语言中的一个预编译指令，它用来将一个标识符定义为一个字符串，该标识符被称为宏名，被定义的字符串称为替换文本。在程序被编译前，先将宏名用被定义的字符串替换，这称为宏替换，替换后才进行编译，宏替换是简单的替换。

宏定义

宏定义包括无参数宏定义和带参数宏定义两类。宏名和宏参数所代表的代码序列可以是任何意义的内容，如类型、常量、变量、操作符、表达式、语句、函数、代码块等。但是宏名和宏参数必须是合法的标识符，其所代表的内容及意义在宏展开前后必须一直是独立且保持不变的，不能分开解释和执行。

无参数宏

用一个用户指定的称为宏名的标识符来代表一个代码序列，这种定义的一般形式为 #define 标识符代码序列。其中 #define 之后的标识符称为宏定义名（简称宏名），在宏定义 #define 之前可以有若干个空格、制表符，但不允许有其它字符，宏名与代码序列之间用空格符分隔。例如：

#define PI 3.1415926535

在 C++ 中，这种替换一般被 const 取代，进而能保证类型的正确性。

C++ 语言函数进阶

Mon, 01 Jan 0001 00:00:00 +0000

C++ 语言函数进阶

说明

一些新东西

我们相信读者已经知晓如何编写 C/C++ 语言之中的函数，现在我们将要讲解一些类似函数重载、默认参数等进阶功能。利用好这些功能可以简化编写代码的过程。

函数重载

定义与意义

同一名称的函数，有两个以上不同的函数实现，被称为函数重载（英语：Overload）。

区别方法

多个同名的函数实现之间，必须保证至少有一个函数参数的类型有区别。即这些同名函数的形式参数的个数、类型或者顺序必须不同，而返回值、参数名称等不能作为区分标识。

float f(int s) { return s / 2.0; }
int f(int s) { return s * 2; }
int main() {
	cout << f(3) << endl;
	return 0;
}

上述两个 f 函数并不是函数重载，因为其只有返回值类型不同。在主函数中调用 f(3) 时，编译器依然无法确定调用哪一个函数。

自动类型转换

定义与性质

如果函数调用语句的实参与函数定义中的形参数据类型不同，且两种数据类型在 C++ 中可以进行自动类型转换（如 int 和 float，float 在自动转换成 int 时是向下取整），则实参会被转换为形参的类型。例如：

#include <iostream>
using namespace std;
void print(float score) {
	cout << "score =" << score << endl;
}

int main() {
	int a = 1;
	print(a); // 此时 a 会被转换为 float 型
	return 0;
}

又例如，自动类型转换也可以通过自定义的类型转换运算符来完成。这些将会在后续章节中阐述。

优先匹配调用

当函数重载时，会优先调用类型匹配的函数实现，否则才会进行类型转换。例如：

#include <iostream>
using namespace std;
void print(int score) { cout << score << endl; }
void print(float score) { cout << score << endl; }

int main() {
	float a = 1.0;
	print(a); // 1
	return 0;
}

这里看上去和优先匹配调用相互矛盾，其实并不是，这是由于 float 输出精度的问题。我们稍作修改：

C++ 类语法初步

Mon, 01 Jan 0001 00:00:00 +0000

C++ 类语法初步

说明

面向对象的概念

在介绍类之前，我们终于要引出面向对象这个概念了。

面向对象（英语：Object oriented）是一种编程范式，其目的是将数据和相关方法封装为一个整体。在使用面向对象的编程方法的时候，我们通常将具有类似抽象特点的事物归为一个类，而具有这些抽象特点的事物就是这个类的实例对象。

比如说，所有的学生都应该具有名字，有一个整数的年龄，这就是学生这类事物的抽象概念。在 C++ 语言中我们就可以描述为：

class Student {
 int age;
 std::string name;
};

这里 Student 是类，age 和 name 都是类的成员变量。成员变量描述了类的数据特征。

而类之中还可以具有函数，其描述了我们可以以何种方式操作类的成员变量，所以这些函数也称为类方法。比如说学生都可以去上学：

class Student {
 int age;
 std::string name;

 void goToSchool() { }
};

在描述出学生这个概念之后，我们就可以创建一个学生，这个学生一定有我们在类之中规定的这些抽象特征：

Student* s = new Student();

这就称为类的实例化，即我们创建出了一个对象，这个对象符合这些抽象特征。

当然，上面说的都是最简单的面向对象概念。后面将会涉及到访问权限、继承、虚方法等各种更进阶的概念，不过保持着这样的最基本的 OOP 思想是重要的。 [!NOTE] 基础讲些什么？

这一部分主要讲解对象的构造和析构、引用以及运算符重载。

访问权限

有时我们并不希望类的部分隐私成员变量为外人所知，此时我们可以将其用 private: 声明为私有。同样，可以公开的成员变量则可以用 public: 声明为公有。C++ 的类默认权限为私有：

class Student {
public:
	int age;
	std::string name;

private:
	int ID;

public:
	void goToSchool() { }
}

类方法也可以声明公有和私有。

私有的类成员和类方法仅可以在类自己的方法内访问或调用，外部调用会报错。公有的类成员和类方法则可以任意调用、读取、修改。

构造函数与析构函数

构造函数

意义

构造函数是编译器在实例化一个对象的时候自动调用的函数，也就是说对象的“生”（初始化工作）是由编译器在创建对象处自动生成调用构造函数的代码来完成的。构造函数是类的特殊成员函数，它用来确保类的每个对象都能正确地初始化。

语法

构造函数没有返回值类型，函数名必须与类名相同。类的构造函数可以重载，即可以使用不同的函数参数进行对象初始化。

class Student {
	int ID;

public:
 Student(int id) { ID = id; }
 Student(int year, int order) { 
 	ID = year * 10000 + order; 
 }
};

这样我们就得到了学生类的两个构造函数。构造函数的调用语法（即对象创建的语法）有几种常用的：

C++ 类语法进阶

Mon, 01 Jan 0001 00:00:00 +0000

C++ 类语法进阶

说明

进阶讲些什么？

这一部分主要深入对象的构造和析构，并且涉及到常量、静态、友元的概念。

本部分讲解的内容可以浓缩为：

变量与静态变量

四类变量的区别

按存储区域分

全局变量、静态全局变量和静态局部变量都存放在内存的静态存储区域，局部变量存放在内存的栈区。静态储存区在函数结束后不会销毁，而栈区在函数结束后会退栈而销毁。

按作用域分

动态变量

全局变量在整个工程文件内都有效，是“在函数外定义的变量”，即从定义变量的位置到本源文件结束都有效。由于同一文件中的所有函数都能引用全局变量的值，因此如果在一个函数中改变了全局变量的值，就能影响到其他函数中全局变量的值。所谓整个工程，是指所有的文件都可以用，不单单在定义全局变量的那个文件。

局部变量在定义它的函数内有效，但是函数返回后失效，是“在函数内定义的变量”，即在一个函数内部定义的变量，只在本函数范围内有效。

注意：全局变量和静态变量如果没有手工初始化，则由编译器初始化为 0。局部变量的值不可知。

静态变量（static）

静态决定了两件事，第一就是存储后不会立刻销毁。第二是自带有一定的限定变量作用区域的功能，强化全局/局部的具体作用域。

静态全局变量只在定义它的文件内有效，效果和全局变量一样，只是就在本文件内部。

静态局部变量只在定义它的函数内有效，只是程序仅分配一次内存，函数返回后，该变量不会消失；静态局部变量的生存期虽然为整个工程，但是其作用仍与局部变量相同，即只能在定义该变量的函数内使用该变量。退出该函数后，尽管该变量还继续存在。局部决定其无法被其他函数使用只能被同一函数下次再用。静态决定其保存在静态区，无法被立刻销毁。

这里还继续存在意味着很重要的性质，对于这个函数而言，静态局部变量是可以复用的。静态局部变量在静态存储区内分配存储单元。在程序整个运行期间都不释放。而自动变量（即动态局部变量）属于动态存储类别，存储在动态存储区空间而不是静态存储区空间，每一次该函数调用结束后即释放。

为静态局部变量赋初值是在编译时进行的，即只赋初值一次，在程序运行时它已有初值。以后每次调用函数时不再重新赋初值而只是保留上次函数调用结束时的值。而为自动变量赋初值，不是在编译时进行的，而是在函数调用时进行，每调用一次函数重新给一次初值，相当于执行一次赋值语句。

如果在定义局部变量时不赋初值的话，对静态局部变量来说，编译时自动赋初值 0（数值型变量）或空字符（字符型变量）。而对自动变量来说，如果不赋初值，则它的值是一个不确定的值。这是由于每次函数调用结束后存储单元已释放，下次调用时又重新另分配存储单元，而所分配的单元中的值是不确定的。

虽然静态局部变量在函数调用结束后仍然存在，但其他函数是不能引用它的。也就是说，在其他函数中它是“不可见”的（这个不可见是指静态局部变量的名称不可在其他函数内被操作。但是由于其内存并没有被析构掉，我们依然能够对这块内存进行操作，这一神奇的操作详见上一章节）。

静态变量与全局变量最明显的区别就在于，全局变量在其定义后所有函数都能用，但是静态全局变量只能在一个文件里面使用，而静态局部变量只能在一个函数里使用。

形参变量

只在被调用期间才分配内存单元，调用结束立即释放。

在函数体内，形参的等级最高。当全局变量名与形参名冲突的时候，函数会操作形参，而不是全局变量。例如：

#include "stdio.h"
int Max = 1;
void add(int Max) {
	Max = 2;
}

int main() {
	add(Max);
	printf("Max = %d", Max);
	getchar();
	return 0;
}

这个结果当然是 Max = 1。进入函数后，用实参来构造了形参，形参的优先级高于全局变量，但改变形参不改变全局变量，且函数执行完后，形参释放。

静态变量

意义

static 的本质意义在于可控制变量的存储方式和可见性。

在函数内部定义的变量，当程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉。如果想将函数中此变量的值保存至下一次调用时，应该如何实现？最容易想到的方法是定义为全局的变量，但定义一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅只受此函数控制）。static 关键字则可以很好的解决这个问题。

另一方面，在 C++ 中，需要一个数据对象为整个类而非某个对象服务，同时又力求不破坏类的封装性，即要求此成员隐藏在类的内部，对外不可见时，可将其定义为静态数据。

定义

使用 static 修饰的变量。例如 static int i = 1。

初始化

引用与复制

Mon, 01 Jan 0001 00:00:00 +0000

引用与复制

常量引用

常量引用的意义

按照最小特权原则：给函数足够的权限去完成相应的任务，但不要给予他任何多余的权限。例如函数 void add(int& a, int& b)，如果将参数类型定义为 int&，则给予该函数在函数体内修改 a 和 b 的值的权限。

如果我们不想给予函数修改权限，则可以在参数中使用常量、常量引用 void add(const int& a, const int& b)。此时函数中仅能读取 a 和 b 的值，无法对 a、b 进行任何修改操作。

拷贝构造函数

定义与语法规则

拷贝构造函数是一种特殊的构造函数，它的参数是语言规定的，是同类对象的常量引用。作用：用参数对象的内容初始化当前对象。

Vector::Vector(const Vector& other) {
 capacity = other.capacity;
 len = other.len;
 array = new Node[other.capacity];
 for (int i = 0; i < len; i++) {
 array[i] = other.array[i];
 }
}

调用时机

拷贝构造函数被调用的三种常见情况。在这些情况下，编译器会自动调用“拷贝构造函数”，在已有对象基础上生成新对象。

用一个类对象定义另一个新的类对象：

Test a;
Test b(a);
Test c = a;

函数调用时以类的对象为形参：

Func(Test a)

函数返回类对象（无返回值优化的情况下）：

Test Func(void)

隐式拷贝构造函数

类的新对象被定义后，会调用构造函数或拷贝构造函数。如果调用拷贝构造函数且当前没有给类显式定义拷贝构造函数，编译器将自动合成“隐式定义的拷贝构造函数”，其功能是调用所有数据成员的拷贝构造函数或拷贝赋值运算符。

对于基础类型来说，默认的拷贝方式为位拷贝（英语：Bitwise Copy），即直接对整块内存进行复制。

位拷贝原本是 C 中的概念。在 C++ 中，只有基础类型（int、double 等）才会进行位拷贝；对于自定义类，编译器会递归调用所有数据成员的拷贝构造函数或拷贝赋值运算符。但一些教材中仍然把这种行为称为“位拷贝”，以区别用户自定义的拷贝方法。

隐式定义拷贝构造函数的缺陷：隐式定义拷贝构造函数在遇到指针类型成员时可能会出错,导致多个指针类型的变量指向同一个地址。

执行顺序

基本的执行顺序

以下述的 func 函数为例，调用该函数时，函数中各类构造函数和析构函数的执行顺序如下。

值得一提的是，实际上在主函数体内，假设我们禁用返回值优化。Myclass a = func(d) 这个语句内的返回值类构造调用了拷贝构造，并且相关的析构非常值得研究，下文将在移动构造函数的例子中将进一步阐述。

组合与继承

Mon, 01 Jan 0001 00:00:00 +0000

组合与继承

组合

定义

如果对象 a 是对象 b 的一个组成部分，则称 b 为 a 的整体对象，a 为 b 的部分对象。并把 b 和 a 之间的关系，称为“整体-部分”关系（也可称为“组合”或“has-a”关系）。

两种实现方式

公有成员

已有类的对象作为新类的公有数据成员，这样通过允许直接访问子对象而“提供”旧类接口。

私有成员

已有类的对象作为新类的私有数据成员。新类可以调整旧类的对外接口，可以不使用旧类原有的接口（相当于对接口作了转换）。

我们有如下命名两类组合方式：

private:
 Wheel w; // private 组合
public:
 Engine e; // public 组合

`public` 接口访问 `private` 数据

#include <iostream>
using namespace std;
class Wheel {
 int _num;
public:
 void set(int n) { _num = n; }
};

class Engine {
public:
 int _num;
 void set(int n) { _num = n; }
};

class Car {
private:
 Wheel w;
public:
 Engine e; // 公有成员，直接访问其接口
 void setWheel(int n) { w.set(n); } // 提供私有成员的访问接口
};

int main() {
 Car c;
 c.e.set(1);
 c.setWheel(4);
 return 0;
}

Car 由 Engine 和 Wheel 两部分组成。如果我的 Wheel 设为私有，那么我没法直接在类外（主函数里）访问 w.set(n)，因为类外无法访问私有成员。私有成员的所有接口会在类外整体私有化，但是私有成员的 public 接口仍然可以被类内函数调用。可以设置 public 接口 setWheel，setW Weel 是个 public 的类内函数，可以访问类内 private 成员，从而我能够通过此接口访问到 private 数据成员 Wheel w 的 public 接口，但是也无法直接访问 private 部分的 private 数据。同理，观察 Wheel 类和 Engine 类的写法，其实也是这种给 private 对象添加 public 接口的思想。

虚函数

Mon, 01 Jan 0001 00:00:00 +0000

虚函数

向上类型转换

定义

派生类对象、引用、指针转换成基类对象、引用、指针，称为向上类型转换。只对 public 继承有效，在继承图上是上升的；对 private、protected 继承无效。

向上类型转换（派生类到基类）可以由编译器自动完成，是一种隐式类型转换。凡是接受基类对象、引用、指针的地方（如函数参数），都可以使用派生类对象、引用、指针，编译器会自动将派生类对象转换为基类对象以便使用。

不允许非 `public` 继承的向上转换

#include <iostream>
using namespace std;
class Base {
private:
 int data {0};
public:
 int getData() { return data; }
 void setData(int i) { data = i; }
};

class Derive1: private Base {
public:
 using Base::getData;
};

int main() {
 Derive1 d1;
 cout << d1.getData();
 Base& b = d1; // 不允许私有继承的向上转换
 b.setData(10); // 否则可以绕过 D1，调用基类的 setData 函数
 return 0;
}

/*
output:
error: cannot cast 'Derive1' to its private base class 'Base'
Base& b = d1;
*/

如果 private 继承也可以向上转换，那么基类对象里的 public 成员也可以被派生类调用了。而 private 继承的原意就是让基类成员在派生类里变成 private 属性，所以 private 继承不能向上转换。

例子

#include <iostream>
using namespace std;
class Base {
public:
 void print() { cout << "Base::print()" << endl; }
};

class Derive: public Base {
public:
 void print() { cout << "Derive::print()" << endl; }
};

void fun(Base obj) { obj.print(); } // 调用 Base 对象的 print

int main() {
 Derive d;
 d.print(); 
 fun(d); // 本意希望对 Derive::print 调用
 return 0;
}

/*
output:
Derive::print()
Base::print()
*/

派生类会覆盖掉基类的同名函数，未发生切片前，想要让派生类使用基类的 print，方法一是使用 using 关键字，方法二是启用命名空间。

多态与模板

Mon, 01 Jan 0001 00:00:00 +0000

多态与模板

抽象类与纯虚函数

定义

虚函数还可以进一步声明为纯虚函数，只要包含有一个纯虚函数的类，即为“抽象类”。语法为函数最后加上 = 0。

需要注意，抽象类不允许定义对象。

定义基类为抽象类，主要用途是为派生类规定共性“接口”。此外，抽象类的定义能避免赋值型对象切片，保证只有指针和引用能被向上类型转换（因为抽象类无法定义对象，但是可以有指针和引用指向它）。

例如：

class A {
public:
	virtual void f() = 0; // 可在类外定义函数体提供默认实现。派生类通过 A::f() 调用
};
A obj; // 不准抽象类定义对象！编译不通过！

以及更为具体的例子：

#include <iostream>
using namespace std;

class Pet { 
public: 
	virtual void motion() = 0;
};
void Pet::motion() { cout << "Pet motion: " << endl; }

class Dog: public Pet { 
public: 
 void motion() override {
 Pet::motion();
 cout << "dog run" << endl;
 } 
}; // 重写覆盖后，也可以通过如 d1.Base::foo() 来调用基类函数

class Bird: public Pet {
public: 
	void motion() override {
 Pet::motion();
 cout << "bird fly" << endl;
 } 
};

int main() {
 Pet* p = new Dog; // 向上类型转换
 p->motion();
 p = new Bird; // 向上类型转换
 p->motion();
 // p = new Pet; // 不允许定义抽象类对象
 return 0;
}

/*
output:
Pet motion: 
dog run
Pet motion: 
bird fly
*/

注意到先前有提到过，重写覆盖 override 与重写隐藏 redefining 相似，也可以通过如 d1.Base::foo() 来调用基类函数。此例中虽然发生了重写覆盖，但是通过直接调用 Pet::motion() 来调用了基类函数。

模板进阶与 STL 入门

Mon, 01 Jan 0001 00:00:00 +0000

模板进阶与 STL 入门

命名空间

定义

为了避免在大规模程序的设计中，以及在程序员使用各种各样的 C++ 库时，标识符的命名发生冲突，标准 C++ 引入了关键字 namespace（命名空间），可以更好地控制标识符的作用域。

标准 C++ 库（不包括标准 C 库）中所包含的所有内容（包括常量、变量、结构、类和函数等）都被定义在命名空间 std（即标准命名空间）中。例如：cout、cin、vector、set、map。

也就是说，namespace 本身是一种关键字，这就是所谓的命名空间，而 std 仅仅是已经被定义的一个命名空间。

例子

自定义命名空间

namespace A {
 int x, y;
}

使用命名空间

A::x = 3;
A::y = 6;
// 对人为定义的命名空间 A 内的 x、y 进行赋值

`using` 申明

使用 using 声明简化命名空间使用。

// 使用整个命名空间：所有成员都直接可用
using namespace A;
x = 3;
y = 6;

以及：

// 使用部分成员：所选成员可直接使用
using A::x;
x = 3; A::y = 6;

任何情况下，都不应出现命名冲突。

STL 初步

定义

标准模板库（英文：Standard Template Library，缩写：STL），是一个高效的 C++ 软件库，它被容纳于 C++ 标准程序库 C++ Standard Library 中。其中包含4个组件，分别为算法、容器、函数、迭代器。这些都是基于模板编写而成。

关键理念：将“在数据上执行的操作”与“要执行操作的数据”分离。

STL 的命名空间是 std，一般使用 std::name 来使用 STL 的函数或对象，也可以使用 using namespace std 来引入 STL 的命名空间。

STL 与字符串处理

Mon, 01 Jan 0001 00:00:00 +0000

STL 和字符串处理

`string` 字符串类

STL 为我们提供了方便的 string 类型：

允许简洁的拼接操作

string fullname = firstname + " " + lastname;

也能够使用惯用的输入输出方法

std::cout << fullname << std::endl;

构造方式

string s0("Initial string"); // 从 C 风格字符串构造
string s1; // 默认空字符串
string s2(s0, 8, 3); // 截取，index 从 8 开始，长度为 3
string s3("Another character sequence", 12); // 截取
string s4(10, 'x');	// 复制字符
string s5(s0.begin(), s0.begin() + 7); // 复制截取
str.c_str(); // 转换为 C 风格字符串

迭代器

// 方式一
#include <string>
#include <iostream>
int main() {
 std::string sample = "Kanashi koto wa kitto owaru darou";
 for (auto it = sample.begin(); it != sample.end(); it++) {
 std::cout << *it << std::endl;
 }
 return 0;
}

// 方式二
for (char c: sample) {
 std::cout << c << std::endl;
}

常见函数

cout << str[1]; // 访问元素
str[1] = 'a'; // 修改元素
str.size() // 查询长度
str.clear() // 清空 
str.empty() // 查询是否为空
str.push_back('a');
str.append(s2); // 向尾部增加

// 直接按照字典序来比较
string a = "alice", b = "bob";
a == b // false
a < b // true

类型转换

// 数值类型字符串化
to_string(1); // "1"
to_string(3.14); // "3.14"
to_string(3.1415926); // "3.141593"，注意精度损失
to_string(1 + 2 + 3); // "6"

// 字符串转数值类型
int a = stoi("2001"); // a = 2001
std::string::size_type sz; // size_t alias
int b = stoi("50 cats", &sz); // b = 50 sz = 2
int c = stoi("40c3", nullptr, 16); // c = 0x40c3，十六进制
int d = stoi("0x7f", nullptr, 0); // d = 0x7f，自动检查进制
double e = stod("34.5"); // e = 34.5

std::string 和 std::vector<char> 的区别

函数对象和智能指针

Mon, 01 Jan 0001 00:00:00 +0000

函数对象和智能指针

函数对象

什么是函数指针

函数本质上存在于代码段，因此，每个函数在代码段中，也有着自己的入口地址。

函数指针是一个指针类型的变量。它指向代码段中函数入口的地址。

函数指针的声明

声明格式如下：

ret (*func)(args, ...);

其中，ret 是函数指针指向的函数的返回类型，func 是该指针的名字，而 args, ... 是该指针指向的函数的参数列表。

也就是说，这个名为 func 的指针只能指向返回值类型、参数类型都相同的那些函数。

函数指针由于返回值、参数不同而有很多种类型。每种类型只能指向特定的一些函数。

由于函数的类型比较难写，常常用 auto 关键字推断函数指针类型，直接令函数指针等于某一函数名。注意如果用 auto，在对函数指针声明的同时必须对其初始化，否则编译器无法自动推导指针类型。例如：

#include <iostream>
int arr[5] = {5, 2, 3, 1, 7};
void increase(int &x) { x++; }
void decrease(int &x) { x--; }
int main() {
 int flag; 
 std::cin >> flag;

 auto func = flag == 1 ? increase : decrease;
 for (int &x: arr) {
 func(x);
 cout << x;
 }
 return 0;
}

函数指针的初始化

给你一个函数，怎么让一个指针指向它呢？

与数组类似，在数组中，数组名就是该数组的首地址，函数也是一样，函数名就是该函数的入口地址，因此，函数名就是该函数的函数指针。也就是说，函数名 A 是个指针，该指针指向的内存空间和储存该指针的内存空间是同一块，就是储存该函数的内存空间的头部位置。但是如果用别的指针 B 指向了函数，那么储存 B 的内存空间和 B 指向的元素的内存空间不是同一块。

#include <iostream>
using namespace std;
void func() { }

int main() {
 int arrow[10];
 auto p = func;
 cout << arrow << endl;
 cout << &arrow << endl;
 cout << func << endl;
 cout << &func << endl;
 cout << p << endl;
 cout << &p << endl;
}

/*
output:
0x7fff7a33d6b0
0x7fff7a33d6b0
1
1
1
0x7fff7a33d6a8
*/

函数指针的用途

函数指针主要有两个用途：做函数的参数、调用函数。

设计模式与行为型模式

Mon, 01 Jan 0001 00:00:00 +0000

设计模式与行为型模式

设计模式是在长时间实践中，开发人员总结出的优秀架构与解决方案。学习设计模式将有助于经验不足的开发人员在实际开发中，灵活地运用面向对象特性，并能够快速构建不同场景下的程序框架，写出优质代码。

设计模式分类

行为型模式：关注对象行为功能上的抽象，从而提升对象在行为功能上的可拓展性，能以最少的代码变动完成功能的增减。
结构型模式：关注对象之间结构关系上的抽象，从而提升对象结构的可维护性、代码的健壮性，能在结构层面上尽可能的解耦合。
创建型模式

本章内容主要探讨设计模式中的行为型模式。

行为型模式分类

本章介绍三种行为型模式。

模版方法模式
策略模式
迭代器模式

模版方法 Template Method

模版方法是一种针对接口编程的设计。

模版方法的思想是，基类是一个模板（也可以称作原型）。基类体现的是“抽象概念”，里面定义若干个纯虚函数，这些函数提供了这个类的“接口”。

比如，如果一个操作有 operation1、operation2 两个步骤，我们可以定义一个基类：

class AbstractClass {
public:
 virtual void Operation1() = 0;
 virtual void Operation2() = 0;
};

这个操作可能有很多个版本。每个版本的实现细节不同。比如，AbstractClass 可能是“监视计算机节点的负载状态”的过程，Operation1 是“得到总内存”，Operation2 是“得到已占用内存”。而这两种操作在不同的环境下，比如 Win32 和 Win64 下可能是不同的。这些不同的细节则由子类负责实现。

在使用时，抽象类的算法骨架提供了大致方法，再由这个方法来根据需要调用具体类的实现细节。比如：

class ConcreteClassA: public AbstractClass {
 void Operation1() {
 cout << "Do Operation 1 of A" << endl;
 }
 void Operation2() {
 cout << "Do Operation 2 of A" << endl;
 }
};

这样当我们要拓展一种新的实现类时，重新对基类进行继承与实现即可，无需对已有的实现类进行修改。

由模板实现多态

现在我们有了很多继承自同一个抽象类的实现类，该怎么实现多态呢？

我们知道，模板多态是依赖于指针和引用的。编译器能够通过指针和引用判断实际指向的类型，并且调用实际类型里面 override 了的虚函数。所以在使用模板模式的时候，常常创建基类指针来调用实现类的函数。

例：

#include <iostream>
using namespace std;

class AbstractClass {
public:
 virtual void Operation1() = 0;
 virtual void Operation2() = 0;
};

class ConcreteClassA: public AbstractClass {
public:
 void Operation1() {
 cout << "Do Operation 1 of A" << endl;
 }
 void Operation2() {
 cout << "Do Operation 2 of A" << endl;
 }
};

class ConcreteClassB: public AbstractClass {
public:
 void Operation1() {
 cout << "Do Operation 1 of B" << endl;
 }
 void Operation2() {
 cout << "Do Operation 2 of B" << endl;
 }
};

int main() {
 AbstractClass *abstract;
 abstract = new ConcreteClassB();
 abstract->Operation1();
 abstract->Operation2();
 return 0;
}

策略模式 Strategy Method

模板模式中，每个实现类里面可能有多个功能（比如 Operation1、Operation2 等）。可能有两个类，它们各有 $N$ 个功能，其中只有一个的实现有区别。在模板模式下，我们却必须实现两个类。这就很麻烦。

C++ 语言面向对象 on ClearSec Wiki

编程环境

编程环境

源程序的结构与预编译

源程序的结构

预编译指令

C++ 语言函数进阶

C++ 语言函数进阶

函数重载

定义与意义

区别方法

自动类型转换

C++ 类语法初步

C++ 类语法初步

访问权限

构造函数与析构函数

构造函数

C++ 类语法进阶

C++ 类语法进阶

变量与静态变量

四类变量的区别

静态变量

引用与复制

引用与复制

常量引用

常量引用的意义

拷贝构造函数

定义与语法规则

调用时机

隐式拷贝构造函数

执行顺序

组合与继承

组合与继承

组合

定义

两种实现方式

公有成员

私有成员

public 接口访问 private 数据

虚函数

虚函数

向上类型转换

定义

不允许非 public 继承的向上转换

例子

多态与模板

多态与模板

抽象类与纯虚函数

定义

模板进阶与 STL 入门

模板进阶与 STL 入门

命名空间

定义

例子

自定义命名空间

使用命名空间

using 申明

STL 初步

定义

STL 与字符串处理

STL 和字符串处理

string 字符串类

函数对象和智能指针

函数对象和智能指针

函数对象

什么是函数指针

函数指针的声明

函数指针的初始化

函数指针的用途

设计模式与行为型模式

设计模式与行为型模式

设计模式分类

行为型模式分类

模版方法 Template Method

由模板实现多态

策略模式 Strategy Method

`public` 接口访问 `private` 数据

不允许非 `public` 继承的向上转换

`using` 申明

`string` 字符串类