-1

这是一个有点标准的链表练习。我有一个函数，它接受另一个函数并遍历列表，特别是_node_loop. 为什么我使用的语法有效？我还没有看到看起来像的函数指针语法。

为了方便测试，包含完整的代码，但我的问题是专门关于函数_node_loop、_del_node和_print_node.

#include<stddef.h>
#include <iostream>

template <class T>
class Node {
public:
    T value;
    Node<T>* next;
    Node(T value_, Node<T>* next_) : value(value_), next(next_) {}
    Node(T value_) : value(value_), next(NULL) {}
};



using namespace std;

template <class T>
class List {
public:
    List() : head(NULL) {}

    void prepend(T val) {
        Node<T>* node_ptr = new Node<T>(val, head);
        head = node_ptr;
    }

    void print() {
        cout << "[";
        _node_loop(_print_node);
        cout << "]" << endl;
    }

    ~List() {
        _node_loop(_del_node);
    }

    static List<T> from_array(T tarray[], int N) {
        List<T> ls = List<T>();
        for (int i = 0; i < N; i++) {
            ls.prepend(tarray[i]);
        }
        return ls;
    }

private:
    Node<T>* head;

    void _node_loop(void kernel(Node<T>*)) {
        Node<T>* node_ptr = head;
        Node<T>* tmp;
        while (node_ptr != NULL) {
            tmp = node_ptr;
            node_ptr = node_ptr->next;
            kernel(tmp);
        }
    }

    static void _print_node(Node<T>* node_ptr) {
        if (node_ptr->next == NULL) {
            cout << node_ptr->value;
        }
        else {
            cout << node_ptr->value << ", ";
        }
    }

    static void _del_node(Node<T>* node_ptr) {
        delete node_ptr;
    }
};



int main() {
    int my_array[] = {1, 2, 3, 4, 5};
    List<int> my_list = List<int>::from_array(my_array, 5);
    my_list.print();
    return 0;
}
4

1 回答 1

1

我将对我所做的评论进行一些扩展。

这里发生了什么事？

解析函数声明后直接调整（或衰减）函数参数类型：

  • 数组some_type调整为指向的指针some_type
  • 函数返回some_type调整为指向函数返回的指针some_type
  • 顶级cv 限定符被删除（例如int const-> int）

见[dcl.fct]/5；函数类型的参数被保留，即指向函数的指针包含与原始函数类型相同的参数。

这种调整只发生在函数参数类型中。它反映了一些可应用于表达式的隐式转换：

  • 的（左值）数组some_type可以转换为指向 的指针some_type，指向数组的第一个元素（“数组到指针的转换”，[conv.array]）
  • （左值）函数返回some_type可以转换为指向函数返回some_type的指针（“函数到指针转换”，[conv.func]）
  • 资格转换，例如 fromint到const int[conv.qual]

关于函数类型

函数类型与函数指针类型不同，但两者的关系类似于数组和指针。例如，您可以使用函数类型声明（但不定义）函数：

typedef void my_function_type(int, double);

my_function_type f0;  // declare the function `void f0(int, double)`
my_function_type f1;  // declare the function `void f1(int, double)`

int main()
{
    f0(42, 1.2);
    f1(42, 1.2);
}

#include <iostream>
void f0(int, double) { std::cout << "f0\n"; }

// illegal:
//my_function_type f1 { std::cout << "f1\n"; }

void f1(int, double) { std::cout << "f1\n"; }

您可以使用函数类型获得函数的引用和指针：

my_function_type& my_ref = f0;
my_function_type* my_ptr = f1;

在最后一行中，使用了函数到指针的转换。它相当于：

my_function_type* my_ptr = &f1;

调用函数指针不需要使用一元*。这是语法糖，因为它的含义是明确的，例如

my_ptr(42, 3.14);

因此，以下所有内容均有效：

my_ptr(42, 3.14);
(*my_ptr)(42, 3.14);
my_ref(42, 3.14);
f0(42, 3.14);

NB ()（函数调用）的优先级高于 unary *，因此*my_ptr需要用括号括起来。

由于一元*需要指针类型，您可以添加任意数量*，请参阅为什么所有这些疯狂的函数指针定义都有效？到底发生了什么？

应用于 OP 的示例

void _node_loop(void kernel(Node<T>*));

这个名为的成员函数_node_loop返回void并接受一个类型为 的参数void(Node<T>*)。这个参数类型被调整为void (*) (Node<T>*)，所以 的声明_node_loop相当于：

void _node_loop(void (*kernel)(Node<T>*));

在这个函数内部，kernel使用了参数：

kernel(tmp);

我们可以通过函数指针调用函数，而无需使用*. 但我们可以更明确（我不推荐）：

(*kernel)(tmp);
于 2013-11-03T14:18:44.217 回答