如何将Property类模板绑定到已声明的私有成员变量？

需求说明 #

我需要实现一个Property模板类，使其能够直接操作类中已声明的私有成员变量，而非维护自身的内部存储。按照OOP规范，私有成员应通过get/set方法访问，但手动为每个成员编写这类方法过于繁琐，希望借助模板自动提供get/set能力。

现有Property模板代码 #

#pragma once

#include <iostream>

template<class T>
class Property 
{
public:
    Property() : m_value() {}
    Property( const T& value ) : m_value(value) {}

    operator const T& () const { return m_value; }

    Property<T>& operator = (const T& value) 
    {
        m_value = value;
        return *this;
    }

    bool operator == (const T& other) const 
    {
        return m_value == other;
    }

    bool operator != (const T& other) const 
    {
        return !(*this == other);
    }

    bool operator < (const T& other) const 
    {
        return m_value < other;
    }

    bool operator > (const T& other) const 
    {
        return other < m_value;
    }

    bool operator <= (const T& other) const 
    {
        return !(other < m_value);
    }

    bool operator >= (const T& other) const 
    {
        return !(m_value < other);
    }

    template<typename U>
    friend std::ostream& operator<<(std::ostream& os, const Property<U>& property);

private:
    T m_value;
};

template<typename T>
std::ostream& operator<<(std::ostream& os, const Property<T>& property) 
{
    os << property.m_value;
    return os;
}

typedef Property<int> IntProperty;

目标绑定场景 #

希望将模板绑定到类的私有成员i_prop，让IProp直接操作该变量：

private:
  int i_prop;

public:
  Property<int> IProp ; // 需要操作i_prop

曾尝试添加以下构造函数但未成功：

Property( class V& ) : V( m_value ) {}

解决方案 #

要实现绑定外部私有成员的需求，需修改Property模板，使其存储指向目标变量的指针，而非自身维护值。具体实现如下：

修改后的Property模板 #

#pragma once

#include <iostream>

template<class T>
class Property 
{
public:
    // 构造函数接收指向目标变量的指针
    Property(T* targetPtr) : m_targetPtr(targetPtr) {}

    // 隐式转换为目标类型的引用，实现get功能
    operator const T& () const { return *m_targetPtr; }

    // 重载赋值运算符，实现set功能
    Property<T>& operator = (const T& value) 
    {
        *m_targetPtr = value;
        return *this;
    }

    // 重载比较运算符，均操作目标变量
    bool operator == (const T& other) const 
    {
        return *m_targetPtr == other;
    }

    bool operator != (const T& other) const 
    {
        return !(*this == other);
    }

    bool operator < (const T& other) const 
    {
        return *m_targetPtr < other;
    }

    bool operator > (const T& other) const 
    {
        return other < *m_targetPtr;
    }

    bool operator <= (const T& other) const 
    {
        return !(other < *m_targetPtr);
    }

    bool operator >= (const T& other) const 
    {
        return !(*m_targetPtr < other);
    }

    template<typename U>
    friend std::ostream& operator<<(std::ostream& os, const Property<U>& property);

private:
    T* m_targetPtr; // 存储指向外部私有成员的指针
};

template<typename T>
std::ostream& operator<<(std::ostream& os, const Property<T>& property) 
{
    os << *property.m_targetPtr;
    return os;
}

typedef Property<int> IntProperty;

绑定私有成员的使用示例 #

在类的构造函数中初始化Property，传入私有成员的地址：

class MyClass {
private:
    int i_prop;
    float a_float;

public:
    Property<int> IProp;
    Property<float> AFloat;

    // 初始化Property，绑定到对应私有成员
    MyClass() : IProp(&i_prop), AFloat(&a_float) {}

    // 自定义拷贝构造，确保拷贝后的Property指向当前对象的私有成员
    MyClass(const MyClass& other) 
        : i_prop(other.i_prop), a_float(other.a_float),
          IProp(&i_prop), AFloat(&a_float) {}

    // 自定义赋值运算符，无需修改Property指针（指向的成员地址不变）
    MyClass& operator=(const MyClass& other) {
        if (this != &other) {
            i_prop = other.i_prop;
            a_float = other.a_float;
        }
        return *this;
    }
};

使用效果 #

MyClass obj;
obj.IProp = 42;         // 等价于修改obj的私有成员i_prop
int val = obj.IProp;    // 等价于读取obj的私有成员i_prop
std::cout << obj.IProp; // 输出i_prop的值

obj.AFloat = 3.14f;
float f_val = obj.AFloat;

关键说明 #

• 原模板的问题在于维护自身的m_value，修改后通过指针直接操作外部目标变量，实现了与私有成员的绑定。
• 由于在类内部初始化Property时可以直接获取私有成员的地址，因此无需破坏封装性。
• 若类涉及拷贝或赋值操作，需自定义拷贝构造函数，确保新对象的Property指向自身的私有成员，避免多个对象的Property指向同一内存地址。

内容的提问来源于stack exchange，提问作者GrooverMD