메이어보다 조금 더 장황하지만, 나는 이것을 할 수 있습니다 :

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); }
};

private 메소드는 const 인스턴스에 대해 non-const Z &를 리턴하는 바람직하지 않은 특성을 가지므로 private입니다. 전용 메소드는 외부 인터페이스의 불변을 깰 수 있습니다 (이 경우 원하는 불변은 “const 객체는 그것을 통해 얻은 객체에 대한 참조를 통해 수정할 수 없습니다”).

주석은 패턴의 일부입니다-_getZ의 인터페이스는 (접근자를 제외하고는) 그것을 호출하는 것이 결코 유효하지 않다고 지정합니다. 더 작거나 빠른 코드를 생성합니다. 메소드를 호출하는 것은 const_cast를 사용하여 접근 자 중 하나를 호출하는 것과 동일하며 그렇게하지 않으려 고합니다. 오류를 명백하게하는 것에 대해 걱정이된다면 (그리고 그것은 공정한 목표입니다), _getZ 대신 const_cast_getZ를 호출하십시오.

그건 그렇고, Meyers의 솔루션에 감사드립니다. 나는 철학적으로 반대하지 않습니다. 개인적으로, 나는 약간의 제어 된 반복과 라인 노이즈처럼 보이는 방법에 대해 엄격하게 통제 된 특정 상황에서만 호출되어야하는 개인용 방법을 선호합니다. 독을 골라 내십시오.

[편집 : Kevin은 _getZ가 getZ와 같은 방식으로 const-specialized 된 추가 메소드 (예 : generateZ)를 호출 할 수 있다고 올바르게 지적했습니다. 이 경우 _getZ는 const Z &를보고 리턴하기 전에 const_cast해야합니다. 상용구 접근자가 모든 것을 감시하기 때문에 여전히 안전하지만 그것이 안전하다는 것은 눈에 띄지 않습니다. 또한 그렇게하면 나중에 const를 반환하도록 generateZ를 변경하면 항상 const를 반환하도록 getZ를 변경해야하지만 컴파일러는 그렇게 지시하지 않습니다.

컴파일러에 대한 후자의 점은 Meyers의 권장 패턴에도 해당되지만 명백하지 않은 const_cast에 대한 첫 번째 점은 그렇지 않습니다. 따라서 균형에서 _getZ가 반환 값으로 const_cast가 필요한 것으로 판명되면이 패턴은 Meyers보다 많은 가치를 잃습니다. Meyers와 비교할 때 단점이 있기 때문에 그 상황에서 그에게로 전환 할 것이라고 생각합니다. 하나에서 다른 것으로 리팩토링하는 것은 쉽다. 유효하지 않은 코드와 상용구 만 _getZ를 호출하기 때문에 클래스의 다른 유효한 코드에는 영향을 미치지 않는다.

답변

class X {

private:

    std::vector<Z> v;

    template<typename InstanceType>
    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);
    }

};

#include <vector>

class Z
{
    // details
};

class X
{
    std::vector<Z> vecZ;

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

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

#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 );
}