函数指针的指针int (*(*pf())())()
目录
函数指针的指针int (*(*pf())())(){}
int (*(*pf())())() {
return nullptr;
}
详细解析
pf是一个函数，它没有参数（即它的参数列表是空白）。pf()是一个返回类型为int (*)()的函数调用。这意味着pf返回的是一个函数指针，这个指针指向的函数没有参数并返回一个int类型的值。(*pf())是对pf()返回的函数指针的解引用，它表示pf返回的那个函数。int (*(*pf())())()表示pf返回的函数指针指向的函数本身也是一个函数指针，这个指针指向的函数没有参数并返回一个int类型的值。
为了简化理解，我们可以将这个复杂的声明分解为以下几个步骤：
-
定义一个返回类型为
int (*)()的函数指针类型：typedef int (*FuncPtr)(); -
定义一个返回
FuncPtr类型的函数pf：FuncPtr pf(); -
实现
pf函数，使其返回nullptr：FuncPtr pf() { return nullptr; }
这样，整个声明就可以理解为：pf 是一个没有参数的函数，它返回一个指向没有参数且返回 int 类型的函数的指针。在这个特定的实现中，pf 返回的是 nullptr，表示它不指向任何有效的函数。
总结一下，这个声明定义了一个函数 pf，它返回一个函数指针，这个指针指向的函数没有参数并返回一个 int 类型的值。
综合解释
int (*(*pf())())()
最外层解析：int (*... )()
- 这表明我们最终有一个函数指针，这个指针指向的函数返回一个
int类型的值。 - 这个函数指针指向的函数没有显示参数（即参数列表为空），但这不一定意味着它真的没有参数，可能是在声明时省略了参数列表。
中间层解析：(*pf())
pf是一个函数名，它没有参数（因为它的括号内是空的）。pf返回一个函数指针。这个返回的函数指针指向的函数的返回类型和参数列表在这一点上还没有完全确定。
最内层解析：(*... )()
- 这里的
(*pf())表示调用pf函数，它返回一个函数指针。 - 这个返回的函数指针指向的函数本身也有返回类型和参数列表，这些在
(*pf())的括号内定义。 - 在这个例子中，
(*pf())返回的函数指针指向的函数没有参数（因为它的括号内是空的），并且返回一个int类型的值。
综合解析
将所有部分放在一起，我们可以这样理解：
pf是一个没有参数的函数。pf返回一个函数指针。- 这个返回的函数指针指向的函数也没有参数，并且返回一个
int类型的值。
所以，整个声明可以这样解读：
pf是一个函数，它返回一个函数指针。- 这个返回的函数指针指向的函数没有参数，并且返回一个
int类型的值。
下面是一个使用这种复杂函数指针声明的例子：
简单例子
#include <iostream>
#include <typeinfo>
#include <vector>
#include <forward_list>
// 定义一个返回 int 的函数
int foo() {
return 42;
}
// 定义一个返回函数指针的函数
int (*bar())() {
return foo;
}
// 定义一个返回函数指针的函数的函数
int (*(*pf_simple())())() {
return bar;
}
int main_函数指针的指针_简单() {
// 调用 pf_simple，得到一个返回函数指针的函数
auto getFuncPtr = pf_simple();
// 调用 getFuncPtr，得到一个函数指针
auto funcPtr = getFuncPtr();
// 通过函数指针调用函数
int result = funcPtr(); // 调用 foo()
std::cout << "Result: " << result << std::endl; // 输出 "Result: 42"
return 0;
}
在这个例子中：
foo是一个简单的函数，它返回整数42。bar是一个返回函数指针的函数，它返回指向foo的指针。pf是一个返回函数指针的函数的函数，它返回指向bar的指针。- 在
main函数中，我们首先调用pf得到一个返回函数指针的函数getFuncPtr，然后调用getFuncPtr得到一个指向foo的函数指针funcPtr，最后通过funcPtr调用foo函数并输出结果。
这个例子展示了如何使用复杂的函数指针声明来间接调用函数。
复杂但好理解
#include <iostream>
#include <typeinfo>
#include <vector>
#include <forward_list>
// 定义一个返回 double ,接受 std::vector<int> 类型参数的函数
double foo_complex(std::vector<int>) {
return std::acos(-1);
}
// 定义一个接受 long 类型参数的函数,返回函数指针的函数(指向函数的指针的函数)
double (*bar_complex(long))(std::vector<int>) {
return foo_complex;
}
// 定义一个接受 std::forward_list<int> 类型参数的函数,返回函数指针的函数的函数
double (*(*pf_complex(std::forward_list<int>))(long))(std::vector<int>) {
return bar_complex;
}
int main_函数指针的指针_复杂() {
// 调用 pf_complex，得到一个返回函数指针的函数
auto getFuncPtr = pf_complex(std::forward_list<int>());
// 调用 getFuncPtr，得到一个函数指针
auto funcPtr = getFuncPtr(long());
// 通过函数指针调用函数
double result = funcPtr(std::vector<int>()); // 调用 foo_complex()
std::cout << "Result: " << result << std::endl; // 输出 "Result: 3.14159"
return 0;
}
double (*(*pf_complex(std::forward_list<int>))(long))(std::vector<int>)
最外层解析：double (*... )(std::vector<int>)
这表明最终我们得到的是一个函数指针，这个指针指向的函数接受一个std::vector<int>类型的参数，并且返回一个double类型的值。这里明确显示该函数指针指向的函数参数，但并不意味着真的没有其他参数，有可能在声明时省略了部分参数列表。
中间层解析：(*pf_complex(std::forward_list<int>))
pf_complex是一个函数名，它接受一个std::forward_list<int>类型的参数。pf_complex函数返回一个函数指针。此时这个返回的函数指针指向的函数的返回类型和除了已经明确的long类型参数之外的其他参数列表在这一点上还没有完全确定（因为我们还需要进一步分析内层结构）。
最内层解析：(*... )(long)
这里的(*pf_complex(std::forward_list<int>))表示调用pf_complex函数，它会返回一个函数指针。这个返回的函数指针指向的函数本身也有返回类型和参数列表，其中明确的是这个函数接受一个long类型的参数，而其返回类型则是由外层所确定的函数指针类型（即指向接受一个std::vector<int>类型参数且返回double类型值的函数的函数指针）。
综合解析
将所有部分放在一起，我们可以这样理解：
pf_complex是一个接受std::forward_list<int>类型参数的函数。pf_complex返回一个函数指针。- 这个返回的函数指针指向的函数接受一个
long类型的参数，并且其返回值类型是一个函数指针，这个返回的函数指针指向的函数接受一个std::vector<int>类型的参数并返回一个double类型的值。
所以，整个声明可以这样解读：
pf_complex是一个函数，它接受一个std::forward_list<int>类型的参数，返回一个函数指针。这个返回的函数指针指向的函数接受一个long类型的参数，并且其返回值类型是一个函数指针，该函数指针指向的函数接受一个std::vector<int>类型的参数并返回一个double类型的值。
原文地址：https://blog.csdn.net/qq_47355554/article/details/143783706
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！