C++ 通过 const 引用传递 const 指针

Question

嗯，VC2012 中的一个奇怪的问题我似乎无法弄清楚通过 const 引用将 const 指针传递给模板参数是非 const 指针的模板类的函数的语法，即：

template<typename T>
struct Foo
{
    void Add( const T& Bar ) { printf(Bar); }
};

void main()
{
Foo<char*> foo;
const char* name = "FooBar"; 
foo.Add(name);                 // Causes error
}

所以我在这里简化了我的问题，但基本上我希望“添加”的参数有一个 const T 即 const char*。我试过了：

void Add( const (const T)& Bar ); 

typedef const T ConstT;
void Add( const (ConstT)& Bar );  

void Add( const typename std::add_const<T>::type& Bar ); 

这些都不起作用。我得到的确切错误是：

error C2664: 'Foo<T>::Add' : cannot convert parameter 1 from 'const char *' to 'char *const &'
          with
          [
              T=char *
          ]
          Conversion loses qualifiers 

我可以看到是正确的，但是如何在没有 const 将 'name' 转换为非 const 的情况下解决它。

Answer 1

指向常量对象的指针（T const* 或 const T*）与指向非常量对象的常量指针（T * const）之间存在很大差异。在您的情况下，成员 Add 的签名是：

void Foo<char *>::Add(char * const& ); // reference to a constant pointer to a 
                                       // non-constant char

出于这个原因，我通常建议人们不要在左侧使用const，因为初学者通常会将typedefs（或推导的类型）与类型替换混淆，当他们阅读时：

const T& [T == char*]

他们误解了

const char*&

如果const放在正确的地方：

T const &

对于初学者来说事情更简单，因为简单的心理替代很有效：

char * const &

---

与您所问的问题不同，但也许您认为自己想要的是：

给定一个类型 T 有一个函数，如果 T 不是指针类型，则 U 是 const T，如果 T 是指向 @987654339 的指针，则 X const * @

template <typename T>
struct add_const_here_or_there {
    typedef T const type;
};
template <typename T>
struct add_const_here_or_there<T*> {
    typedef T const * type;
};

然后你可以在你的签名中使用这个：

template <typename T>
void Foo<T>::Add( const typename add_const_here_or_there<T>::type & arg ) {
     ...

请注意，我在签名中添加了两个 const，因此在您的情况下，char* 将映射到 char const * const &，因为您似乎想将 const& 传递给某些东西，并且您还想要指出输入const。

您可能想知道元函数的名称：*add_const_here_or_there*，之所以这样是有原因的：没有简单的方法来描述您正在尝试做什么，这通常是代码异味。但在这里你有你的解决方案。

Answer 2

这里看起来像您的问题，因为一旦您将指针类型映射到模板类型，您就不能再将 const-ness 添加到指向的类型，只能添加到指针本身。看起来您正在尝试做的是自动将 constness 添加到函数的参数中（因此，如果 T 是 char*，则函数应该接受 const char* const& 而不是 char* const& 如您所写的那样）。做到这一点的唯一方法是使用另一个模板为指针类型的指针添加常量，如下所示。我冒昧地添加了丢失的标题并更正了main的签名：

#include <cstdio>

template<typename T>
struct add_const_to_pointee
{
    typedef T type;
};

template <typename T>
struct add_const_to_pointee<T*>
{
    typedef const T* type;
};

template<typename T>
struct Foo
{
    void Add( typename add_const_to_pointee<T>::type const & Bar ) { printf(Bar); }
};

int main()
{
    Foo<char*> foo;
    const char* name = "FooBar";
    foo.Add(name);                 // Causes error
}

正如另一个人提到的那样，如果您使用 std::string 而不是 C 风格的字符串，这个问题就会消失。

Answer 3

您需要将 Foo 对象的模板参数更改为 Foo<const char*>。因为如果T=char*，那么const T=char*const，而不是const char*。试图强制它工作不是一个好主意，并且可能会导致未定义的行为。

Answer 4

用途：

Foo<const char*> foo;
const char* name = "FooBar"; 
foo.Add(name);     

写int main()而不是void main()

Answer 5

如果将const char* 而不是char* 传递给Foo 不是一个选项，您可以使用std::remove_pointer 调整正确的类型。这将删除指针修饰符并允许您提供更明确的类型。

#include <type_traits>

template<typename T>
struct Foo
{
    void Add(typename std::remove_pointer<T>::type const*& Bar ) { printf(Bar); }
};

为防止指针值被修改，您也可以将引用声明为const。

void Add(typename std::remove_pointer<T>::type const* const& Bar )
{ Bar = "name"; } // <- fails

如果您需要将类型从 指针减少到指针，您可以使用 std::decay 和 std::remove_pointer

void Add(typename std::remove_pointer<typename std::decay<T>::type>::type const*& Bar)
{
    printf(Bar);
}

这实际上取决于您对T 的要求。我建议假设只有基本类型（例如char）作为T 传递，并从中构建引用和指针类型。