C++赋值运算符为何修改const引用参数？求技术解答

核心原因 #

你遇到的const引用参数被意外修改的问题，本质是浅拷贝导致的指针共享+错误的资源管理逻辑：

• 若Directory包含裸指针（如parentDirectory），赋值时的浅拷贝会让多个对象共享同一内存地址，修改其中一个对象的指针指向或其指向的内容，会间接影响其他对象。
• 若innerDirectories的元素拷贝/析构函数存在副作用（比如错误修改父对象成员），会在vector赋值（涉及旧元素析构、新元素拷贝）时意外修改原const对象。
• 极端情况是代码中存在const_cast修改const对象成员的未定义行为，但编译器通常会给出警告。

可复现代码（还原你的场景） #

#include <string>
#include <vector>
#include <iostream>

class Directory {
public:
    std::string path;
    Directory* parentDirectory;
    std::vector<Directory> innerDirectories;

    Directory(const std::string& p, Directory* parent = nullptr)
        : path(p), parentDirectory(parent) {
        if (parent) parent->innerDirectories.push_back(*this);
    }

    // 错误的拷贝构造：拷贝时将自身添加到原父目录，间接修改原对象
    Directory(const Directory& other)
        : path(other.path), parentDirectory(other.parentDirectory) {
        if (parentDirectory) parentDirectory->innerDirectories.push_back(*this);
    }

    // 有问题的赋值运算符
    Directory& operator=(const Directory& that) {
        if (this == &that) return *this;

        innerDirectories = that.innerDirectories; // 触发拷贝构造，可能修改that
        path = that.path;
        parentDirectory = that.parentDirectory; // 浅拷贝指针，共享父对象

        return *this;
    }

    // 错误的析构函数：清空父对象path
    ~Directory() {
        if (parentDirectory) parentDirectory->path.clear();
    }
};

int main() {
    Directory parent("C:\\parent");
    Directory child("C:\\parent\\child", &parent);

    child = parent; // 执行赋值后，parent的path会被清空

    std::cout << "Parent path: " << parent.path << std::endl;
    std::cout << "Child path: " << child.path << std::endl;
    return 0;
}

正确实现方案 #

要完成父Directory向子Directory的赋值，核心是深拷贝所有资源，并正确管理parentDirectory的指向：

#include <string>
#include <vector>
#include <iostream>
#include <algorithm>

class Directory {
public:
    std::string path;
    Directory* parentDirectory;
    std::vector<Directory> innerDirectories;

    // 基础构造函数
    Directory(const std::string& p, Directory* parent = nullptr)
        : path(p), parentDirectory(parent) {}

    // 深拷贝构造：递归拷贝子目录，修正parent指针为当前对象
    Directory(const Directory& other, Directory* newParent = nullptr)
        : path(other.path), parentDirectory(newParent) {
        for (const auto& dir : other.innerDirectories) {
            innerDirectories.emplace_back(dir, this);
        }
    }

    // 拷贝并交换式赋值：异常安全，简化实现
    Directory& operator=(Directory that) {
        swap(*this, that);
        return *this;
    }

    // 友元swap函数，用于赋值运算符
    friend void swap(Directory& lhs, Directory& rhs) noexcept {
        using std::swap;
        swap(lhs.path, rhs.path);
        swap(lhs.parentDirectory, rhs.parentDirectory);
        swap(lhs.innerDirectories, rhs.innerDirectories);
    }

    // 安全析构：仅清理自身资源，不修改父对象
    ~Directory() = default;

    // 辅助打印函数，验证结构
    void print(int indent = 0) const {
        std::cout << std::string(indent, ' ') << path << '\n';
        for (const auto& dir : innerDirectories) dir.print(indent + 2);
    }
};

int main() {
    // 构建父目录结构
    Directory parent("C:\\parent");
    parent.innerDirectories.emplace_back("C:\\parent\\sub1", &parent);
    parent.innerDirectories.emplace_back("C:\\parent\\sub2", &parent);

    // 子目录
    Directory child("C:\\old_child", nullptr);

    // 赋值：child成为parent的深拷贝
    child = parent;
    // 若需要将child作为其他目录的子对象，手动设置parent
    // child.parentDirectory = &some_other_dir;

    std::cout << "Parent structure:\n";
    parent.print();
    std::cout << "\nChild structure after assignment:\n";
    child.print();

    // 修改child的path，验证不会影响parent
    child.path = "C:\\new_child";
    std::cout << "\nAfter modifying child path:\n";
    std::cout << "Parent path: " << parent.path << '\n';
    std::cout << "Child path: " << child.path << '\n';

    return 0;
}

关键注意事项 #

• 深拷贝递归处理：拷贝子目录时，必须将每个子目录的parentDirectory指向当前对象（this），避免与原对象共享任何子对象或指针。
• 拷贝并交换Idiom：这种赋值方式既保证异常安全，又简化代码逻辑，避免手动处理自我赋值等边界情况。
• 避免裸指针副作用：若需要双向关联父子目录，建议使用std::weak_ptr替代裸指针，避免循环引用和意外修改。

内容的提问来源于stack exchange，提问作者Zoltán Turcsán