C++函数头匹配: how does matching work when const and templates are both involved?

Question

我有一个我想调用的模板化函数。这是标题的(精简版):

template <typename Item>
void print (shared_ptr<const MyContainer<Item>> stuff, ostream& out)

我试着用这样的一行来调用它:

print (make_shared<MyContainer<int>>(42), cerr);

但是编译器提示没有匹配项。让我感到困惑的是 const 不匹配不是问题，因为如果我重新声明我的函数以省略它工作的模板:

void print (shared_ptr<const MyContainer<int>> stuff, ostream& out)  //matches!

另一方面，如果我省略常量，模板化版本就可以工作:

template <typename Item>
void print (shared_ptr<MyContainer<Item>> stuff, ostream& out)  //also matches!

但我应该能够在 const 事物上编写一个函数并向其传递一个非常量值(该函数将不会修改该值)，对吗？事实上，如果我回到非托管指针，相应的旧方法将是编写 header

template <typename Item>
void print (const MyContainer<Item>* stuff, ostream& out)

然后调用

print (new MyContainer<int>(42), cerr);  //yet another match!

再次就好了。

那么，是什么导致编译器无法找到匹配函数的 shared_ptr、模板和 const 的特殊组合？ (运行 g++ 8.2.1 和 clang++ 7.0.1 似乎产生相同的结果。)

Answer 1

关于指针对象的常量性，std::shared_ptr行为与原始指针有点不同。

A std::shared_ptr<T>与 std::shared_ptr<const T> 不同.允许隐式转换甚至不兼容。 (Daniels answer 中的错误消息直截了本地说明了这一点。)

由于与以下(反例)示例相同的原因，它不起作用:

template <typename T>
struct ContainerT {
  T a;
  ContainerT(T a): a(a) { }
  ContainerT(const ContainerT&) = default;
  ContainerT& operator=(const ContainerT&) = default;
};

int main()
{
  ContainerT<int> a(42);
  ContainerT<const int> b(a);
  return 0;
}

输出:

g++ (GCC) 8.2.0
Copyright (C) 2018 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

main.cpp: In function 'int main()':
main.cpp:15:28: error: no matching function for call to 'ContainerT<const int>::ContainerT(ContainerT<int>&)'
   ContainerT<const int> b(a);
                            ^
main.cpp:8:3: note: candidate: 'constexpr ContainerT<T>::ContainerT(const ContainerT<T>&) [with T = const int]'
   ContainerT(const ContainerT&) = default;
   ^~~~~~~~~~
main.cpp:8:3: note:   no known conversion for argument 1 from 'ContainerT<int>' to 'const ContainerT<const int>&'
main.cpp:7:3: note: candidate: 'ContainerT<T>::ContainerT(T) [with T = const int]'
   ContainerT(T a): a(a) { }
   ^~~~~~~~~~
main.cpp:7:3: note:   no known conversion for argument 1 from 'ContainerT<int>' to 'int'

Live Demo on coliru

---

在std::shared_ptr的情况下，有办法绕过这个问题
→一个 std::const_pointer_cast 可以使用:

#include <iostream>
#include <memory>

template <typename T>
struct ContainerT {
  T a;
  ContainerT(T a): a(a) { }
};

template <typename T>
void print(std::shared_ptr<const ContainerT<T>> ref, std::ostream &out)
{
  out << "print: '" << ref->a << "'\n";
}

int main()
{
  print(std::make_shared<const ContainerT<int>>(42), std::cout);
  print(std::const_pointer_cast<const ContainerT<int>>(std::make_shared<ContainerT<int>>(42)), std::cout);
  return 0;
}

输出:

print: '42'
print: '42'

Live Demo on coliru

---

为了方便起见，const-cast 可以在另一个函数模板中完成:

#include <iostream>
#include <memory>

template <typename T>
struct ContainerT {
  T a;
  ContainerT(T a): a(a) { }
};

template <typename T>
void print(std::shared_ptr<const ContainerT<T>> ref, std::ostream &out)
{
  out << "print const: '" << ref->a << "'\n";
}

template <typename T>
void print(std::shared_ptr<ContainerT<T>> ref, std::ostream &out)
{
  out << "print non-const: ";
  print(std::const_pointer_cast<const ContainerT<T>>(ref), out);
}

int main()
{
  print(std::make_shared<const ContainerT<int>>(42), std::cout);
  print(std::make_shared<ContainerT<int>>(42), std::cout);
  return 0;
}

输出:

print const: '42'
print non-const: print const: '42'

Live Demo on coliru