Question

您可以按如下方式描述一个简单的列表：

简单列表可以包含零个或多个特定类型的项目。
您可以创建一个空列表。
您可以将项目添加到列表中。
您可以确定列表是否为空。
您可以确定列表是否已满。
您可以访问列表中的每个项目并对其执行一些操作。

如你所见，这个清单真的很简单;例如，它不允许插入或删除。设计一个List类来表示这个抽象类型。你应该提供一个list.h 带有类声明的头文件和带有类方法的list.cpp文件您应该创建一个利用您的设计的简短程序。

保持列表规范简单的主要原因是简化此编程练习。您可以将列表实现为数组，或者，如果您熟悉数据类型，作为链表。但是公共界面不应该依赖于你的选择。也就是说，公共接口不应该有数组索引，指向节点的指针，等等。它应该在创建列表，将项目添加到列表等的一般概念中表达。处理访问每个项目和执行的常用方法动作是使用一个以函数指针作为参数的函数：

void visit(void (*pf)(Item &));

这里pf指向一个引用Item的函数（不是成员函数）参数，其中Item是列表中项目的类型.visit（）函数适用此函数用于列表中的每个项目。您可以使用Stack类作为一般指南。

我想知道的是为什么我应该使用指向函数的指针？使用通常的成员函数和使用指针到函数的函数作为参数之间的区别是什么？（在这种情况下，使用void visit(void (*pf)(Item &))）？

Answer 1

功能指针

想象一下，你有一个函数，它接受一个数字并将其平方并返回它。你有一个列表，你想要平方的每个成员。你是怎么做到的？

你要么写另一个接受数组的函数，遍历它并将每个元素转换成它的正方形。
你有一个函数接受一个数组和一个可以转换单个元素的函数。您将该函数应用于数组的每个元素。

两者都执行相同的任务。您可能认为以前的案例更容易实现。毕竟你不必处理函数指针。

然而，如果您说20个函数可以是double，triple，cube，square等，那么传递给它们的单个参数会怎样。如果您遵循第一条路线，则必须编写20种不同的功能（可能有不同的名称）。然而，现在后者是有道理的。您只需声明各个功能。并通过指针传递数组和20个函数中的任何一个来调用变换器函数来实现你的任务。

一个例子是C ++ STL中的std::transform。

工作：

#include <iostream>
#include <vector>

typedef double (*function)(double);

void transformer(std::vector<double>& to_transform, function f)
{
    for(auto it = to_transform.begin(); it != to_transform.end(); ++it)
        *it = f(*it);
}

void print(const std::vector<double>& v)
{
    std::cout << "[ ";
    for(double val : v)
        std::cout << val << " ";
    std::cout << "]" ;
}

double f1(double a) { return a*2; }
double f2(double a) { return a*3; }
double f3(double a) { return a/2; }
double f4(double a) { return a*a*a; }

int main() {
    std::vector<double> array = { 2.3, 5.6, 4.5, 7.8, 2.3 };
    std::vector<function> function_ptrs = { &f1, &f2, &f3, &f4 };
    std::size_t val ;
    std::cout << "The original : " ;
    print(array);
    std::cout << "\nChoose a function (1-4) : ";
    std::cin >> val;
    std::cout << "The array after applying function " << val << " is : ";
    transformer(array, function_ptrs[(val - 1) % function_ptrs.size()]);
    print(array);
    return 0;
}

我假设你有一个符合C ++ 11标准的编译器。上面的代码有4个函数，它们采用double并以某种方式对其进行转换。 transformer函数将这样的函数应用于双精度矢量。函数指针也存储在一个向量中 - 是一个函数指针数组。可以通过索引访问函数，因为普通元素是通过索引访问的。在选择一个选项时，调用适当的函数并由transformer元素在双精度矢量上执行。

您可以使用模板（而非固定双打）和STL中的std::transform进一步改进它。

C ++ 11 Lambda表达式

另外，对于C ++ 11，你应该更喜欢lambdas而不是函数指针。 Lambdas写成

[ ... capture list ... ] ( params ) -> return_type (optional) { body }

使用lambda的解决方案是这样的：

#include <iostream>
#include <algorithm>
#include <vector>

template <typename T>
void print(const std::vector<T>& v)
{
    std::cout << "[ ";
    for(T val : v)
        std::cout << val << " ";
    std::cout << "]" ;
}

int main() {
    std::vector<double> array = { 2.3, 5.6, 4.5, 7.8, 2.3 };
    std::cout << "The original : " ;
    print(array);
    std::cout << "\nThe array after transforming : " ;
    std::transform(array.begin(), array.end(), array.begin(), 
        [](double x) { return x * x; });
    print(array);
    return 0;
}

功能对象

您可以声明自己的类，它只是重载()运算符（使对象可调用）并执行与函数指针相同的工作（可以传递给函数并调用），即在这种情况下课程看起来像：

class double_the_value
{
    double operator()(double val) const { return val * 2.0 ; }
};

double_the_value f ;
std::cout << f(3.0) ; // outputs 6.0

实际用法是std::unordered_map容器，如果你使用自己的类类型的键，你需要提供一个键哈希 - 它可以是一个函数对象。 this回答详细说明了这一点。

Answer 2

当你创建一个真正的抽象列表时，你不知道你需要在对象上调用哪些函数，所以你通常的成员函数是不够的。你不能写所有这些。

此模式的一个常见且更简单的替代方法是返回完整集合的副本或将迭代器公开给第一个和最后一个元素。但这可能会导致性能问题并且可能存在风险 - 副本可能很昂贵并且通常是不必要的，如果使用迭代器，如果集合在您下面发生变化，它们可能会变得无效。访问者模式通过为您提供更好的封装来隐藏所有这些，并将迭代循环保持在类通常所属的类中。

这是一个额外的抽象层。如果您有一组项目，通常需要对该集合中的某些（或所有）项目执行某些操作。访客模式允许您检查每个项目，然后执行某些操作。

C ++入门第6练习10.8

2 个答案: