我在联合中删除哪个元素有关系吗

Question

I am writing a translator and for that, I want to create a class Verb. this class should only save the complete cunjugation when it is irregular because it would produce large lists, taking much memory. So here's my code:

#include "string.h"  

struct Irregular{
    std::string present;  
    std::string simplepast;  
    std::string pastparticiple;  
}  

union Verbform{  
    Irregular* irregular;  
    std::string* regular;  
    Verbform(Irregular irreg){irregular=new Irregular(irreg);}  
    Verbform(std::string s){regular=new std::string(s);  
    ~Verbbform(){delete regular;}  //here is my problem  
}  

class Verb{  
    public:  
        //some public functions  
    private:  
        Verbform verbform;  
        //some other things;
}  

When I do it like this and I initialize it with an irreglar verb, does he delete the complete irregular verb or only the first string?

When I do it like this: ~Verbform(){delete irregular;} and I initialize it with a normal string, does he deletes more than I want him to delete?

Answer 1

delete irregular calls the ~Irregular() destructor, which then calls the std::string::~string() destructor 3 times. Calling this when irregular is n not the active union member is undefined behavior .

delete regular calls the std::string::~string() destructor 1 time. Calling this when regular is not the active union member is undefined behavior .

You need to keep track of which member of the union is active so you can call the appropriate destructor, eg:

enum Verbform_type { vtIrregular, vtRegular };

union Verbform_data {
    Irregular* irregular;
    std::string* regular;
};

struct Verbform {
    Verbform_type type;
    Verbform_data data;

    Verbform(Irregular irreg) {
        type = vtIrregular;
        data.irregular = new Irregular(irreg);
    }

    Verbform(std::string reg) {
        type = vtRegular;
        data.regular = new std::string(reg);
    }

    ~Verbform() {
        switch (type) {
            case vtIrregular:
                delete data.irregular;
                break;
            case vtRegular:
                delete data.regular;
                break;
        }
    }
} 

Also, don't forget to follow the Rule of 3/5/0 by adding copy/move constructors and copy/move assignment operators.

Otherwise, you should just get rid of your Verbform struct altogether and use std::variant instead. Let it handle all of these details natively for you.

using Verbform = std::variant<Irregular, std::string>;