C++指针（四）万字图文详解！


#include <bits/stdc++.h>
using namespace std;
void te()
{
	printf("hello!\n");
}
int main()
{
	printf("%p\n", te);
	printf("%p\n", &te);
	return 0;
}

输出结果：

函数地址：函数名、&函数名

可要储存怎么办呢？别急，接下来我们要讲的函数指针就是用来存储函数的地址的。

1.1函数指针的概念

函数指针是指可以指向函数的变量。它存储了函数的地址，可以通过函数指针调用对应的函数。在C和C++等编程语言中，函数被编译为一段机器码，该机器码位于内存的某个地址上。函数指针就是存储这个地址的变量，它允许我们通过指针来直接调用对应的函数。

1.2函数指针的作用

函数指针可以用于以下几个方面：

1.回调函数：当一个函数需要在某个事件发生时调用另一个函数时，可以使用函数指针来实现回调函数。比如，当一个操作完成时，可以调用预先设置的回调函数来处理操作结果。
2.排序和搜索算法：函数指针可以用于排序和搜索算法中，通过传递一个比较函数给算法，实现不同的排序顺序或搜索条件。
3.动态库加载：函数指针可以用于加载动态库中的函数。通过函数指针，可以在运行时动态地加载和使用库中的函数。
4.多态性：函数指针可以用于实现多态性，允许在运行时确定要调用的具体函数。

总而言之，函数指针可以增强程序的灵活性，使其能够根据特定的条件或需求选择不同的函数进行调用。这在设计可扩展和可重用的代码时非常有用。

1.3函数指针的使用

1.3.1定义

在C++中，可以通过以下两种方式定义函数指针：

1.使用typedef关键字定义函数指针类型，然后使用该类型定义函数指针变量。例如：

复制代码

typedef void (*FuncPtr)(int);  // 定义函数指针类型
FuncPtr fnPtr;  // 定义函数指针变量

2.直接使用函数指针的语法定义函数指针变量。例如：

cpp 复制代码

void (*fnPtr)(int);  // 定义函数指针变量

3.使用using关键字来定义。例如：

复制代码

using FnPtr = void (*)(int);  // 定义函数指针类型FnPtr

以上三种方式都定义了一个指向形参为int类型，返回类型为void的函数指针。

注：这里我们需要加上两个括号，它们表示fnPtr是一个函数指针变量，指向一个参数为int类型的函数。

1.3.2初始化

关于函数指针的初始化，我们可以直接赋值给一个已有函数的地址。例如：

cpp 复制代码

void myFunction(int x) {
    // 函数体
}

void (*fnPtr)(int);  // 定义函数指针变量

fnPtr = &myFunction;  // 将myFunction函数的地址赋值给fnPtr

在C++中，可以使用取地址运算符&来获取函数的地址，也可以省略取址运算符直接赋值给函数指针变量。另外，使用using关键字定义的函数指针类型可以提高代码的可读性。

对了，在输出函数指针时需要注意，在C++中，函数指针的打印输出不会直接显示函数的地址 ，而是显示为1。**因为C++中的函数指针是一种可调用类型，可以像函数一样进行调用，因此在进行输出时，函数指针会被隐式地转换为一个bool值，而非函数的内存地址。**如果想要获得函数的地址，可以使用reinterpret_cast将函数指针转换为void*类型，然后进行打印输出。如下所示：
cpp 复制代码
cout << reinterpret_cast<void*>(fnPtr) << endl;  // 输出函数指针fnPtr所指向的函数的地址
这样，我们将得到正确的函数地址的输出。

接下来，我们就可以输出函数的地址了！如下：

1.3.2调用函数

我们可以通过函数指针直接调用相应的函数。例如，假设有一个函数指针fnPtr，可以使用(*fnPtr)(参数列表)的方式调用函数。

cpp 复制代码

void myFunction(int x) {
    // 函数体
}

int main() {
    void (*fnPtr)(int) = myFunction;  // 定义函数指针并初始化

    // 调用函数
    (*fnPtr)(10);

    return 0;
}

1.3.3比较函数指针

我们可以使用函数指针进行比较操作，判断两个函数指针是否相等。函数指针相等表示两个函数指向同一个函数。

cpp 复制代码

#include<bits/stdc++.h>
using namespace std;

void myFunction1(int x) {
    // 函数体
}

void myFunction2(int x) {
    // 函数体
}

int main() {
    void (*fnPtr1)(int) = myFunction1;  // 定义函数指针1并初始化
    void (*fnPtr2)(int) = myFunction2;  // 定义函数指针2并初始化

    // 比较函数指针
    if (fnPtr1 == fnPtr2) {
        cout<<"ok"<<endl;
    } else {
        cout<<"no"<<endl;
    }
    
cout << reinterpret_cast<void*>(fnPtr1) << endl;// 输出函数指针fnPtr所指向的函数的地址
cout << reinterpret_cast<void*>(fnPtr2) << endl; // 输出函数指针fnPtr所指向的函数的地址



    return 0;
}

结果：

1.4函数指针的练习

题目：编写一个程序，计算三角形的面积。利用函数指针来选择计算面积的方法。

步骤：

声明一个函数指针，指向一个计算面积的函数。
编写一个计算面积的函数，该函数接受三个参数表示三角形的边长，并返回计算得到的面积。
编写第二个计算面积的函数，该函数接受两个参数表示三角形的底和高，并返回计算得到的面积。
编写主函数，在其中通过用户输入选择计算面积的方法。
在主函数中，根据用户选择的方法，使用函数指针调用相应的计算面积的函数，并输出结果。

知识点：

函数指针的声明和使用。
函数的定义和调用。
3. 三角形面积的计算方法。

三角形面积的计算方法有两种，一个是三边法，采用的是海伦公式，另一个是底高法，也就是公式面积=底*高/2。

流程图：

复制代码

开始
声明函数指针
定义计算面积函数1
定义计算面积函数2
接收用户输入选择方法
根据选择使用函数指针调用相应函数
输出结果
结束

代码：

cpp 复制代码

#include <iostream>

using namespace std;

// 声明函数指针
typedef double (*AreaFunc)(double, double);

// 计算面积的函数1：三边法
double calcAreaBySide(double a, double b, double c) {
    double s = (a + b + c) / 2;
    return sqrt(s * (s - a) * (s - b) * (s - c));
}

// 计算面积的函数2：底高法
double calcAreaByBaseHeight(double base, double height) {
    return 0.5 * base * height;
}

int main() {
    int choice;
    double a, b, c, base, height;
    AreaFunc areaFunc;

    cout<<"选择方法："<<endl;
    cin >> choice;

    switch (choice) {
        case 1:
            areaFunc = calcAreaBySide;
            cout << "三角形的三边长度：" << endl;
            cin >> a >> b >> c;
            cout << "三角形的面积为：" << areaFunc(a, b, c) << endl;
            break;
        case 2:
            areaFunc = calcAreaByBaseHeight;
            cout << "三角形的底和高：" << endl;
            cin >> base >> height;
            cout << "三角形的面积为：" << areaFunc(base, height) << endl;
            break;
        default:
            cout << "无效" << endl;
            break;
    }

    return 0;
}

本示例中，通过函数指针 AreaFunc 来选择使用不同的计算面积的函数。用户可以通过输入选择三边法或底高法来计算三角形的面积，程序会根据选择来调用相应的计算函数并输出结果。

2.函数指针数组

既然有函数指针，那肯定也有函数指针数组啦！函数指针数组是一个数组，每个成员都是一个函数指针。

2.1函数指针数组的作用

函数指针数组的作用主要有以下几个方面：

调用不同的函数：函数指针数组可以存储多个函数的指针，通过数组的索引可以选择调用不同的函数。这样可以在运行时根据需要动态地选择不同的函数来执行特定的操作。

函数回调：函数指针数组可以用于实现函数回调的机制。回调函数是指在特定的条件或事件发生时，通过函数指针来调用事先定义好的函数。通过函数指针数组，可以在需要的时候选择合适的回调函数进行调用。

状态机：函数指针数组可以用于实现状态机的机制。状态机是一种表示状态和状态转换的模型，通过函数指针数组可以将每个状态定义为一个函数，使用数组索引进行状态转换。

函数指针数组作为参数传递：函数指针数组可以作为参数传递给其他函数，以便在函数内部使用。这样可以将一组相关的函数作为整体传递，方便对这组函数进行统一的操作或处理。

总之，函数指针数组提供了一种灵活、动态和可扩展的方式来管理和调用函数，使得程序可以根据需要选择不同的函数进行执行，增强了程序的灵活性和可维护性。

2.2函数指针数组的使用

在C++中，函数指针数组的操作与C类似，但可以使用更具有面向对象特性的方式。

2.2.1 定义

使用typedef关键字可以简化函数指针类型的定义，使代码更具可读性。

cpp 复制代码

typedef void (*FuncPtr)(int);  // 定义函数指针类型

FuncPtr func_ptr_array[N];  // 定义大小为N的函数指针数组

2.2.2 初始化

可以直接在定义函数指针数组时给出初始值，或通过循环赋值操作为数组元素赋予特定的函数指针。这里介绍在定义函数指针数组时给出初始值和数组元素赋予特定的函数指针这两种方法。

cpp 复制代码

void func1(int);
void func2(int);

FuncPtr func_ptr_array[] = {func1, func2};  // 初始化函数指针数组

func_ptr_array[0] = func1;  // 为函数指针数组赋值
func_ptr_array[1] = func2;

2.2.3 调用

这里我们可以使用数组的索引来选择并调用函数指针数组中的函数。

cpp 复制代码

int index = 0;//索引
func_ptr_array[index](10);  // 调用函数指针数组中索引为0的函数，并传入参数10

2.2.4 传参

这里同样可以将函数指针数组作为参数传递给其他函数，在函数内部使用。

cpp 复制代码

void process_func_array(FuncPtr array[], int size) {
    //函数体......
}

process_func_array(func_ptr_array, 2);  // 将函数指针数组作为参数传递给函数

在C++中，可以使用函数指针数组来实现更加灵活的函数回调机制、策略模式等。此外，C++还提供了更强大的工具，如函数对象、Lambda表达式等，可以替代函数指针数组，在处理函数选择和回调方面更加方便和易用。

2.3函数指针二维数组

函数指针二维数组用于存储多个函数指针，每个函数指针可以指向一个函数。它的定义和使用方式与普通二维数组类似，只是数组元素是函数指针。

函数指针二维数组的定义如下：

cpp 复制代码

typedef returnType (*functionName)(parameter1, parameter2, ...);

functionName arrayName[rowSize][colSize];

其中，returnType 是函数的返回类型，functionName 是函数指针类型的名称，parameter1, parameter2, ... 是函数的参数列表。arrayName 是函数指针二维数组的名称，rowSize 是数组的行数，colSize 是数组的列数。

2.4函数指针数组的练习

题目：编写一个程序，根据输入的年份判断是否为闰年。

步骤：

定义一个函数指针数组，用于存储判断闰年的函数地址。
定义多个判断闰年的函数，如根据公历规则判断、根据儒略历规则判断等。
在主函数中，输入一个年份。
遍历函数指针数组，依次调用判断闰年的函数，并将输入的年份作为参数传递给该函数。
根据函数的返回结果判断是否为闰年，如果是则输出"该年份是闰年"，否则输出"该年份不是闰年"。

知识点：

函数指针数组的定义和使用。
根据输入的年份调用对应的判断闰年函数。
函数的参数传递和返回值。

流程图：

cpp 复制代码

输入一个年份
 |
V
遍历函数指针数组
 |
V
调用判断闰年的函数，将年份作为参数传递
 |
V
根据返回结果判断是否为闰年
 |
V
输出结果

代码：

在运行时，程序会要求输入一个年份，然后遍历函数指针数组，依次调用判

cpp 复制代码

#include <iostream>

typedef bool (*leapYearChecker)(int); // 定义函数指针类型

// 根据公历规则判断是否为闰年
bool isLeapYearByGregorian(int year) {
    if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
        return true;
    } else {
        return false;
    }
}

// 根据儒略历规则判断是否为闰年
bool isLeapYearByJulian(int year) {
    if (year % 4 == 0) {
        return true;
    } else {
        return false;
    }
}

int main() {
    int year;
    
    std::cout << "请输入一个年份：";
    std::cin >> year;
    
    leapYearChecker leapYearCheckers[] = {isLeapYearByGregorian, isLeapYearByJulian}; // 函数指针数组
    
    int numCheckers = sizeof(leapYearCheckers) / sizeof(leapYearCheckers[0]); // 计算数组长度
    
    bool isLeapYear = false;
    
    for (int i = 0; i < numCheckers; i++) {
        isLeapYear = leapYearCheckers[i](year); // 调用判断闰年的函数
        
        if (isLeapYear) {
            std::cout << "该年份是闰年" << std::endl;
            break;
        }
    }
    
    if (!isLeapYear) {
        std::cout << "该年份不是闰年" << std::endl;
    }
    
    return 0;
}

断闰年的函数，并将输入的年份作为参数传递给该函数。根据函数的返回结果判断是否为闰年，并输出相应的结果。

3.回调函数与回调指针

回调函数（callback function）是指在某个函数执行完毕后自动调用的函数。它的作用是将一个函数传递给另一个函数，以便在适当的时候被调用。

3.1回调函数的用处

回调函数的作用主要体现在以下几个方面：

1.异步操作：通过传递回调函数作为参数，可以在某个操作完成后立即执行回调函数。这样可以避免阻塞主线程，提高程序的并发性和响应性。
2.事件处理：通过注册回调函数作为事件处理函数，可以实现对事件的响应和处理。这样可以增加程序的可扩展性和可维护性。
3.抽象接口：通过回调函数，可以将具体的实现逻辑与调用逻辑分离。这样可以提高代码的复用性和可读性。

总结而言，回调函数是一种常用的编程技术，可以实现异步操作、事件处理和抽象接口等功能。它可以提高程序的灵活性和可扩展性，使程序更加模块化和可维护。

3.2回调函数的使用

回调指针的使用包括以下几个步骤：

3.2.1 定义函数原型

首先需要定义回调函数的函数原型，包括返回类型和参数列表。这个函数原型将作为回调函数的类型，后续需要定义回调指针来指向这个函数。

cpp 复制代码

// 定义回调函数的函数原型
typedef void (*CallbackFunction)(int);

3.2.2 声明变量

使用定义的回调函数类型来声明回调指针变量。回调指针变量是一个指向回调函数的指针，可以用来存储回调函数的地址。

cpp 复制代码

// 声明回调指针变量
CallbackFunction callbackPointer;

3.2.3定义

根据之前定义的函数原型，实现回调函数的具体逻辑。回调函数可以在特定事件或条件发生时被调用执行，可以在函数内部进行相应的操作。

cpp 复制代码

// 回调函数
void callbackFunction(int value) {
    std::cout << "Callback Function: " << value << std::endl;
}

// 需要回调的函数
void doSomething(int value, CallbackFunction callback) {
    std::cout << "Doing something with value: " << value << std::endl;
    // 调用回调函数
    callback(value);
}

3.2.4 地址传递

在需要使用回调函数的地方，将回调函数的地址作为参数传递给其他函数。这些函数在特定的时候可以通过回调指针调用回调函数。

cpp 复制代码

// 将回调函数的地址传递给其他函数
    callbackPointer = callbackFunction;

3.2.5调用

在需要触发回调函数的时候，通过回调指针调用回调函数。回调函数将执行其内部的逻辑操作，并返回结果或执行特定的任务。

cpp 复制代码

 // 调用需要回调的函数
    doSomething(10, callbackPointer);

3.3回调指针

回调指针（callback pointer）是指一个指针，它指向回调函数的内存地址。通过使用回调指针，可以在适当的时候调用回调函数。

3.3.1回调指针的使用

在C++中，可以通过回调指针在回调函数中调用特定的函数或方法。下面是一个代码示例：

复制代码

#include <iostream>

// 回调函数的定义
void callbackFunc(int arg) {
    std::cout << "Callback called with argument: " << arg << std::endl;
}

// 接受回调函数指针的函数
void doSomething(int data, void (*callback)(int)) {
    // 执行其他操作
    std::cout << "Doing something with data: " << data << std::endl;
    
    // 调用回调函数
    callback(data);
    
    // 执行其他操作
}

int main() {
    int data = 42;
    
    // 调用doSomething函数，并传递回调函数指针
    doSomething(data, callbackFunc);
    
    return 0;
}

在这个例子中，callbackFunc是一个回调函数，它接受一个整数参数，并在函数内部打印该参数的值。doSomething函数接受一个整数参数和一个指向回调函数的指针。它在执行其他操作后调用回调函数，将传入的数据作为参数传递给回调函数。

在main函数中，首先定义了一个整数变量data，然后调用doSomething函数，并将data和callbackFunc作为参数传递给它。

当doSomething函数执行时，它会执行一些操作，然后调用传入的回调函数指针，传递给它data`作为参数。这样，回调函数callbackFunc将被调用，并打印出传入的参数值。

通过回调指针，可以在回调函数中灵活地调用不同的函数或方法，实现不同的功能和逻辑。

3.3.2回调函数与回调指针的关系

回调函数与回调指针之间存在着紧密的关系。下面是一个简单的图表，用于说明它们之间的关系：

复制代码

        +---------------------+
        |      调用者函数       |
        +---------------------+
                 |
                 |   回调指针
                 |
        +---------------------+
        |       回调函数       |
        +---------------------+

解析：在这个图表中，调用者函数是一个函数，它需要在特定的事件或条件发生时执行某些操作。为了实现这个功能，调用者函数会定义一个回调指针，并将需要执行的回调函数的地址赋给这个指针。

回调函数是一个独立的函数，它执行实际的操作。它的原型（参数列表和返回值类型）需要与回调指针指向的函数类型相匹配。当特定事件或条件发生时，调用者函数将使用回调指针调用回调函数，从而执行所需的操作。

通过使用回调指针，调用者函数可以在运行时灵活地指定要执行的回调函数。这使得回调函数的执行可以根据具体的需求动态地确定。
总结：回调函数通过回调指针与调用者函数建立联系，实现在特定事件或条件下执行指定操作的机制，相当于"过渡"的作用。回调指针允许在运行时动态地指定回调函数，从而实现灵活性和可扩展性。

4.指针函数

指针函数是指返回指针的函数。与普通函数返回基本数据类型或对象不同，指针函数返回一个指针，该指针指向内存中的某个地址。

4.1指针函数的作用

指针函数的作用主要有以下几个方面：

1.返回动态分配的内存：指针函数可以用于动态分配内存，并返回指向该内存的指针。这样可以在函数外部使用这些动态分配的内存，并在适当的时候释放。
2.返回局部变量的地址：指针函数可以返回局部变量的地址。虽然局部变量的作用域只限于函数内部，但通过返回指针，可以在函数外部访问并修改局部变量的值。
3.返回数组、链表等数据结构：指针函数可以返回数组、链表等数据结构的指针，这样可以在函数外部通过指针访问和操作这些数据结构。
4.函数指针的使用：指针函数可以返回函数指针，即返回一个指向函数的指针。这样可以在函数外部调用不同的函数，实现程序的动态性。

4.2指针函数的操作

指针函数是一种返回指针的函数。它可以用来返回动态分配的内存、对象的指针或者函数指针。

下面是一些关于指针函数的常见操作：

4.2.1 声明

复制代码

int* myFunction();  // 返回int类型指针的指针函数

上述代码声明了一个返回int类型指针的指针函数myFunction。

4.2.2 定义

复制代码

int* myFunction() {
   int* ptr = new int(10);
   return ptr;
}

上述代码定义了一个指针函数myFunction，它动态分配了一个int类型的内存，并返回指向该内存的指针。

4.2.3 调用

复制代码

int* result = myFunction();

上述代码调用指针函数myFunction，并将返回的指针存储在result变量中。

4.2.4返回

复制代码

cout << *result << endl;  // 输出指针所指向的值
delete result;  // 释放动态分配的内存

上述代码使用指针函数返回的指针，输出指针所指向的值，并释放动态分配的内存。

4.3指针函数的练习

题目：编写一个指针函数，接受一个整数数组和数组的长度作为参数，返回一个指向数组中最大元素的指针。

步骤：

声明并定义一个指针函数，函数名为`findMax()`，参数为整数数组和数组的长度。
在函数内部，声明一个指针变量`max`，并将其初始化为指向数组的第一个元素。
使用一个循环遍历数组的每个元素：

如果当前元素大于`max`指向的值，则将`max`指向当前元素。

返回指针`max`。

知识点：

指针函数的声明和定义
指针的初始化和赋值
指针的比较

流程图：

复制代码

开始
|
声明并定义指针函数 findMax(arr, length)
|
声明并初始化指针变量 max = arr
|
循环遍历数组的每个元素
|
|   如果当前元素 > *max
|   |
|   将 max 指向当前元素
|
返回 max
|
结束

代码：

复制代码

int* findMax(int* arr, int length) {
    int* max = arr;
    for (int i = 0; i < length; i++) {
        if (arr[i] > *max) {
            max = &arr[i];
        }
    }
    return max;
}

接下来，我们就可以在main函数里直接调用这个函数啦！这个练习可以帮助你熟悉指针函数的声明、定义和使用，以及指针的操作。可以通过测试不同的数组来验证函数的正确性。记得在使用完动态分配的内存后，及时释放它们，以避免内存泄漏。

总结

本篇博客到这里就结束了，感谢大家的支持与观看，如果有好的建议欢迎留言，制作不易，如果对您有帮助，那请给PingdiGuo_guo一个免费的赞，谢谢啦！