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

编程问答 2022-06-15

问题描述

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

在vector<T>类的帮助下，类似HugeTpool的接口在基础T_ref数据结构上被仿真。 T和T_ref仅延迟*_data内存的管理。 T_ref指向的内存不得在T_ref obj销毁后释放。这两个类仅延迟复制和移动构造函数，析构函数和赋值运算符，其余的相同。

由于T和T_ref本质上是相同的，因此我需要T和T_ref才能互操作。这需要很多胶水和样板代码。另外，由于两个类都具有相同的接口（和成员函数），因此有很多代码重复。有解决此问题的方法吗？我已经考虑了继承，但是它似乎不太适合这种情况。

这是我的问题的简化版本，实际上，我有很多_ref类，并且它们需要彼此可互操作。完成此操作所需的粘合代码很快就会失控。

解决方法

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

如果不是这种情况，请编写一个borrow_ptr模板，该模板与unique_ptr非常相似，除了它还会跟踪它是否不拥有它的元素。然后在borrow_ptr<size_t> data;中使用T，并丢弃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
};
boilerplatec++code-duplicationinheritanceinheritance