const 重载和共享指针

Question

试图更好地掌握围绕 const 重载的规则。考虑以下代码 -

MyClass.h

class MyClass
{
public:
    MyClass();
    ~MyClass();
};

MyClass.cpp

#include "MyClass.h"
MyClass::MyClass() 
{
}
MyClass::~MyClass()
{
}

main.cpp

#include <iostream>
#include "MyClass.h"
#include <memory>
using namespace std;

/*
void test_function(MyClass& test)
{
    cout << "ref to non const" << endl;
}
*/
void test_function(const MyClass& test)
{
    cout << "ref to const" << endl;
}
/*
void test_shared_ptr( shared_ptr<MyClass>& test)
{
    cout << "ref to non const shared ptr to non const" << endl;
}

void test_shared_ptr ( const shared_ptr<MyClass>& test)
{
    cout << "ref to const shared ptr to non const" << endl;
}
*/
void test_shared_ptr (const shared_ptr<const MyClass>& test)
{
    cout << "ref to const shared ptr to const" << endl;
}

int main()
{
    MyClass non_const_my_class;
    test_function(non_const_my_class);
    const MyClass const_my_class;
    test_function(const_my_class);

    shared_ptr<MyClass> non_const_ptr_to_non_const = make_shared<MyClass>                (MyClass());
    test_shared_ptr(non_const_ptr_to_non_const);

    const shared_ptr<MyClass> const_ptr_to_non_const = make_shared<MyClass>(MyClass());
    test_shared_ptr(const_ptr_to_non_const);

    const shared_ptr< const MyClass> const_ptr_to_const = make_shared< const MyClass>(MyClass());
    test_shared_ptr(const_ptr_to_const);

    int pause;
    cin >> pause;
    return 0;
}

注释掉方法后的输出是：

ref to const
ref to const
ref to const shared ptr to const
ref to const shared ptr to const
ref to const shared ptr to const

这个输出是我所期望的，但是我在一些围绕这种类型的 const 重载的代码上遇到了一个潜在的错误。真的只是想对以下陈述进行一些验证：

1. 始终可以将非常量数据作为对 const 的引用传递给函数，只要该函数不试图违反其参数的 const 性。这会导致编译错误。
2. 永远不行，因为它会导致编译错误，将 const 数据作为对非 const 的引用传递给函数。这将违反数据的常量性。

最后一个问题——

在什么情况下您可能需要如下代码？在我上面的测试代码中，将非 const 数据作为 const 引用传递给函数是非常好的，那么我为什么需要像这样执行 const_cast 呢？

void test_const_cast(const MyClass & test)
{
    //Do something
}

void test_const_cast( MyClass & test)
{
    test_const_cast(const_cast<MyClass const &>(test));
}

Answer 1

声明 1：对于 C++98 来说接近，甚至比对于 C++11 更接近。在 C++11 中，当涉及到标准库时，增加了一个要求，即 const 成员函数不引入数据竞争。见http://channel9.msdn.com/posts/C-and-Beyond-2012-Herb-Sutter-You-dont-know-blank-and-blank。除了具有类型实例的极端情况之外，该类型实例具有引入数据竞争的 const 成员函数，而非常量重载则没有，将可变左值传递给采用对 const 的引用的函数是可以的。 即使该函数确实违反了其参数的常量性（通过使用const_cast<>()）。

声明 2： 可以将 const 数据作为对非 const 的引用传递，提供函数实际上不会更改其参数引用的对象。这是const_cast<>() 的主要预期用例。

额外问题：使用const_cast<>() 来添加 const 的代码主要在重载函数的返回值不是void 时很有用。例如，标准库为std::vector<T /* technically more type paraeters here */> 提供了非成员begin() 和end() 函数，例如采用const vector<int>& 的重载返回vector<int>::const_iterator，但采用vector<int>& 的重载返回vector<int>::iterator .如果您想要const_iterator 而不仅仅是iterator，并且不想麻烦地将iterator 转换为const_iterator，您可以这样做。这就是 C++17 引入 as_const() http://en.cppreference.com/w/cpp/utility/as_const 的原因，以使其更容易且无需使用可怕的 const_cast<>()。

Answer 2

将非常量数据作为对 const 的引用传递给函数总是可以的，只要该函数不试图违反其参数的 const 性。这会导致编译错误。

并非总是如此。 C++ 不喜欢传递使用常量模板化的类型。考虑以下代码：

#include <vector>
using std::vector;

void test(const vector<const int> & b) { }

int main() {
  vector<int> a;
  test(a);
}

这里，a 是 int 的向量，test 接受 const 的向量 const int。 test 的约束本质上是一个承诺，它既不会修改b 也不会修改其中的元素；直观地说，它根本不应该对a 施加任何限制。然而代码不会编译。例如，在 clang 中，您会收到以下错误：

test_template.cxx:11:3: error: no matching function for call to 'test'
  test(a);
  ^~~~
test_template.cxx:5:6: note: candidate function not viable: no known conversion
      from 'vector<int>' to 'const vector<const int>' for 1st argument
    void test(const vector<const int> & a) { }
     ^

删除vector 前面的const 实际上，它确实可以编译（至少在clang 上）。所以const 和你总结的不太一样。

Answer 3

这个问题的答案似乎是它只是依赖于编译器。可以使用 Visual Studio 编译器将指向 const 数据的非 const 指针传递给一个函数，该函数将指向 const 数据的 const 指针作为参数，但不能使用 gcc。