C++中调用父嵌套类方法及Argument类联合拷贝构造问题求助

问题根源 #

你的代码存在三个核心问题：

1. 联合包含非平凡类型未管理生命周期：DefaultValues中包含QString（有自定义构造/析构/拷贝逻辑的非平凡类型），C++11及以后允许联合包含这类类型，但必须手动管理其构造、析构和拷贝，否则会触发未定义行为。
2. 缺少活跃成员类型跟踪：联合本身无法记录当前存储的是哪个类型，导致拷贝、析构时无法确定要操作的字段。
3. 跨上下文访问错误：尝试在DefaultValues的拷贝构造函数中调用Argument::getDataType()是无效的——联合对象不属于Argument类的成员函数上下文，无法直接访问外层类的成员函数。

推荐方案：使用C++17 std::variant（类型安全的联合） #

std::variant是标准库提供的类型安全替代方案，自带活跃成员跟踪，自动处理非平凡类型的生命周期，无需手动编写复杂的拷贝/析构逻辑，还能避免构造函数歧义。

#include <variant>
#include <QString>
#include <string>
#include <type_traits>

class Argument {
private:
    // 用variant替代自定义联合，自动管理类型和生命周期
    using DefaultValues = std::variant<bool, char, long long, double, QString>;
    DefaultValues mvDefaultValues;

public:
    // 针对各类型的构造函数，variant会自动匹配对应类型
    Argument(bool val) : mvDefaultValues(val) {}
    Argument(char val) : mvDefaultValues(val) {}
    Argument(long long val) : mvDefaultValues(val) {}
    Argument(double val) : mvDefaultValues(val) {}
    Argument(const QString& val) : mvDefaultValues(val) {}
    Argument(QString&& val) : mvDefaultValues(std::move(val)) {}

    // 拷贝/移动构造、赋值运算符由variant自动生成，无需手动实现
    Argument(const Argument&) = default;
    Argument(Argument&&) = default;
    Argument& operator=(const Argument&) = default;
    Argument& operator=(Argument&&) = default;

    // 获取当前存储的数据类型
    std::string getDataType() const {
        return std::visit([](const auto& val) -> std::string {
            using T = std::decay_t<decltype(val)>;
            if constexpr (std::is_same_v<T, bool>) return "bool";
            else if constexpr (std::is_same_v<T, char>) return "char";
            else if constexpr (std::is_same_v<T, long long>) return "long long";
            else if constexpr (std::is_same_v<T, double>) return "double";
            else if constexpr (std::is_same_v<T, QString>) return "QString";
            else return "unknown";
        }, mvDefaultValues);
    }

    // 示例：重载赋值运算符
    Argument& operator=(bool val) {
        mvDefaultValues = val;
        return *this;
    }
};

兼容方案：手动管理原生联合（不推荐） #

如果必须使用原生联合，需要添加类型标记并手动处理非平凡类型的生命周期：

#include <QString>
#include <string>
#include <utility>

class Argument {
public:
    // 枚举标记当前活跃的成员类型
    enum class DataType { Bool, Char, LongLong, Double, QString };

private:
    union DefaultValues {
        bool mbDefault;
        char mchDefault;
        long long mllDefault;
        double mdDefault;
        QString msDefault;

        // 空构造/析构，手动管理非平凡类型的生命周期
        DefaultValues() {}
        ~DefaultValues() {}
    } mvDefaultValues;

    DataType mActiveType;

    // 辅助函数：析构当前活跃的非平凡类型
    void destroyActiveMember() {
        if (mActiveType == DataType::QString) {
            mvDefaultValues.msDefault.~QString();
        }
    }

public:
    // 各类型构造函数
    Argument(bool val) : mActiveType(DataType::Bool) {
        mvDefaultValues.mbDefault = val;
    }

    Argument(char val) : mActiveType(DataType::Char) {
        mvDefaultValues.mchDefault = val;
    }

    Argument(long long val) : mActiveType(DataType::LongLong) {
        mvDefaultValues.mllDefault = val;
    }

    Argument(double val) : mActiveType(DataType::Double) {
        mvDefaultValues.mdDefault = val;
    }

    Argument(const QString& val) : mActiveType(DataType::QString) {
        // 定位new构造QString
        new (&mvDefaultValues.msDefault) QString(val);
    }

    Argument(QString&& val) : mActiveType(DataType::QString) {
        new (&mvDefaultValues.msDefault) QString(std::move(val));
    }

    // 拷贝构造函数
    Argument(const Argument& other) : mActiveType(other.mActiveType) {
        switch (mActiveType) {
            case DataType::Bool: mvDefaultValues.mbDefault = other.mvDefaultValues.mbDefault; break;
            case DataType::Char: mvDefaultValues.mchDefault = other.mvDefaultValues.mchDefault; break;
            case DataType::LongLong: mvDefaultValues.mllDefault = other.mvDefaultValues.mllDefault; break;
            case DataType::Double: mvDefaultValues.mdDefault = other.mvDefaultValues.mdDefault; break;
            case DataType::QString: new (&mvDefaultValues.msDefault) QString(other.mvDefaultValues.msDefault); break;
        }
    }

    // 移动构造函数
    Argument(Argument&& other) : mActiveType(other.mActiveType) {
        switch (mActiveType) {
            case DataType::Bool: mvDefaultValues.mbDefault = other.mvDefaultValues.mbDefault; break;
            case DataType::Char: mvDefaultValues.mchDefault = other.mvDefaultValues.mchDefault; break;
            case DataType::LongLong: mvDefaultValues.mllDefault = other.mvDefaultValues.mllDefault; break;
            case DataType::Double: mvDefaultValues.mdDefault = other.mvDefaultValues.mdDefault; break;
            case DataType::QString:
                new (&mvDefaultValues.msDefault) QString(std::move(other.mvDefaultValues.msDefault));
                // 销毁原对象的QString，避免重复析构
                other.mvDefaultValues.msDefault.~QString();
                other.mActiveType = DataType::Bool;
                break;
        }
    }

    // 析构函数
    ~Argument() {
        destroyActiveMember();
    }

    // 赋值运算符重载
    Argument& operator=(const Argument& other) {
        if (this == &other) return *this;

        destroyActiveMember();
        mActiveType = other.mActiveType;

        switch (mActiveType) {
            case DataType::Bool: mvDefaultValues.mbDefault = other.mvDefaultValues.mbDefault; break;
            case DataType::Char: mvDefaultValues.mchDefault = other.mvDefaultValues.mchDefault; break;
            case DataType::LongLong: mvDefaultValues.mllDefault = other.mvDefaultValues.mllDefault; break;
            case DataType::Double: mvDefaultValues.mdDefault = other.mvDefaultValues.mdDefault; break;
            case DataType::QString: new (&mvDefaultValues.msDefault) QString(other.mvDefaultValues.msDefault); break;
        }
        return *this;
    }

    // 获取数据类型
    std::string getDataType() const {
        switch (mActiveType) {
            case DataType::Bool: return "bool";
            case DataType::Char: return "char";
            case DataType::LongLong: return "long long";
            case DataType::Double: return "double";
            case DataType::QString: return "QString";
            default: return "unknown";
        }
    }
};

原代码错误解析 #

• 构造函数歧义：多个基础类型的构造函数可能因隐式转换冲突（比如char和bool的转换）触发"Ambiguous method"错误，std::variant通过显式类型匹配避免了这个问题。
• 联合拷贝构造函数无效：联合对象无法访问外层Argument类的getDataType()，必须在Argument类中跟踪活跃类型，再在拷贝/析构时根据标记操作对应字段。
• 非平凡类型生命周期未管理：直接使用包含QString的联合，未手动调用其构造/析构函数，会导致内存泄漏或未定义行为。

内容的提问来源于stack exchange，提问作者Seth D. Fulmer