当 class T 和 T_ref 仅在构造函数和析构函数上不同时，如何优雅地避免代码重复？

Question

class HugeTpool{            // Owner of *_dataPool memory
    int x;
    int y; 
//   ...  etc;      // Data Members (many)
   size_t* _dataPool;        // pointer to huge contiguous data

    T_ref operator[](int i){    // used to emulate vector<T> like behaviour
    /* Implementation  details*/
    return T_ref_Obj;
    }
};

class T{                    // Owner of *_data memory
    int a;
//    ... etc;       //  Data Members   (few)
    size_t* _data;           // pointer to small contiguous data
   
    T operator+(T){}
//      ... etc;     //  Member functions

// Glue code to enable interoperability with class T_ref
    T operator+(T_ref){}
//    ... etc;
};

class T_ref{                // A reference type, to emulate T class interfaces 
    int a;
//    ... etc;        //  Data Members  (Identical to class T)  
    size_t* _data;          // Does not own *_data memory, only references it

    T operator+(T_ref);
//      ... etc;        //  Member functions (Identical to class T)    

// Glue code to enable interoperability with class T
    T operator+(T){}
//    ... etc;
};

这里在 T_ref class 的帮助下，在底层 HugeTpool 数据结构上模拟了类似 vector<T> 的接口。 T 和 T_ref 仅延迟 *_data 内存的管理。 T_ref 指向的内存不能在 T_ref 对象销毁时释放。两个classes只是在copy&move构造函数、析构函数和赋值运算符上defer，其他都是一样的。

由于T和T_ref本质上是一样的，我需要T和T_ref可以互操作。这需要大量的胶水和样板代码。此外，由于 class 具有相同的接口（和成员函数），因此存在大量代码重复。有解决这个问题的优雅方法吗？我考虑过继承，但它似乎不太适合这种情况。

这是我的问题的简化版本，在实践中，我有很多 _ref classes 并且它们需要相互操作。完成此任务所需的胶水代码很快就会失控。

Answer 1

可能您应该使用 T & 而不是 T_ref，或者如果您需要它是常规类型，std::reference_wrapper<T>.

如果不是这种情况，请编写一个 borrow_ptr 模板，与 unique_ptr 非常相似，只是如果它不拥有它的元素，它也会进行跟踪。然后在T中使用borrow_ptr<size_t> data;，丢弃T_ref.

草图

template <typename T>
class borrow_ptr 
{
    std::unique_ptr<T> data;
    bool owns;
public:
    ~borrow_ptr() { if (!owns) data.release(); }
    // public surface of unique_ptr
};

当 class T 和 T_ref 仅在构造函数和析构函数上不同时，如何优雅地避免代码重复？

How to elegantly avoid code duplication, when class T and T_ref only differ in the constructors & destructors?

c++

inheritance

code-duplication

boilerplate