如何保留OldClass并替换为NewClass，避免成员访问代码重复？

针对你遇到的新旧类共存导致的代码重复、类型转换冗余问题，以下几个方案可以优雅解决，同时保证后续删除OldClass的成本极低：

方案1：封装统一的成员操作函数 #

把针对NewClass和OldClass的成员设置/读取逻辑，分别封装到重载函数里，再提供一个统一的入口函数处理模式判断和类型转换。这样业务代码里只需要调用统一入口，不用重复写if-else和类型转换。

示例代码：

// 针对NewClass的成员操作实现
void operateMembers(NewClass* obj, int valA, bool valB) {
    obj->setMemberA(valA);
    obj->setMemberB(valB);
    // 其他所有成员的操作都写在这里
}

// 针对OldClass的成员操作实现（注意处理类型差异，比如OldClass的memberB是int）
void operateMembers(OldClass* obj, int valA, bool valB) {
    obj->setMemberA(valA);
    obj->setMemberB(valB ? 1 : 0); // 根据实际类型做适配转换
    // 其他成员对应实现
}

// 统一入口，业务代码只需要调用这个函数
void operateCommonMembers(CommonAncestor* c, int valA, bool valB, bool newMode) {
    if (newMode) {
        operateMembers(dynamic_cast<NewClass*>(c), valA, valB);
    } else {
        operateMembers(dynamic_cast<OldClass*>(c), valA, valB);
    }
}

后续清理：删除OldClass时，只需要删掉operateMembers(OldClass*)重载函数，以及统一入口里的else分支即可，业务代码无需修改。

方案2：用适配器对齐接口 #

给OldClass写一个适配器类，让它的接口和NewClass完全对齐，这样可以用统一的接口操作两种对象，避免重复逻辑。

示例代码：

// OldClass适配器，对齐NewClass的接口
class OldClassAdapter {
private:
    OldClass* m_oldObj;
public:
    explicit OldClassAdapter(OldClass* obj) : m_oldObj(obj) {}

    // 完全复制NewClass的接口
    void setMemberA(int val) {
        m_oldObj->setMemberA(val);
    }

    void setMemberB(bool val) {
        // 适配类型差异，比如把bool转成OldClass需要的int
        m_oldObj->setMemberB(val ? 1 : 0);
    }

    // 其他成员的适配方法同理
};

// 通用操作函数，支持任何拥有对应接口的对象
template<typename T>
void operateMembers(T& obj, int valA, bool valB) {
    obj.setMemberA(valA);
    obj.setMemberB(valB);
    // 统一处理所有成员
}

// 业务代码中的调用
void process(CommonAncestor* c, bool newMode) {
    if (newMode) {
        auto* newObj = dynamic_cast<NewClass*>(c);
        operateMembers(*newObj, 10, true);
    } else {
        auto* oldObj = dynamic_cast<OldClass*>(c);
        OldClassAdapter adapter(oldObj);
        operateMembers(adapter, 10, true);
    }
}

后续清理：删除OldClass时，直接删掉OldClassAdapter类和对应的分支，通用操作函数和业务代码无需修改。

方案3：复用NewClass转OldClass的构造逻辑 #

利用你已经实现的「用NewClass构造OldClass」的能力，统一以NewClass为操作基准，先把对象转换成NewClass的实例，完成所有操作后再根据模式写回原对象。

示例代码：

void operateCommonMembers(CommonAncestor* c, int valA, bool valB, bool newMode) {
    // 先把对象转换成NewClass实例
    NewClass temp;
    if (newMode) {
        temp = *dynamic_cast<NewClass*>(c);
    } else {
        temp = *dynamic_cast<OldClass*>(c); // 假设支持从OldClass转NewClass，或者你自己实现转换逻辑
    }

    // 统一操作NewClass的成员，只写一遍逻辑
    temp.setMemberA(valA);
    temp.setMemberB(valB);
    // 其他成员操作

    // 根据模式写回原对象
    if (newMode) {
        *dynamic_cast<NewClass*>(c) = temp;
    } else {
        *dynamic_cast<OldClass*>(c) = OldClass(temp); // 用你已有的构造方法
    }
}

后续清理：删除OldClass时，只需要删掉转换和写回的else分支，核心的成员操作逻辑完全保留。

核心原则 #

不管选哪种方案，核心都是把和OldClass相关的逻辑集中到少数模块，避免散落在整个代码库中。这样后续删除OldClass时，只需要清理这些集中的代码，业务层代码几乎不用改动，能最小化重构成本。

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