c++ - 结合了 const 和非常量引用数据成员的单一类

Question

这是一组实现一种适配器模式的 C++ 类:

#include <iostream>

class Cfoo
{
public:
    explicit Cfoo(int i):i_(i){}
    void SetI(int i){ i_ = i; }
    int GetI()const{ return(i_); }
private:
    int i_;
};

class CfooHolderConst
{
public:
    explicit  CfooHolderConst(const Cfoo& foo):foo_(foo){}
    int GetI()const{ return( foo_.GetI() ); }
private:
    const Cfoo& foo_;
};

class CfooHolderNonConst
{
public:
    explicit CfooHolderNonConst(Cfoo& foo):foo_(foo){};
    int GetI()const{ return( foo_.GetI() ); }
    void SetI(int i){ foo_.SetI(i); }
private:
    Cfoo& foo_;
};

int main(  int argc, char* argv[] )
{
    const Cfoo myConstFoo(42);
    CfooHolderConst myConstFooHolder(myConstFoo);
    std::cout << myConstFooHolder.GetI() << std::endl;

    Cfoo myNonConstFoo(1);
    CfooHolderNonConst myNonConstFooHolder(myNonConstFoo);
    myNonConstFooHolder.SetI(42);
    std::cout << myConstFooHolder.GetI() << std::endl;

    return(0);
}

我想将 CfooHolderNonConst 和 CFooHolderConst 合并到一个类中，或者失败时，从另一个继承一个。这里对Cfoo的引用是个问题，因为在CFooHolderConst中需要定义为const Cfoo&，而在CfooHolderNonConst中需要定义为Cfoo&。

这与这里的 interator/const_iterator 有类似的问题: How to avoid code duplication implementing const and non-const iterators?

...但我希望因为这不必满足 STL 迭代器要求，所以可能有更简单的解决方案。

在过去，我通过将 const 和非 const 指针都作为类成员，并从重载的构造函数中设置一个或另一个来解决此类问题。这既浪费空间又显得笨拙。有更优雅的解决方案吗？

Answer 1

是的，可以做到:

template< typename T > CHolderReader
{
 public: 
    explicit  CHolderBase( T& t):t_(t){}
    int Get()const { return t_.GetI(); }

 protected:
    ~CHolderReader() {}

 protected:
    T& t_;
};

template< typename T > CHolderReaderWriter : public CHolderReader< T >
{
public:
   void Set( int i)
   {
       t_.SetI(i);
   }
};

typedef CHolderReader<const Cfoo> CFooHolderConst;
typedef CHolderReaderWriter<Cfoo> CFooHolderNonConst;    

实际上，这是一个示例，您可以在其中将基础数据的获取包装在其 const 或非 const 状态中。 Reader 拥有非常量引用，除非模板化类型是 const，但不允许您写入它，因此当您确实需要写入时，您可以像使用 CHolderReaderWriter 一样扩展它。