将变量作为模板参数传递

Question

我正在使用一个库来公开一个可以使用的接口。这个库的一个功能是这样的：

template <int a>
void modify(){}

我必须修改从1到10的参数，即使用模板参数从1到10调用modify。为此，我编写了这段代码（代码的基本版本，实际代码要大得多）。

for(int i=0; i<10; i++){
    modify<i>();
}

在编译时，我收到以下错误

error: 'i' cannot appear in constant-expression

通过互联网上的一些链接后，我开始知道我不能传递任何值作为模板参数，这在编译时不会被评估。我的问题如下：1。为什么编译时无法编译评估i？ 2.还有其他任何方法可以实现我想要在不改变API接口的情况下实现的目标吗？

---

还有一件事我想做。调用修改为修改，其中VAR是某些功能计算的输出。我怎样才能做到这一点？

Answer 1

编译时i的值（不是常数）是多少？除非执行循环，否则无法回答。但执行不是“编译”因为没有答案，编译器不能这样做。

模板不是要执行的算法，而是要扩展以生成代码的宏。你可以做的是依靠专门化来通过递归来实现迭代，就像这里：

#include <iostream>

template<int i>
void modify()
{ std::cout << "modify<"<<i<<">"<< std::endl; }

template<int x, int to>
struct static_for
{
    void operator()() 
    {  modify<x>();  static_for<x+1,to>()(); }
};

template<int to>
struct static_for<to,to>
{
    void operator()() 
    {}
};


int main()
{
    static_for<0,10>()();
}

请注意，通过这样做，您实际上是实例化了名为modify<0> ... modify<9>的10个函数，分别由static_for<0,10>::operator() ... static_for<9,10>::operator()调用。

迭代结束是因为static_for<10,10>将从具有两个相同值的特化中实例化，而不执行任何操作。

Answer 2

既然您使用Boost.MPL要求答案：

#include <boost/mpl/for_each.hpp>
#include <boost/mpl/range_c.hpp>

#include <iostream>

template <int N>
void modify()
{
    std::cout << N << '\n';
}

// You need to wrap your function template in a non-template functor
struct modify_t
{
    template <typename N>
    void operator()(N)
    {
        modify<N::value>();
    }
};

int main()
{
    namespace mpl = boost::mpl;

    mpl::for_each< mpl::range_c<int,0,10> >( modify_t() ); // prints 0 to 9
}

Answer 3

1. “为什么编译时无法编译评估i？” 那会破坏模板的目的。模板适用于某些情况下源代码看起来相同的情况，但编译器需要生成的指令每次都不同。
2. “还有其他任何方法可以实现我想要实现的目标，而无需更改API接口吗？” 是的，看看Boost.MPL。 但是我怀疑这里正确的答案是你想要改变API。它取决于modify函数的内部。我知道你有它的来源，因为模板必须在标题中定义。那么看看为什么它需要在编译时知道i，如果没有，最好用普通函数和参数替换（或补充，如果你需要保持向后兼容性）。

Answer 4

不使用struct或Boost也可以完成：

#include <iostream>
#include <utility>

template <int a>
void modify()
{
    std::cout<<a<<",";
}

template<int i,size_t... t>
constexpr inline void CT_for_impl(std::integer_sequence<size_t,t...>)
{
    bool kai[]= { (modify<i+t>(), false)...};
}

template<int i,int n>
constexpr inline void CT_for()
{
    CT_for_impl<i>(std::make_index_sequence<n-i+1>());
}

int main()
{
    CT_for<-5,5>();
    return 0;
}

Answer 5

解决错误：'i'不能出现在上述问题的常量表达式中

To read about constexpr click this link

#include <iostream>
using namespace std;

template <typename T>
void modify(T a)
{
    cout<<a<<endl;  //to check if its working 
}


//func converts int a into const int a
constexpr int func(int a)
{
    return a;
}

int main(){
    for(int i=0; i<10; i++){
        modify(func(i));//here passing func(i) returned value which can be used as template argument now as it is converted to constexpr    
}
    return 0;
}

Answer 6

如果您希望通过索引在运行时调用函数，并且无法更改API，则可以考虑使用类型擦除：

std::vector<std::function<void(int)> > func;
func.push_back(modify<1>);
func.push_back(modify<2>);
//... and so on ...
func.push_back(modify<10>);

for(int i=0; i<10; ++i)
{
    func[i]();  //calls modify<i+1>();
}

有些要点：

• 这不是主要用于模板的模板，但它是将静态库带入运行时世界的一种方式。对此的基本要求是一个人使用同类型（ - 如果modify<7>()将返回，比如说，整个方法会破坏std::string）。
• 使用类型擦除的先前解决方案具有开销。通过使用函数指针，可以更快地获得它，但它仍然总是比在编译时调用函数慢。
• 人们可以（并且应该）将push_backs包装到另一个迭代静态函数中以避免手动调用。