带有模板函数名的可变模板

variadic templates with template function names

本文关键字：函数      更新时间：2023-10-16

在这个问题之后，我试图避免复制粘贴一些与调用类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();
    }
}

上面的代码依次执行所有mixins的update()，然后再执行所有mixins的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>(); }

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

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

也不正确。

在这种情况下是否有可能避免复制?如果我将工作runAll()移动到文件"sensor.t.hpp"中，模板参数看起来会是什么样子?

谢谢

你可以使用一个通用的lambda和一种控制反转。
它遵循一个最小的工作示例:

#include<iostream>
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 F>
    void execute(F &&f) {
        int arr[] = { (f(static_cast<SensorType&>(*this)), 0)..., 0 };
        (void)arr;
    }
public:
    void update() {
        execute([](auto &t) { t.update(); });
    }
    void printStats() {
        execute([](auto &t) { t.printStats(); });
    }
};
int main() {
    BaseSensor<EdgeSensor,TrendSensor> ets;
    ets.update();
    ets.printStats();
}

如果你能使用c++的1z折叠表达式可能是最短的方式:

template<typename ... SensorType>
class BaseSensor : public SensorType ... //to my BaseSensor class
{
public:
    void update() { (SensorType::update(),...); }
    void printStats() { (SensorType::printStats(),...); }
};

另一种c++11方法可以使用指向方法的指针的std::array，例如:

template<typename ... SensorType>
class BaseSensor : public SensorType ... //to my BaseSensor class
{
   void runAll(std::array<void (BaseSensor::*)(), sizeof...(SensorType)>&& vs) {
      for (auto v: vs) {
         (this->*v)();
      }
   }
public:
    void update() {
       runAll({&SensorType::update...});
    }
    void printStats() {
       runAll({&SensorType::printStats...});
    }
};

下面是另一个在c++ 11中编译的更紧凑的解决方案:

#include <type_traits>
#include <iostream>
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 <void(SensorType::* ...M)()>
    void run() {
        int arr[] = { 0, ((this->*M)(), 0)... };
        (void)arr;
    }
public:   
    void update() {   
        run<&SensorType::update...>();
    }
    void printStats() {
        run<&SensorType::printStats...>();
    }
};
int main() {
    BaseSensor<EdgeSensor, TrendSensor> bs;
    bs.update();
    bs.printStats();
}

我很想说，你不需要任何结构来支持指向成员方法的指针包。
无论如何，我发现这可以用clang编译，而不能用GCC。我还在努力弄清楚代码是否格式错误，或者问题是否在编译器中。

我建议按照另一个问题来知道你是否可以使用这个代码

这是我想到的另一个纯粹的c++11答案。这个使用标签调度和非类型模板参数:

template <class T, void (T::*)()>
struct Method { };
template<typename ... SensorType>
class BaseSensor : public SensorType ... //to my BaseSensor class
{
   template <class T, void(T::*M)()>
   int runSingle(Method<T, M>) {
      (this->*M)();
      return 0;
   }
   template <class... Ts>
   void runAll() {
      int run[sizeof...(Ts)] = { runSingle(Ts{})... };
      (void)run;
   }
public:
    void update() {
       runAll<Method<SensorType, &SensorType::update>...>();
    }
    void printStats() {
       runAll<Method<SensorType, &SensorType::printStats>...>();
    }
};

必须声明的是，除了fold表达式(包括skypjack的一个)之外，这些答案都不会处理mixin类的虚拟调用方法…然而，我认为skyjack的答案可以很容易地修改，以达到这样的效果:

#include<type_traits>
// (...)
template<typename ... SensorType>
class BaseSensor : public SensorType ...
{
    template<typename F>
    void execute(F &&f) {
        int arr[] = { (f(static_cast<SensorType&>(*this)), 0)..., 0 };
        (void)arr;
    }
public:
    void update() {
        execute([](auto &t) { t.std::remove_reference<decltype(t)>::type::update(); });
    }
    void printStats() {
        execute([](auto &t) { t.std::remove_reference<decltype(t)>::type::printStats(); });
    }
};
相关文章：