带有 c++11 模板函数名称的可变参数模板

Question

在this 问题之后，我试图避免复制粘贴一些与调用BaseSensor 类的所有同名方法相关的代码。

在sensor.hpp中

struct EdgeSensor //a mixin
{
    void update(){}
    void printStats() {}
};

struct TrendSensor //another mixin
{
    void update(){}
    void printStats() {}
};

template<typename ... SensorType>
class BaseSensor : public SensorType ... //to my BaseSensor class
{
    void update() /*{ what goes in here??? }*/
    void printStats() /*{ what goes in here??? }*/
};

在sensor.t.hpp中

template<typename ... SensorType>
void BaseSensor<SensorType...>::update()
{
    int arr[] = { (SensorType::update(), 0)..., 0 };
    (void)arr;
}

template<typename ... SensorType>
void BaseSensor<SensorType...>::printStats()
{
    int arr[] = { (SensorType::printStats(), 0)..., 0 };
    (void)arr;
}

在 main.cpp 中

int main(int , const char **) 
{
    {
        BaseSensor<EdgeSensor,TrendSensor> ets;
        ets.update();
        ets.printStats();
    }
    {
        BaseSensor<EdgeSensor> ets;
        ets.update();
        ets.printStats();
    }
}

上面的代码依次执行所有mixin的update()，然后继续执行所有mixin的所有printStats()。

我想知道是否有可能避免重复执行 BaseSensor::update() 和 BaseSensor::printStats() 并创建一个通用（模板）函数，该函数接受目标函数的名称以在所有 mixins 中执行：

例如，我可以创建一个方法runAll()

template<typename ... SensorType>
class BaseSensor : public SensorType ... //to my BaseSensor class
{
    void update() /*{ what goes in here??? }*/
    void printStats() /*{ what goes in here??? }*/

    template<typename FnName>
    void runAll(FnName f)
    {
        int arr[] = { (SensorType::f(), 0)..., 0 };
        (void)arr;
    }
};

我将如何从BaseSensor::update() 和BaseSensor::printStats() 调用它。我尝试过使用

void update() { runAll<update>(); }
void printStats() { runAll<printStats>(); }

但这不起作用（没想到会这样）。将函数名称作为函数参数传递的问题（我看到许多其他问题，例如here 是我不知道如何从BaseSensor::update() 指向各种::update() 函数。例如

void update() { runAll<update>( update() ); }

也不正确。

在这种情况下是否可以避免复制？这可以在单行中完成，以避免使用 c++11 进行大量复制（即不使用通用 lambda，就像 here 所做的那样）？如果我将工作的runAll() 移动到文件“sensor.t.hpp”中，模板参数会是什么样子？

谢谢。

Answer 1

只要要调用的函数是两个，就可以使用专用结构，依靠重载来解决。
它遵循一个最小的工作示例：

#include<iostream>

struct Executor {
    template<typename T>
    static void execute(int, T &t) {
        t.update();
    }

    template<typename T>
    static void execute(char, T &t) {
        t.printStats();
    }
};

struct EdgeSensor
{
    void update() { std::cout << "EdgeSensor::update" << std::endl; }
    void printStats() { std::cout << "EdgeSensor::printStats" << std::endl; }
};

struct TrendSensor
{
    void update() { std::cout << "TrendSensor::update" << std::endl; }
    void printStats() { std::cout << "TrendSensor::printStats" << std::endl; }
};

template<typename ... SensorType>
class BaseSensor : public SensorType ...
{
    template<typename T>
    void execute() {
        int arr[] = { (Executor::execute(T{}, static_cast<SensorType&>(*this)), 0)..., 0 };
        (void)arr;
    }

public:
    void update() {
        execute<int>();
    }

    void printStats() {
        execute<char>();
    }
};

int main() {
    BaseSensor<EdgeSensor,TrendSensor> ets;
    ets.update();
    ets.printStats();
}

如果您有两个以上的函数要调用，我想choice 技巧在这里很适用。

Answer 2

您仍然可以手动编写通用 lambda 的（简化版本）：

void update() {
    execute([](auto &t) { t.update(); });
}

变成这样

void update() {
    struct {
        template <typename T>
        void operator () (T& t) const { t.update(); }
    } updater;
    execute(updater);
}