c++中的向量，代理类和点运算符

Vector, proxy class and dot operator in C++

本文关键字：点运算 运算符 代理 向量 c++      更新时间：2023-10-16

关于c++中自定义Vector类的问题。

template <typename T>
class Vector
{ ...
  private:
    T * mData; int mSize;
  public:
    proxy_element operator[](const size_type index) { return proxy_element(*this, index); }
    const T& operator[](const size_type index) const {   return mData[index]; }
};
template <typename T>
class proxy_element
{  ...
   proxy_element(Vector<T>& m_parent, const size_type index);
   proxy_elem& operator=(const T& rhs); // modifies data so invalidate on other memories
   bool operator==(const proxy_elem& rhs) // only read, just copy data back.
   ...
}

使用proxy_element类的原因是为了区分和优化读写操作，考虑到矢量数据也可以驻留在GPU设备内存中。因此，任何读操作都只需要将最新的数据复制回来(如果有的话)，但读写操作需要使设备内存中的数据失效。

这种设计在元素类型为基元时效果很好。但是对于更复杂的元素类型，有一个问题:

struct person{ int age; double salary; }; 
int main()
{
   Vector<person> v1(10); 
   v[1].age = 10; // gives error as operator[] returns proxy_element for which "." operator has no meaning
}

很显然，c++中不能重载"。"操作符。一个明显的解决方案是不使用proxy_elem，只返回常规引用(T &)，假设每次访问都是写访问，但由于明显的原因，这将是低效的。

是否有其他工作可以让我"。"操作符工作，同时保留区分读和写操作的能力?

一种选择是使这样的数据类型不可变(私有成员变量，由构造函数初始化，唯一的setter是类的赋值操作符)。这样，更改任何内容的唯一方法是分配给类的整个实例，这可以通过proxy_element进行引导。

Marcelo Cantos的答案当然是正确的做事方式。然而，专业化有一个复杂而疯狂的变通方法。(不建议)。

//if it's a class, inherit from it to get public members
template<class T> 
class proxy_element : public T {
    ...
    proxy_element(Vector<T>& m_parent, const size_type index);
    proxy_elem& operator=(const T& rhs); // modifies data so invalidate on other memories
    bool operator==(const proxy_elem& rhs) // only read, just copy data back.
    ...
};
//pretend to be a pointer
template<> 
class proxy_element<T*> {
    ...
    proxy_element(Vector<T>& m_parent, const size_type index);
    proxy_elem& operator=(const T& rhs); // modifies data so invalidate on other memories
    bool operator==(const proxy_elem& rhs) // only read, just copy data back.
    ...
};
//otherwise, pretend to be primitive
#define primitive_proxy(T) 
template<> class proxy_element {
    ...
    proxy_element(Vector<T>& m_parent, const size_type index);
    proxy_elem& operator=(const T& rhs); // modifies data so invalidate on other memories
    bool operator==(const proxy_elem& rhs) // only read, just copy data back.
    ...
};
primitive_proxy(char)
primitive_proxy(unsigned char)
primitive_proxy(signed char) //this is distinct from char remember
primitive_proxy(short)
primitive_proxy(unsigned short)
primitive_proxy(int)
primitive_proxy(unsigned int)
primitive_proxy(long)
primitive_proxy(unsigned long)
primitive_proxy(long long)
primitive_proxy(unsigned long long)
primitive_proxy(char16_t) //if GCC
primitive_proxy(char32_t) //if GCC
primitive_proxy(wchar_t)
primitive_proxy(float)
primitive_proxy(double)
primitive_proxy(long double)
相关文章：