自学设计模式（简单工厂模式、工厂模式、抽象工厂模式）

使用工厂模式来生产某类对象（代码简化且容易维护，类之间有血缘关系，可以通过工厂类进行生产）；

简单工厂模式（用于创建简单对象）

对于简单工厂模式，需要的工厂类只有一个；

在工厂类中的公共成员函数来创建所需对象；

#include <bits/stdc++.h>
using namespace std;
// 产品父类 
class shape{
public:
    virtual void cal() = 0;
    virtual ~shape(){
        
    }
}; 

class triangle:public shape{
public:
    void cal() override{
        cout<<"三角形面积";
    }
};

class square:public shape{
public:
    void cal() override{
        cout<<"正方形面积";
    }
};

class cycle:public shape{
public:
    void cal() override{
        cout<<"圆形面积";
    }
};

// 工厂类
enum class Type:char{
    triangle , 
    square , 
    cycle
};
class fac{
public:
    shape* creat_kinds(Type type){
        shape* ptr = nullptr;
        switch(type){
            case Type::triangle:
                ptr = new triangle;
                break;
            case Type::square:
                ptr = new square;
                break;
            case Type::cycle:
                ptr = new cycle;
                break;
        }
        return ptr;
    }
}; 
int main(){
    fac* cur = new fac;
    shape* obj = cur->creat_kinds(Type::cycle);
    obj->cal();
    return 0;
}

工厂模式

简单工厂模式会违反开放封闭原则 在添加类时需要修改子类、枚举类、工厂类、和判断代码

工厂模式通过创立N个工厂类来解决上述问题（对简单工厂模式解耦合），对已经写好的代码无需修改；

#include <bits/stdc++.h>
using namespace std;
// 产品父类 
class shape{
public:
    virtual void cal() = 0;
    virtual ~shape(){
        
    }
}; 

class triangle:public shape{
public:
    void cal() override{
        cout<<"三角形面积"<<endl;
    }
};

class square:public shape{
public:
    void cal() override{
        cout<<"正方形面积"<<endl;
    }
};

class cycle:public shape{
public:
    void cal() override{
        cout<<"圆形面积"<<endl;
    }
};

// 工厂类
class fac{
public:
    virtual shape* creat_kinds() = 0;
    virtual ~fac(){
        
    }
}; 

class triangle_fac:public fac{
public:
    shape* creat_kinds(){
        return new triangle;
    }
    ~triangle_fac(){
        cout<<"三角形被析构"; 
    }
};
class square_fac:public fac{
public:
    shape* creat_kinds(){
        return new square;
    }
    ~square_fac(){
        cout<<"三角形被析构"; 
    }
};

class cycle_fac:public fac{
public:
    shape* creat_kinds(){
        return new cycle;
    }
    ~cycle_fac(){
        cout<<"三角形被析构"; 
    }
};
int main(){
    fac* cur = new cycle_fac;
    shape* obj = cur->creat_kinds();
    obj->cal();
    
    delete obj;
    delete cur;
    
    return 0;
}

抽象工厂模式

通过造船，船分为三个模块，船体、武器、动力，三个模块又分为了简易、标准、旗舰三个版本

#include <bits/stdc++.h>
using namespace std;
// 三个抽象类 每个抽象类下三个具体派生类
// 抽象工厂类 一个抽象类 三个派生类
class body{
public:
    virtual void getbody() = 0;
    virtual ~body(){
        
    }
}; 

class wood_body:public body{
public:
    void getbody() override{
        cout<<"船的船体为<木头>---";
    }
};

class iron_body:public body{
public:
    void getbody() override{
        cout<<"船的船体为<钢铁>---";
    }
};

class mental_body:public body{
public:
    void getbody() override{
        cout<<"船的船体为<合成金属>---";
    }
};

class weapon{
public:
    virtual void getweapon() = 0;
    virtual ~weapon(){
        
    } 
};

class gun_weapon:public weapon{
public:
    void getweapon() override{
        cout<<"船的武器为<枪>---" ;
    }
};

class cannon_weapon:public weapon{
public:
    void getweapon() override{
        cout<<"船的武器为<炮>---" ;
    }
};

class laser_weapon:public weapon{
public:
    void getweapon() override{
        cout<<"船的武器为<激光>---" ;
    }
};

class power{
public:
    virtual void getpower() = 0;
    virtual ~power(){
        
    } 
}; 

class human_power:public power{
public:
    void getpower() override{
        cout<<"船的动力为<手动>---"; 
    }
};

class engine_power:public power{
public:
    void getpower() override{
        cout<<"船的动力为<内燃机>---"; 
    }
};

class nuclear_power:public power{
public:
    void getpower() override{
        cout<<"船的动力为<核反应堆>---"; 
    }
};

class ship{
private:
    body* m_body;
    weapon* m_weapon;
    power* m_power;
public:
    ship(body* o_body , weapon* o_weapon , power* o_power):m_body(o_body) , m_weapon(o_weapon) , m_power(o_power){
        m_body->getbody();
        m_weapon->getweapon();
        m_power->getpower(); 
    }
    ~ ship(){
        delete m_body;
        delete m_weapon;
        delete m_power;
    } 
};

class fac{
public:
    virtual ship* get() = 0;
    ~ fac(){
        
    }
}; 

class e_fac:public fac{
public:
    ship* get() override{
        ship* cur = new ship(new wood_body , new gun_weapon , new human_power);
        return cur;
    }
};

class m_fac:public fac{
public:
    ship* get() override{
        ship* cur = new ship(new iron_body , new cannon_weapon , new engine_power);
        
        return cur;
    }
};

class h_fac:public fac{
public:
    ship* get() override{
        ship* cur = new ship(new mental_body , new laser_weapon , new nuclear_power);
        return cur;
    }
};

int main() {
    fac* cur = new h_fac;
    ship* res = cur->get();
    delete cur;
    delete res;
    return 0;
}

描述：首先定义三个抽象类，代表船的三个组成部分（船体、武器、动力）;每个抽象类下有三个派生类，分别对应初级船、中级船、高级船所用的对应材料。通过ship类将船的三个部分组成起来，一个工厂抽象类fac，通过工厂抽象类的派生类，结合ship类设置三种规格的船。