takon—union

#include <iostream>
#include <string>
using namespace std;
//cout << ch;//我想定义这个 << 但union当时的值不缺定，遂没办法
union Takon1
{
    friend ostream& operator<<(ostream &os, const Takon& take);

    char ch;
    int ival;
    double dval;
};

static union{
    char d_ch;
    int d_ival;
    double d_dval;
};//这个错误可查，前几天总结的static，
//全局变量的 《匿名》Union必须显示的生命为static，具体原因还不清楚

void main1()
{
    Takon ch = {1};
    cout << ch.ival << endl;
    ch.ch = 's';
    cout << ch.ival << endl;//发生未定义

    d_ch = 's';
    cout << d_ch << endl;
    //在这个简单的使用上 就可以看出，局限性非常大
}
cout << " " << endl;
//巧妙之处：
//1 enmu，用于跟踪，来实现union
//2 copy_union 抽象出来的话，就是：两个大物件，当需要交换其中两个小物件有难度时
//像这个类的union，根本不知道他所持有的类型，那么久跳出来，重新站在两个大物件上
//因为大物件上的东西多，对交换肯定能提供方便。
class Takon
{
public:
    Token() : Tok(INT), ival(0) { }//同步一下，判别式
    Token(const Token & rhs) { Tok(rhs.Tok);  copy_union(rhs)}//copy
    //union是个特殊的东西，得额外写个函数，
    ~Token(){ if(Tok == STR) sval.~string(); }
    //这里我想延伸一下，如果，这里不止一个类，当定义一个析构函数，编译器就不会定义默认的
    //析构函数，是不是就只有两个方法，要么把if写在析构函数里，但好像析构函数应该不能有参数
    //那就只能使用重载了
    Takon & operator=(const string&);
    Takon & operator=(int); 
    Takon & operator=(char);
    Takon & operator=(double);
private:
    enum {
        STR,INT,DOUBLE,CHAR
    }Tok;//判别式

    union{
        string sval;
        char ch;
        int ival;
        double dval;
    };

    void copy_union(Takon&);
};

Takon& Takon::operator=(int i)
{
    if(Tok == STR)
        sval.~string();
    ival = i;
    Tok = INT;
    return *this;
}

Takon& Takon::operator=(char c)
{
    if(Tok == STR)
        sval.~string();
    ch = c;
    Tok = CHAR;
    return *this;
}

Takon& Takon::operator=(double d)
{
    if(Tok == STR)
        sval.~string();
    dval = d;
    Tok = DOUBLE;
    return *this;
}
/*Takon& Takon::operator=(string& s)
{
    if(Tok == STR)
        sval.~string();
    sval = s;
    Tok = STR;
    return *this;
}
  自己想的，
*/
Takon& Takon::operator=(string& s)
{
    if(Tok == STR)

    sval = s;
    else
    //sval = new string(s);
    new(&sval) string (s);//否则需要先构建一个string
    //言外之意就是union也是一个普通的类，他们也都已经默认初始化
    Tok = STR;
    return *this;
}

void Takon::copy_union(Takon& rhs)
{
    switch(Tok)
    {
        //case 'INT' 我的水平就只限于这样
    case Takon::INT: ival = rhs.ival; break;
    case Takon::CHAR: ch = rhs.ch; break;
    case Takon::DOUBLE: dval = rhs.dval; break;
    case Takon::STR: sval = rhs.sval; break;
    }
}

Takon & Takon::operator =(const Takon& rhs)
{
    if(Tok == STR && rhs.Tok != STR) 
        sval.~string();
    if(Tok == STR && rhs.Tok == STR)
        copy_union(rhs);

    Tok = rhs.Tok;
    return *this;
}