const 函数调用非 const 或反之亦然（避免重复）？ [复制]

Question

使用一个比另一个有什么优势：

class Foo
{
public:
    const int& get() const
    {
        // stuff here
        return myInt;
    }

    int& get()
    {
        return const_cast<int&>(static_cast<const Foo*>(this)->get());
    }
};

或者

class Foo
{
public:
    int& get()
    {
        // stuff here
        return myInt;
    }

    const int& get() const
    {
        return const_cast<Foo*>(this)->get();
    }
};

我只使用了第一个，但我看到第二个在某个地方使用过，所以我想知道。

评论// stuff here 可能是一项重要的检查，例如检索表的索引以返回表成员的引用（例如：myInt = myTable[myComputedIndex];），因此我不能将其公开。因此 table 和任何成员都不是 const。

Answer 1

你没有说myInt 来自哪里，最好的答案取决于那个。 有 2+1 种可能的情况：

1) 最常见的情况是myInt 来自类内部指针。

假设这是避免代码重复和强制转换的最佳解决方案。

class Foo{
    int* myIntP;
    ... 
    int& get_impl() const{
       ... lots of code
       return *myIntP; // even if Foo instance is const, *myInt is not
    }
public:
    int& get(){return get_impl();}
    const int& get() const{return get_impl();}
};

上面的这种情况适用于指针数组和（大多数）智能指针。

2) 另一种常见情况是myInt 是引用或值成员，那么前面的解决方案就行不通了。 但它也是根本不需要getter 的情况。 在这种情况下不要使用吸气剂。

class Foo{
     public:
     int myInt; // or int& myInt;
};

完成！ :)

3) @Aconcagua 指出的第三种情况，即内部固定数组的情况。在那种情况下，这是一个折腾，这真的取决于你在做什么，如果找到索引真的是问题，那么可以将其排除在外。但目前尚不清楚应用程序是什么：

class Foo{
    int myInts[32];
    ... 
    int complicated_index() const{...long code...}
public:
    int& get(){return myInts[complicated_index()];}
    const int& get() const{return myInts[complicated_index()];}
};

我的意思是，了解问题，不要过度设计。 const_cast 或模板不需要解决这个问题。

---

完整的工作代码如下：

class Foo{
    int* myIntP;
    int& get_impl() const{
       return *myIntP; // even if Foo instance is const, *myInt is not
    }
public:
    int& get(){return get_impl();}
    const int& get() const{return get_impl();}

    Foo() : myIntP(new int(0)){}
    ~Foo(){delete myIntP;}
};

#include<cassert>

int main(){
    Foo f1; 
    f1.get() = 5;
    assert( f1.get() == 5 );

    Foo const f2;
//    f2.get() = 5; // compile error
    assert( f2.get() == 0 );    
    return 0;
}

Answer 2

如果您必须创建一个与 const 无关并避免重复的函数，那么一种巧妙的方法是将实现委托给模板，例如

class Foo {
private: 

    int my_int;
    template <typename ThisPtr>
    static auto& get(ThisPtr this_ptr) { 
        return this_ptr->my_int;
    }

public:
    int& get() {
        return get(this);
    }

    const int& get() const {
        return get(this);
    }
};

这样你就不用担心在这种情况下使用const_cast、mutable 和其他试图减少代码重复的东西。如果出现错误，编译器会通知您。

Answer 3

忽略是否真的需要 getter 的问题，在const 和非const 方法中复制功能时，最好的解决方案是让非const 方法调用const 方法和抛弃结果的const-ness（即您在问题中提出的两个备选方案中的第一个）。

原因很简单：如果反其道而行之（使用非const 方法中的逻辑），您可能会意外修改const 对象，而编译器不会捕捉到它在编译时（因为该方法未声明 const） - 这将具有未定义的行为。

当然，如果“getter”实际上不是一个 getter（即，如果它正在做一些比仅仅返回对私有字段的引用更复杂的事情），这只是一个问题。

此外，如果您不受 C++11 的限制，Curious 在他们的回答中提出的基于模板的解决方案是避免此问题的另一种方法。

Answer 4

当您打算访问更复杂的内部结构时（通过您的编辑澄清；例如像 std::vector 那样为内部数组提供operator[](size_t index)），那么您必须确保不调用 undefined通过修改潜在的 const 对象来行为。

第二种方法这样做的风险更高：

int& get()
{
    // stuff here: if you modify the object, the compiler won't warn you!
    // but you will modify a const object, if the other getter is called on one!!!
    return myInt;
}

在第一个变体中，您是安全的（除非您在这里也使用const_cast，这现在真的很糟糕......），这是这种方法的优势：

const int& get() const
{
    // stuff here: you cannot modify by accident...
    // if you try, the compiler will complain about
    return myInt;
}

如果你真的需要修改非常量getter中的对象，你无论如何都不能有一个通用的实现......

Answer 5

使用一个比另一个有什么优势：...

不，两者都不好，因为它们违反了数据封装原则。

在您的示例中，您应该将myInt 设为公共成员。 在这种情况下使用吸气剂根本没有任何优势。

如果你真的想要（需要）getter 和 setter 函数，它们应该如下所示：

class Foo
{
private: 
    mutable int myInt_;
 // ^^^^^^^ Allows lazy initialization from within the const getter,
 //         simply omit that if you dont need it.

public:
    void myInt(int value)
    {
        // Do other stuff ...
        myInt = value;
        // Do more stuff ...
    }

    const int& myInt() const
    {
        // Do other stuff ...
        return myInt_;
    }
}

Answer 6

通过非 const 访问路径修改 const 对象 [...] 会导致未定义的行为。

（来源：http://en.cppreference.com/w/cpp/language/const_cast）

这意味着如果 myInt 实际上是 Foo 的 const 成员，第一个版本可能会导致未定义的行为：

class Foo
{
    int const myInt;
public:
    const int& get() const
    {
        return myInt;
    }
    int& get()
    {
        return const_cast<int&>(static_cast<const Foo*>(this)->get());
    }
};
int main()
{
    Foo f;
    f.get() = 10; // this compiles, but it is undefined behavior
}

第二个版本无法编译，因为get 的非常量版本格式不正确：

class Foo
{
    int const myInt;
public:
    int& get()
    {
        return myInt;
        // this will not compile, you cannot return a const member
        // from a non-const member function
    }
    const int& get() const
    {
        return const_cast<Foo*>(this)->get();
    }
};
int main()
{
    Foo f;
    f.get() = 10;  // get() is ill-formed, so this does not compile
}

这个版本实际上是 Scott Meyers 在Effective C++中Avoid Duplication in const and Non-const Member Function下推荐的。