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

Question

遵循这个问题，我试图避免复制粘贴与调用BaseSensor类的mixins的所有同名方法有关的一些代码。

在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()并创建一个通用的（模板）函数来接受目标函数的名称以在所有mixin中执行：

例如，我可以创建一个方法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>(); }

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

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

也不正确。

在这种情况下是否可以避免复制？ 可以单行执行此操作，以避免使用c ++ 11进行大量复制（即，不像此处那样使用通用lambda进行复制）吗？ 如果我将可运行的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);
}