C+中的向量、代理类和点运算符+； 一个与C++中的自定义向量类有关的问题。 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. ... } 模板 类向量 { ... 私人： T*mData；int-mSize； 公众： proxy_元素运算符[]（常量大小_类型索引）{返回proxy_元素（*this，index）；} 常量T&运算符[]（常量大小_类型索引）常量{return mData[index]；} }; 模板 类代理元素 { ... 代理元素（向量和m_父元素，常量大小类型索引）； proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效 bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。 ... }

使用proxy_元素类的原因是为了区分和优化读写操作，考虑到矢量数据也可以驻留在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
}

struct person{int age；双薪；}；
int main（）
{
向量v1（10）；
v[1].age=10；//由于运算符[]返回的代理元素“.”运算符对其没有意义，因此给出错误
}

<> AfAIK，“.”运算符不能在C++中超载。一个明显的解决方案是不使用proxy元素，只返回正则引用（T&），假设每个访问都是写访问，但由于明显的原因，这将是低效的

---

是否还有其他工作可以让我在保留区分读操作和写操作的能力的同时使用“.”运算符？

一个选项是使此类数据类型不可变（私有成员变量，由构造函数初始化，唯一的设置器是类的赋值运算符）。这样，更改任何内容的唯一方法是分配给类的整个实例，该实例可以通过代理元素进行传递。

一个选项是使此类数据类型不可变（私有成员变量，由构造函数初始化，唯一的设置器是类的赋值运算符）。通过这种方式，更改任何内容的唯一方法是分配给类的整个实例，该实例可以通过proxy_元素进行传递。

Marcelo Cantos的答案当然是正确的操作方法。然而，专业化有一个复杂而疯狂的解决方法。（不推荐。）

//如果它是一个类，则从中继承以获取公共成员
模板
类代理_元素：public T{
...
代理元素（向量和m_父元素，常量大小类型索引）；
proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效
bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。
...
};
//假装是一个指针
模板
类代理元素{
...
代理元素（向量和m_父元素，常量大小类型索引）；
proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效
bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。
...
};
//否则，假装原始
#定义原语_代理（T）\
模板类代理元素{
...
代理元素（向量和m_父元素，常量大小类型索引）；
proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效
bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。
...
};
原语_代理（char）
原语_代理（无符号字符）
primitive_proxy（signed char）//这与char memory不同
原语_代理（短）
基元_代理（无符号短）
原语_代理（int）
基元_代理（无符号整数）
原语_代理（长）
基元_代理（无符号长）
原语_代理（长）
基元_代理（无符号长）
基元代理（char16\u t）//如果是GCC
基元代理（char32\u t）//如果是GCC
基元代理（wchar\u t）
原语_代理（浮点）
原语_代理（双）
原语_代理（长双精度）
马塞洛·坎托斯的答案当然是正确的做事方式。然而，专业化有一个复杂而疯狂的解决方法。（不推荐。）

//如果它是一个类，则从中继承以获取公共成员
模板
类代理_元素：public T{
...
代理元素（向量和m_父元素，常量大小类型索引）；
proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效
bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。
...
};
//假装是一个指针
模板
类代理元素{
...
代理元素（向量和m_父元素，常量大小类型索引）；
proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效
bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。
...
};
//否则，假装原始
#定义原语_代理（T）\
模板类代理元素{
...
代理元素（向量和m_父元素，常量大小类型索引）；
proxy_elem&operator=（const T&rhs）；//修改数据，使其他内存无效
bool运算符==（const proxy_elem&rhs）//仅读取，仅将数据复制回。
...
};
原语_代理（char）
原语_代理（无符号字符）
primitive_proxy（signed char）//这与char memory不同
原语_代理（短）
基元_代理（无符号短）
原语_代理（int）
基元_代理（无符号整数）
原语_代理（长）
基元_代理（无符号长）
原语_代理（长）
基元_代理（无符号长）
基元代理（char16\u t）//如果是GCC
基元代理（char32\u t）//如果是GCC
基元代理（wchar\u t）
原语_代理（浮点）
原语_代理（双）
原语_代理（长双精度）
在更复杂的类型中是否可以使用指针？然后你可以通过重载操作符->来解决你的问题。@TeaWolf:谢谢。我知道这个选项，但我一直在寻找使它适用于常规类型的方法。在更复杂的类型中使用指针可能吗？那你就不知道了
//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)