以数组为参数的模板专业化

pin_ftv

我正在尝试专门化此功能模板：

template< typename T, std::size_t Size>
T Max(T(&pArr)[Size]) {
    T result{ *pArr };

    for (size_t i{ 1 }; i < Size; i++) {
        result = pArr[i - 1] > pArr[i] ? pArr[i - 1] : pArr[i];
    }
    return result;
}

我想专门针对const char *。我已经尝试了很多东西，但是其中任何一个都可以。尝试这种方式时：

template<std::size_t SIZE>
const char* Max<const char*>(const char *(&pArr)[SIZE]) {
    char result{ *pArr };

    for (size_t i{ 1 }; i < SIZE; i++) {
        result = pArr[i - 1] > pArr[i] ? pArr[i - 1] : pArr[i];
    }
    return result;
}

我收到错误消息：'Max'：非法使用显式模板参数。有人可以帮我吗？我想了解为什么它不起作用以及如何使其起作用。

谢谢！

最高66

您的代码存在的问题是C ++ 11不支持模板功能的部分专业化。只有全部专业。

根据您的Max()功能，可能的完全专业化如下

template <>
int Max<int, 4u>(int(&pArr)[4u])
 {
   int result{ *pArr };

   for (size_t i{ 1 }; i < 4u; i++) 
      result = pArr[i - 1] > pArr[i] ? pArr[i - 1] : pArr[i];

   return result;
 }

您可以解决这个限制，即在模板struct / class中插入一个函数，然后部分专门化struct / class。

例如，给定以下模板struct，其中包含一个static func()函数

template <typename T, std::size_t N>
struct MaxS
 {
   static T func (T (&a)[N])
    {
      T result{ a[0] };

      for (size_t i{ 1 }; i < N; i++)
         result = a[i - 1] > a[i] ? a[i - 1] : a[i];

      return result;
    }
 };

您可以对所有intC样式数组进行部分专业化，如下所示

template <std::size_t N>
struct MaxS<int, N>
 {
   static int func (int (&a)[N])
    {
      int result{ a[0] };

      for (size_t i{ 1 }; i < N; i++)
         result = a[i - 1] > a[i] ? a[i - 1] : a[i];

      return result;
    }
 };

不幸的是，这样一来，您就无法推断出类型和大小。因此，您明确要求他们func()按如下方式调用s（例如）

MaxS<int, 4>::func(a)

以下是这两种解决方案的完整编译示例

#include <iostream>

template< typename T, std::size_t Size>
T Max(T(&pArr)[Size])
 {
   std::cout << "Max(), generic version" << std::endl;

   T result{ *pArr };

   for (size_t i{ 1 }; i < Size; i++)
      result = pArr[i - 1] > pArr[i] ? pArr[i - 1] : pArr[i];

   return result;
 }

template <>
int Max<int, 4u>(int(&pArr)[4u])
 {
   std::cout << "Max(), full specialization" << std::endl;

   int result{ *pArr };

   for (size_t i{ 1 }; i < 4u; i++) 
      result = pArr[i - 1] > pArr[i] ? pArr[i - 1] : pArr[i];

   return result;
 }

template <typename T, std::size_t N>
struct MaxS
 {
   static T func (T (&a)[N])
    {
      std::cout << "MaxS::func(), generic version" << std::endl;

      T result{ a[0] };

      for (size_t i{ 1 }; i < N; i++)
         result = a[i - 1] > a[i] ? a[i - 1] : a[i];

      return result;
    }
 };

template <std::size_t N>
struct MaxS<int, N>
 {
   static int func (int (&a)[N])
    {
      std::cout << "MaxS::func(), int partial specialization" << std::endl;

      int result{ a[0] };

      for (size_t i{ 1 }; i < N; i++)
         result = a[i - 1] > a[i] ? a[i - 1] : a[i];

      return result;
    }
 };


int main()
{
   int  a [] { 1, 2, 3, 4 };
   long b [] { 1, 2, 3, 4 };
   int  c [] { 1, 2, 3, 4, 5 };

   std::cout << Max(a) << std::endl;
   std::cout << Max(b) << std::endl;
   std::cout << Max(c) << std::endl;

   std::cout << MaxS<int, 4>::func(a) << std::endl;
   std::cout << MaxS<long, 4>::func(b) << std::endl;
   std::cout << MaxS<int, 5>::func(c) << std::endl;
}

本文收集自互联网，转载请注明来源。

如有侵权，请联系 [email protected] 删除。