如何删除类似const和非const成员函数之间的代码重复？

C++ 17已经更新了这个问题的最佳答案:

T const & f() const {
    return something_complicated();
}
T & f() {
    return const_cast(std::as_const(*this).f());
}

这有以下优点:

显而易见的是什么

具有最小的代码开销 - 它适合单行

难以出错(只能volatile意外抛弃,但是volatile难得一见)

如果你想要完整的扣除路线,那么可以通过辅助功能来完成

template
constexpr T & as_mutable(T const & value) noexcept {
    return const_cast(value);
}
template
constexpr T * as_mutable(T const * value) noexcept {
    return const_cast(value);
}
template
constexpr T * as_mutable(T * value) noexcept {
    return value;
}
template
void as_mutable(T const &&) = delete;

现在你甚至不能搞砸了volatile,用法看起来像

decltype(auto) f() const {
    return something_complicated();
}
decltype(auto) f() {
    return as_mutable(std::as_const(*this).f());
}

比迈耶斯更冗长,但我可能会这样做:

class X {

    private:

    // This method MUST NOT be called except from boilerplate accessors.
    Z &_getZ(size_t index) const {
        return something;
    }

    // boilerplate accessors
    public:
    Z &getZ(size_t index)             { return _getZ(index); }
    const Z &getZ(size_t index) const { return _getZ(index); }
};

私有方法具有不受欢迎的属性,它返回一个非const Z&for const实例,这就是它为私有的原因.私有方法可能会破坏外部接口的不变量(在这种情况下,所需的不变量是"const对象不能通过它获得的引用修改为它具有的对象").

请注意,注释是模式的一部分 - _getZ的接口指定调用它永远无效(显然除了访问器):无论如何这样做都没有可能的好处,因为它输入了1个字符,而不是导致更小或更快的代码.调用该方法相当于使用const_cast调用其中一个访问器,您也不希望这样做.如果你担心明显错误(这是一个公平的目标),那么称之为const_cast_getZ而不是_getZ.

顺便说一句,我很欣赏迈耶斯的解决方案.我对它没有任何哲学上的反对意见.但就个人而言,我更喜欢一点点的受控重复,以及一种只能在某些严格控制的情况下调用的私有方法,而不是一种看起来像线路噪声的方法.选择你的毒药并坚持下去.

[编辑:Kevin正确地指出_getZ可能想要调用另一个方法(比如generateZ),这个方法与getZ一样是const专用的.在这种情况下,_getZ会看到一个const Z&并且必须在返回之前进行const_cast.这仍然是安全的,因为样板访问器可以控制所有内容,但是它的安全性并不明显.此外,如果你这样做,然后将generateZ更改为始终返回const,那么你还需要将getZ更改为始终返回const,但编译器不会告诉您这样做.

关于编译器的后一点也适用于Meyers的推荐模式,但关于非显而易见的const_cast的第一点不是.所以总的来说,我认为如果_getZ结果需要一个const_cast作为其返回值,那么这种模式会失去很多超过Meyers的价值.由于与Meyers相比它也有缺点,我想我会在那种情况下转向他.从一个重构到另一个很容易 - 它不会影响类中的任何其他有效代码,因为只有无效代码和样板文件调用_getZ.

好问题和好答案.我有另一种解决方案,它不使用强制转换:

class X {

private:

    std::vector v;

    template
    static auto get(InstanceType& instance, std::size_t i) -> decltype(instance.get(i)) {
        // massive amounts of code for validating index
        // the instance variable has to be used to access class members
        return instance.v[i];
    }

public:

    const Z& get(std::size_t i) const {
        return get(*this, i);
    }

    Z& get(std::size_t i) {
        return get(*this, i);
    }

};

但是,它具有需要静态成员的丑陋以及在其中使用instance变量的需要.

我没有考虑这个解决方案的所有可能(负面)含义.如果有的话请告诉我.

您也可以使用模板解决此问题.这个解决方案稍微丑陋(但丑陋隐藏在.cpp文件中)但它确实提供了constness的编译器检查,并且没有代码重复.

.h文件:

#include 

class Z
{
    // details
};

class X
{
    std::vector vecZ;

public:
    const std::vector& GetVector() const { return vecZ; }
    std::vector& GetVector() { return vecZ; }

    Z& GetZ( size_t index );
    const Z& GetZ( size_t index ) const;
};

.cpp文件:

#include "constnonconst.h"

template< class ParentPtr, class Child >
Child& GetZImpl( ParentPtr parent, size_t index )
{
    // ... massive amounts of code ...

    // Note you may only use methods of X here that are
    // available in both const and non-const varieties.

    Child& ret = parent->GetVector()[index];

    // ... even more code ...

    return ret;
}

Z& X::GetZ( size_t index )
{
    return GetZImpl< X*, Z >( this, index );
}

const Z& X::GetZ( size_t index ) const
{
    return GetZImpl< const X*, const Z >( this, index );
}

我可以看到的主要缺点是,因为该方法的所有复杂实现都在一个全局函数中,您需要使用上面的GetVector()等公共方法来获取X的成员(其中总是需要一个const和非const版本)或者你可以使这个功能成为朋友.但我不喜欢朋友.

[编辑:删除了在测试期间添加的cstdio不需要的包含.]