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

这是一组实现一种适配器模式的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和nonconst指针都作为类成员，并通过重载的构造函数设置了一个或另一个来解决了此类问题。这浪费了空间并且显得笨拙。有没有更优雅的解决方案？

最佳答案

是的，可以这样做：

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或non-const状态。除非模板类型为const，否则Reader会持有一个非const引用，但不允许您对其进行写入，因此您在需要写入时可以像使用CHolderReaderWriter一样对其进行扩展。