C++ 以数组作为参数的模板专门化

我正在尝试专门化此函数模板：

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;
}

模板
T最大值（T&pArr）[尺寸]）{
T结果{*pArr}；
对于（size_t i{1}；ipArr[i]？pArr[i-1]：pArr[i]；
}
返回结果；
}

我想专门针对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;
}

模板
常量字符*最大值（常量字符*（&pArr）[大小]）{
字符结果{*pArr}；
对于（size_t i{1}；ipArr[i]？pArr[i-1]：pArr[i]；
}
返回结果；
}

我得到错误：“Max”：非法使用显式模板参数。 有人能帮我吗？我想了解为什么它不起作用，以及如何使它起作用

---

谢谢大家!

代码的问题是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;
 }

您可以对所有

int

C样式数组进行局部专门化，如下所示

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;
    }
 };

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;
}

#包括
模板
T最大值（T&pArr）[尺寸]）
{
std:：cout您不能对函数进行部分专门化。但您不必这样做，因为函数已经支持重载。您只需为
const char*
创建重载。您的版本有两个错误

您已经将结果变量声明为
char
，但它应该是
const char*
使用
比较随机指针不会产生有意义的结果。您必须决定如何调用一个大于另一个的指针
链接：


#包括
模板
T最大值（T&pArr）[尺寸]）{
T结果{*pArr}；
对于（size_t i{1}；ipArr[i]？pArr[i-1]：pArr[i]；
}
返回结果；
}
布尔更大（常量字符*第一，常量字符*第二）{
返回strlen（第一个）>strlen（第二个）；
}
模板
常量字符*最大值（常量字符*（&pArr）[大小]）{
常量字符*结果{*pArr}；
对于（size_t i{1}；i



还有一个问题：
Max
假设数组至少有两个元素。您可以添加一个
static\u assert
或正确处理大小写
仅供参考，有一个std lib algo
std:：max_元素
，也可以与数组一起使用
不能对函数进行局部专门化。您的意思是它应该是这样的吗？模板const char*Max（const char*（&pArr）[SIZE]）嗯……不；如果以前没有人这样做，我会试着写一个答案来更好地解释。谢谢！如果我在你的答案之前无法让它工作，我会在这里写下我是如何工作的。与错误无关，你的
Max
不会返回数组的最大元素，是有意的吗？
#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;
}

#include<cstring>

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;
}

bool greater(const char* first, const char* second){
    return strlen(first) > strlen(second);
}

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

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

int foo() {
    int ints[] = {1, 2};
    return Max(ints);
}

const char* bar() {
    const char* stuff[] = {"1222", "234", "sfsdfsd"};
    return Max(stuff);
}