C++ 依赖于非类型参数的模板函数

是否可以基于非类型参数定义重载模板函数

以下情况：

template<uint8_t> void SetupMem();

template<> void SetupMem<4>()
{ /* some code */ }


template<> void SetupMem<8>()
{ /* some code */ }

void TemplateCaller()
{
   // use the plattform-specific template function at compile-time
   SetupMem<sizeof(size_t)>();
}

---

这样

TemplateCaller（）

就不会使用所需的模板参数显式调用

SetupMem

（这样就避免了类似于：

SetupMem（）；

）的事情了？欢迎使用高达C++11的可能解决方案：）

您可以编写一个类型特征：

template<::std::size_t x_Size> class
t_IntegralFromSize;

template<> class
t_IntegralFromSize<4> final
{
    public: using type = ::std::uint32_t;
};

template<> class
t_IntegralFromSize<8> final
{
    public: using type = ::std::uint64_t;
};

template<::std::size_t x_Size> typename t_IntegralFromSize<x_Size>::type
SetupMem();

template<> t_IntegralFromSize<4>::type
SetupMem<4>()
{ /* some code */ }


template<> t_IntegralFromSize<8>::type
SetupMem<8>()
{ /* some code */ }

void TemplateCaller()
{
    // use the plattform-specific template function at compile-time
    SetupMem<sizeof(size_t)>(); // works without changes
}

模板类
t_积分的大小；
模板类
t\u最终尺寸
{
public：使用类型=：：std:：uint32\u t；
};
模板类
t\u最终尺寸
{
public：使用类型=：：std:：uint64\u t；
};
模板typename t_integrationfromsize:：type
SetupMem（）；
模板t_integrationfromsize:：type
SetupMem（）
{/*一些代码*/}
模板t_integrationfromsize:：type
SetupMem（）
{/*一些代码*/}
void TemplateCaller（）
{
//在编译时使用特定于平台的模板函数
SetupMem（）；//无需更改即可工作
}

只需使用简单的函数重载和

std:：integral\u常量

：

std::uint32_t SetupMem(std::integral_constant<int, 4>); // (0)
std::uint64_t SetupMem(std::integral_constant<int, 8>); // (1)

void TemplateCaller()
{
   auto a = SetupMem(std::integral_constant<int, 4>{}); // calls (0)
   auto b = SetupMem(std::integral_constant<int, 8>{}); // calls (1)
}

---

问题意义上的用法是

SetupMem（ic（））我喜欢这个，因为它非常简单，这从来都不是坏事。我非常喜欢这个解决方案，但不幸的是，我们的“特殊”编译器还没有提供std:：integral_常量。因此，我将在这里给出一个简单的向上投票。@mbed_dev解决方法：定义您自己的积分常数：
template ic{}应该是您所需要的全部，因为您只需要模板类型来选择正确的重载…@Aconcagua您可以完成示例吗？这不是XY问题吗？如果您只担心
size\u t
，那么只需使用
size\u t
。注意，现在很多库都有32位和64位版本。
std::uint32_t SetupMem(std::integral_constant<int, 4>); // (0)
std::uint64_t SetupMem(std::integral_constant<int, 8>); // (1)

void TemplateCaller()
{
   auto a = SetupMem(std::integral_constant<int, 4>{}); // calls (0)
   auto b = SetupMem(std::integral_constant<int, 8>{}); // calls (1)
}

template <int X>
using ic = std::integral_constant<int, X>;

std::uint32_t SetupMem(ic<4>);
std::uint64_t SetupMem(ic<8>);

void TemplateCaller()
{
   auto a = SetupMem(ic<4>{});
   auto b = SetupMem(ic<8>{});
}

template <int>
struct ic { };

std::uint32_t SetupMem(ic<4>);
std::uint64_t SetupMem(ic<8>);

void TemplateCaller()
{
   auto a = SetupMem(ic<4>{});
   auto b = SetupMem(ic<8>{});
}