请考虑以下事项：
template <unsigned N>
struct Fibonacci
{
enum
{
value = Fibonacci<N-1>::value + Fibonacci<N-2>::value
};
};
template <>
struct Fibonacci<1>
{
enum
{
value = 1
};
};
template <>
struct Fibonacci<0>
{
enum
{
value = 0
};
};
这是一个常见的例子，我们可以将Fibonacci数的值作为编译时常量：
int main(void)
{
std::cout << "Fibonacci(15) = ";
std::cout << Fibonacci<15>::value;
std::cout << std::endl;
}
但是你显然无法在运行时获得该值：
int main(void)
{
std::srand(static_cast<unsigned>(std::time(0)));
// ensure the table exists up to a certain size
// (even though the rest of the code won't work)
static const unsigned fibbMax = 20;
Fibonacci<fibbMax>::value;
// get index into sequence
unsigned fibb = std::rand() % fibbMax;
std::cout << "Fibonacci(" << fibb << ") = ";
std::cout << Fibonacci<fibb>::value;
std::cout << std::endl;
}
因为 fibb 不是编译时常量。
所以我的问题是：
在运行时查看此表的最佳方法是什么？最明显的解决方案（和“解决方案”应该是轻率的），是有一个大的switch语句：
unsigned fibonacci(unsigned index)
{
switch (index)
{
case 0:
return Fibonacci<0>::value;
case 1:
return Fibonacci<1>::value;
case 2:
return Fibonacci<2>::value;
.
.
.
case 20:
return Fibonacci<20>::value;
default:
return fibonacci(index - 1) + fibonacci(index - 2);
}
}
int main(void)
{
std::srand(static_cast<unsigned>(std::time(0)));
static const unsigned fibbMax = 20;
// get index into sequence
unsigned fibb = std::rand() % fibbMax;
std::cout << "Fibonacci(" << fibb << ") = ";
std::cout << fibonacci(fibb);
std::cout << std::endl;
}
但是现在表格的大小非常难以编码，并且将它扩展为40，并不容易。
我想出的唯一一个有类似查询方法的是：
template <int TableSize = 40>
class FibonacciTable
{
public:
enum
{
max = TableSize
};
static unsigned get(unsigned index)
{
if (index == TableSize)
{
return Fibonacci<TableSize>::value;
}
else
{
// too far, pass downwards
return FibonacciTable<TableSize - 1>::get(index);
}
}
};
template <>
class FibonacciTable<0>
{
public:
enum
{
max = 0
};
static unsigned get(unsigned)
{
// doesn't matter, no where else to go.
// must be 0, or the original value was
// not in table
return 0;
}
};
int main(void)
{
std::srand(static_cast<unsigned>(std::time(0)));
// get index into sequence
unsigned fibb = std::rand() % FibonacciTable<>::max;
std::cout << "Fibonacci(" << fibb << ") = ";
std::cout << FibonacciTable<>::get(fibb);
std::cout << std::endl;
}
这似乎很有效。我看到的唯一两个问题是：
可能大的调用堆栈，因为计算Fibonacci＆lt; 2＆gt;要求我们一直通过TableMax到2，并且：
如果值在表格之外，则返回零而不是计算它。
那么我缺少什么？似乎应该有更好的方法在运行时选择这些值。
也许是一个switch语句的模板元编程版本，它会生成一个特定数量的switch语句？
提前致谢。
答案 0 :(得分：27)
template <unsigned long N>
struct Fibonacci
{
enum
{
value = Fibonacci<N-1>::value + Fibonacci<N-2>::value
};
static void add_values(vector<unsigned long>& v)
{
Fibonacci<N-1>::add_values(v);
v.push_back(value);
}
};
template <>
struct Fibonacci<0>
{
enum
{
value = 0
};
static void add_values(vector<unsigned long>& v)
{
v.push_back(value);
}
};
template <>
struct Fibonacci<1>
{
enum
{
value = 1
};
static void add_values(vector<unsigned long>& v)
{
Fibonacci<0>::add_values(v);
v.push_back(value);
}
};
int main()
{
vector<unsigned long> fibonacci_seq;
Fibonacci<45>::add_values(fibonacci_seq);
for (int i = 0; i <= 45; ++i)
cout << "F" << i << " is " << fibonacci_seq[i] << '\n';
}
经过深思熟虑之后，我想出了这个解决方案。当然，您仍然必须在运行时将值添加到容器中，但（重要的是）它们在运行时不是计算。
作为旁注，重要的是不要在Fibonacci<1>之上定义Fibonacci<0>，否则在解析对Fibonacci<0>::add_values的调用时，编译器会将非常弄糊涂，因为Fibonacci<0>的模板专业化尚未指定。
当然，TMP有其局限性：您需要预先计算的最大值，并且在运行时获取值需要递归（因为模板是递归定义的）。
答案 1 :(得分：17)
我知道这个问题已经过时了，但它引起了我的兴趣，我不得不在运行时填充动态容器：
#ifndef _FIBONACCI_HPP
#define _FIBONACCI_HPP
template <unsigned long N>
struct Fibonacci
{
static const unsigned long long value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
static unsigned long long get_value(unsigned long n)
{
switch (n) {
case N:
return value;
default:
return n < N ? Fibonacci<N-1>::get_value(n)
: get_value(n-2) + get_value(n-1);
}
}
};
template <>
struct Fibonacci<0>
{
static const unsigned long long value = 0;
static unsigned long long get_value(unsigned long n)
{
return value;
}
};
template <>
struct Fibonacci<1>
{
static const unsigned long long value = 1;
static unsigned long get_value(unsigned long n)
{
return value;
}
};
#endif
这似乎有效，并且在使用优化进行编译时（不确定是否允许这样做），调用堆栈不会深入 - 当然对于值（参数）n，堆栈上存在正常的运行时递归＆GT; N，其中N是模板实例化中使用的TableSize。但是，一旦你低于TableSize，生成的代码将替换在编译时计算的常量，或者在最坏的情况下，通过删除跳转表（在gcc中使用-c -g -Wa，-adhlns = main编译）来“计算”。 s并检查列表），就像我认为显式切换语句会导致的那样。
当像这样使用时：
int main()
{
std::cout << "F" << 39 << " is " << Fibonacci<40>::get_value(39) << '\n';
std::cout << "F" << 45 << " is " << Fibonacci<40>::get_value(45) << '\n';
}
在第一种情况下根本没有调用计算（在编译时计算的值），在第二种情况下，调用堆栈深度最差：
fibtest.exe!Fibonacci<40>::get_value(unsigned long n=41) Line 18 + 0xe bytes C++
fibtest.exe!Fibonacci<40>::get_value(unsigned long n=42) Line 18 + 0x2c bytes C++
fibtest.exe!Fibonacci<40>::get_value(unsigned long n=43) Line 18 + 0x2c bytes C++
fibtest.exe!Fibonacci<40>::get_value(unsigned long n=45) Line 18 + 0xe bytes C++
fibtest.exe!main() Line 9 + 0x7 bytes C++
fibtest.exe!__tmainCRTStartup() Line 597 + 0x17 bytes C
即。它会递归直到它在“表”中找到一个值。 （通过逐行逐步调试调试器中的Disassembly进行验证，也可以通过用随机数替换测试整数＆lt; = 45）
递归部分也可以用线性迭代解决方案代替：
static unsigned long long get_value(unsigned long n)
{
switch (n) {
case N:
return value;
default:
if (n < N) {
return Fibonacci<N-1>::get_value(n);
} else {
// n > N
unsigned long long i = Fibonacci<N-1>::value, j = value, t;
for (unsigned long k = N; k < n; k++) {
t = i + j;
i = j;
j = t;
}
return j;
}
}
}
答案 2 :(得分：4)
如果您的C ++编译器支持可变参数模板（C ++ 0x标准），则可以在编译时将斐波那契序列保存在元组中。在运行时，您可以通过索引来访问该元组中的任何元素。
#include <tuple>
#include <iostream>
template<int N>
struct Fib
{
enum { value = Fib<N-1>::value + Fib<N-2>::value };
};
template<>
struct Fib<1>
{
enum { value = 1 };
};
template<>
struct Fib<0>
{
enum { value = 0 };
};
// ----------------------
template<int N, typename Tuple, typename ... Types>
struct make_fibtuple_impl;
template<int N, typename ... Types>
struct make_fibtuple_impl<N, std::tuple<Types...> >
{
typedef typename make_fibtuple_impl<N-1, std::tuple<Fib<N>, Types... > >::type type;
};
template<typename ... Types>
struct make_fibtuple_impl<0, std::tuple<Types...> >
{
typedef std::tuple<Fib<0>, Types... > type;
};
template<int N>
struct make_fibtuple : make_fibtuple_impl<N, std::tuple<> >
{};
int main()
{
auto tup = typename make_fibtuple<25>::type();
std::cout << std::get<20>(tup).value;
std::cout << std::endl;
return 0;
}
答案 3 :(得分：3)
使用C ++ 11：您可以创建一个std::array和一个简单的getter：https://ideone.com/F0b4D3
namespace detail
{
template <std::size_t N>
struct Fibo :
std::integral_constant<size_t, Fibo<N - 1>::value + Fibo<N - 2>::value>
{
static_assert(Fibo<N - 1>::value + Fibo<N - 2>::value >= Fibo<N - 1>::value,
"overflow");
};
template <> struct Fibo<0u> : std::integral_constant<size_t, 0u> {};
template <> struct Fibo<1u> : std::integral_constant<size_t, 1u> {};
template <std::size_t ... Is>
constexpr std::size_t fibo(std::size_t n, index_sequence<Is...>)
{
return const_cast<const std::array<std::size_t, sizeof...(Is)>&&>(
std::array<std::size_t, sizeof...(Is)>{{Fibo<Is>::value...}})[n];
}
template <std::size_t N>
constexpr std::size_t fibo(std::size_t n)
{
return n < N ?
fibo(n, make_index_sequence<N>()) :
throw std::runtime_error("out of bound");
}
} // namespace detail
constexpr std::size_t fibo(std::size_t n)
{
// 48u is the highest
return detail::fibo<48u>(n);
}
答案 4 :(得分：1)
我的想法是在可变参数模板中递归保存斐波那契数列，然后将其转换为数组。所有这些都是在编译时完成的。 例如，当 n = 5 时，我们有：
Fatal error: Unexpectedly found nil while unwrapping an Optional value然后我们可以在运行时索引数组。
我的 C++14 实现：
F<5>::array
= F<4, 0>::array
= F<3, 0, 1>::array
= F<2, 0, 1, 1>::array
= F<1, 0, 1, 1, 2>::array
= F<0, 0, 1, 1, 2, 3>::array
= { 0, 1, 1, 2, 3 }
答案 5 :(得分：0)
C（以及大部分C ++）的基本契约之一是你不需要支付你不需要的费用。
自动生成查找表并不是编译器需要为您完成的事情。即使你需要这种功能，也不是其他所有人都需要的。
如果你想要一个查找表，写一个程序来制作一个。然后在程序中使用该数据。
如果您希望在运行时计算值，请不要使用模板元程序，只需使用常规程序来计算值。
答案 6 :(得分：0)
您可以使用预处理器元编程技术生成开关或静态数组。 如果复杂性不超过该方法的限制，那么这是一个很好的决定，并且您不希望使用生成代码或数据的额外步骤来扩展您的工具链。
答案 7 :(得分：-1)
这应该可以解决问题......
template <int N> class EXPAND {
public:
static const string value;
};
template <> class EXPAND<0> {
public:
static const string value;
};
template <int N> const string EXPAND<N>::value = EXPAND<N-1>::value+"t";
const string EXPAND<0>::value = "t";
int main() {
cout << EXPAND<5>::value << endl;
}