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

using namespace std;

class T72 {
    T72(const string& id) : id_(id) {}
    const string& getId() const { return id_; }
private:
    string id_;
};

class Tank {
public:
    Tank(const string& name) : name_(name) {}
    virtual ~Tank() {}
    const string& getName() const { return name_; }
private:
    string name_;
};
using UTank = unique_ptr<Tank>;

class LeopardTank : public Tank {
public:
    LeopardTank(const string& name) : Tank(name) {}
};

class TwardyTank : public Tank {
public:
    TwardyTank(const string& name) : Tank(name) {}
};

class Missle {
public:
    Missle();
    virtual ~Missle() {}
};
using UMissle = unique_ptr<Missle>;

class Missle125 : public Missle {
public:
    Missle125()  {}
};

class Missle120 : public Missle {
public:
    Missle120() {}
};

class AbstractFactory {
public:
    virtual UTank createTank(const std::string& name) = 0;
    virtual UMissle createMissle() = 0;
};

class LeopardFactory : public AbstractFactory {
public:
    virtual UTank createTank(const std::string& name) { return UTank(new LeopardTank(name)); }
    virtual UMissle createMissle(){ return UMissle(new Missle125() ); }
};

class TwardyFactory : public AbstractFactory {
public:
    virtual UTank createTank(const std::string& name) { return UTank(new TwardyTank(name)); }
    virtual UMissle createMissle(){ return UMissle(new Missle120() ); }
};

int main() {
    int level = 1;
    unique_ptr<AbstractFactory> factory;
    if(level==1) {
        factory = make_unique<TwardyFactory>();
    } else {
        factory = make_unique<LeopardFactory>();
    }
    factory->createTank("102");
    factory->createMissle();
}