是否可以重载一个可以从指针中分辨出固定数组的函数？

Question

动机：

几乎是为了好玩，我正在尝试编写一个函数重载，它可以区分参数是固定大小的数组还是指针。

double const  d[] = {1.,2.,3.};
double a;
double const* p = &a;
f(d); // call array version
f(p); // call pointer version

我发现这特别困难，因为众所周知，数组迟早会衰减为指针。一个天真的方法是写

void f(double const* c){...}
template<size_t N> void f(double const(&a)[N]){...}

不幸的是，这不起作用。因为在最好的情况下，编译器会确定上面的数组调用 f(d) 是不明确的。

部分解：

我尝试了很多东西，最接近的是下面的具体代码。另请注意，在此示例代码中，我使用 char 而不是 double，但最后非常相似。

首先，我必须使用 SFINAE 在函数的指针版本中禁用转换（从数组 ref 到 ptr）。其次，我必须为所有可能的数组大小（手动）重载。

[可编译代码]

#include<type_traits> // for enable_if (use boost enable_if in C++98)
#include<iostream>
template<class Char, typename = typename std::enable_if<std::is_same<Char, char>::value>::type>
void f(Char const* dptr){std::cout << "ptr" << std::endl;} // preferred it seems

void f(char const (&darr)[0] ){std::cout << "const arr" << std::endl;}
void f(char const (&darr)[1] ){std::cout << "const arr" << std::endl;}
void f(char const (&darr)[2] ){std::cout << "const arr" << std::endl;}
void f(char const (&darr)[3] ){std::cout << "const arr" << std::endl;}
void f(char const (&darr)[4] ){std::cout << "const arr" << std::endl;}
void f(char const (&darr)[5] ){std::cout << "const arr" << std::endl;}
void f(char const (&darr)[6] ){std::cout << "const arr" << std::endl;} // this is the one called in this particular example
// ad infinitum ...

int main(){     
    f("hello"); // print ptr, ok because this is the fixed size array
    f(std::string("hello").c_str()); // print arr, ok because `c_str()` is a pointer
}

这行得通，但问题是我必须为 N 的所有可能值重复该函数并使用 template<size_t N> 使我回到零平方，因为使用模板参数两个通话回到平等地位。换句话说，template<size_t N> void f(char const(&a)[N]){std::cout << "const arr" << std::endl;} 没有帮助。

有什么方法可以泛化第二个重载而不退回到模棱两可的调用吗？还是有其他方法？

也欢迎提供 C++ 或 C++1XYZ 答案。

两个细节：1) 我在上面的实验中使用了 clang，2) 实际的 f 最终将成为 operator<<，我想知道这是否对解决方案。

解决方案总结（以下基于其他人的）并适用于示例的具体类型char。两者似乎都依赖于使 char const* 指针对编译器不那么明显：

一个weird（可移植？），（来自@dyp的评论。）为指针版本添加引用限定符：

    template<class Char, typename = typename std::enable_if<std::is_same<Char, char>::value>::type>
    void f(Char const* const& dptr){std::cout << "ptr" << std::endl;}
    
    template<size_t N>
    void f(char const (&darr)[N] ){std::cout << "const arr" << std::endl;}

一个优雅的（来自@user657267 的特例）

    template<class CharConstPtr, typename = typename std::enable_if<std::is_same<CharConstPtr, char const*>::value>::type>
    void f(CharConstPtr dptr){std::cout << "ptr" << std::endl;}
    
    template<size_t N>
    void f(char const (&darr)[N] ){std::cout << "const arr" << std::endl;}

Answer 1

您可以使用以下内容：

namespace detail
{
    template <typename T> struct helper;

    template <typename T> struct helper<T*> { void operator() () const {std::cout << "pointer\n";} };
    template <typename T, std::size_t N> struct helper<T[N]> { void operator() ()const {std::cout << "array\n";} };
}


template <typename T>
void f(const T& )
{
    detail::helper<T>{}();
}

Live example

Answer 2

这似乎对我有用

#include <iostream>

template<typename T>
std::enable_if_t<std::is_pointer<T>::value>
foo(T) { std::cout << "pointer\n"; }

template<typename T, std::size_t sz>
void foo(T(&)[sz]) { std::cout << "array\n"; }

int main()
{
  char const* c;
  foo(c);
  foo("hello");
}

奖金std::experimental::type_traits：

using std::experimental::is_pointer_v;
std::enable_if_t<is_pointer_v<T>>

你的评论让我尝试了更简单的方法

template<typename T> void foo(T) { std::cout << "pointer\n"; }
template<typename T, unsigned sz> void foo(T(&)[sz]) { std::cout << "array\n"; }

当然这里的问题是 foo 现在可以为任何类型调用，这取决于您希望参数检查有多宽松。

另一种方法是（ab）使用右值引用

void foo(char const*&) { std::cout << "pointer\n"; }
void foo(char const*&&) { std::cout << "array\n"; }

显然这不是万无一失的。

Answer 3

我喜欢使用标签调度：

void foo(char const*, std::true_type /*is_pointer*/) {
  std::cout << "is pointer\n";
}
template<class T, size_t N>
void foo( T(&)[N], std::false_type /*is_pointer*/) {
  std::cout << "is array\n";
}
template<class X>
void foo( X&& x ) {
  foo( std::forward<X>(x), std::is_pointer<std::remove_reference_t<X>>{} );
}

live example

Answer 4

这是一个简单的解决方案，它利用了 in C the value of an array is equal to its address 这一事实，而这通常不适用于指针。

#include <iostream>

template <typename P>
bool is_array(const P & p) {
  return &p == reinterpret_cast<const P*>(p);
}

int main() {
  int a[] = {1,2,3};
  int * p = a;

  std::cout << "a is " << (is_array(a) ? "array" : "pointer") << "\n";
  std::cout << "p is " << (is_array(p) ? "array" : "pointer") << "\n";
  std::cout << "\"hello\" is " << (is_array("hello") ? "array" : "pointer");
}

请注意，虽然指针通常指向与其自身不同的位置，但不一定能保证这一点；实际上，您可以通过执行以下操作轻松地欺骗代码：

//weird nasty pointer that looks like an array:
int * z = reinterpret_cast<int*>(&z);

但是，由于您是为了乐趣而编写代码，因此这可能是一种有趣、基本的第一种方法。

Answer 5

在我看来就这么简单：

#include<iostream>
using namespace std;

template<typename T>
void foo(T const* t)
{
  cout << "pointer" << endl;
}

template<typename T, size_t n>
void foo(T(&)[n])
{
  cout << "array" << endl;
}

int main() {
  int a[5] = {0};
  int *p = a;
  foo(a);
  foo(p);
}

我不明白 std::enable_if 和 std::true_type 以及 std::is_pointer 和魔术的所有复杂情况。如果我的方法有任何问题，请告诉我。

Answer 6

我也想知道如何绕过编译器抱怨模棱两可的重载并遇到这个问题。

此 C++11 解决方案在形式上类似于分派答案，但使用可变 SFINAE 技巧（编译器首先尝试数组版本）。 "decltype" 部分允许不同的 return 类型。如果所需的 return 类型是固定的（例如，根据 OP，"void"）则不需要。

#include <functional>
#include <iostream>
using std::cout;
using std::endl;

template <typename T> T _thing1(T* x, ...) { cout << "Pointer, x=" << x << endl; return x[0]; }
template <typename T, unsigned N> T _thing1(T (&x)[N], int) { cout << "Array, x=" << x << ", N=" << N << endl; return x[0]; }
template <typename T> auto thing1(T&& x) -> decltype(_thing1(std::forward<T>(x), 0)) { _thing1(std::forward<T>(x), 0); }

int main(int argc, char** argv)
{
    const int x0[20] = {101,2,3};
    cout << "return=" << thing1(x0) << endl;

    int x1[10] = {22};
    cout << "return=" << thing1(x1) << endl;

    float x2 = 3.141;
    cout << "return=" << thing1(&x2) << endl;

    const float x3 = 55.1;
    cout << "return=" << thing1(&x3) << endl;

}

示例输出为：

$ g++ -std=c++11 array_vs_ptr.cpp -o array_vs_ptr && ./array_vs_ptr
Array, x=0x22ca90, N=20
return=101
Array, x=0x22ca60, N=10
return=22
Pointer, x=0x22caec
return=3.141
Pointer, x=0x22cae8
return=55.1

是否可以重载一个可以从指针中分辨出固定数组的函数？

Is it possible to overload a function that can tell a fixed array from a pointer?

c++

arrays

pointers

c++11