海前王

Posted on Aug 27

disign2

// ConsoleApplication30.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

include

using namespace std;
//
class fontFactory;
class font
{
private:
std::string key;
public:
font(const std::string& key ):key(key)
{

};

class fontFactory
{
map footpool;
public:
font * getfont(const string &key)
{
map::iterator it = footpool.find(key);

    if (it != footpool.end())
    {
        return footpool[key];

    }
    else
    {
        font* font = new ::font(key);
        footpool[key] = font;
        return font;
    }
}

};
int main()
{
std::cout << "Hello World!\n";
}

// expressionPattern.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

include

using namespace std;

class expression
{
public:
virtual int interperet(std::map var)
{};

private:
};

class varexpression : public expression
{
string m_key;

public:
varexpression(string key): m_key(key)
{
}

virtual int interperet(std::map<std::string, int> var)
{
    return var[m_key];
}

};

class symbolExpression : public expression
{
public:
expression* left;
expression* right;

symbolExpression(expression* l, expression* r):
    left(l), right(r)
{
}

expression* getleft() { return left; }
expression* getright() { return right; }

};

class addExpression : public symbolExpression
{
public:
addExpression(expression* l, expression* r) : symbolExpression(l, r)
{
}
};

class subExpression : public symbolExpression
{
public:
subExpression(expression* l, expression* r) : symbolExpression(l, r)
{
}
};

class calculator
{
public:
expression* m_expression;

calculator(string ex)
{
    m_expression = nullptr;
    stack<expression*> strexp;
    expression* right;
    expression* left;
    for (int i = 0; ex.length(); i++)
    {
        switch (ex[i])
        {
        case '+':
            left = strexp.top();
            strexp.pop();
            right = new varexpression(ex.substr(++i, 1));
            strexp.push(new addExpression(left, right));
            break;
        case '-':
            left = strexp.top();
            strexp.pop();
            right = new varexpression(ex.substr(++i, 1));
            strexp.push(new subExpression(left, right));
            break;

        default:
            strexp.push(new varexpression(ex.substr(i, 1)));
        }
    }
    if(!strexp.empty())
    {
        //m_expression = strexp.pop();
        strexp.pop();
    }

}

int runing(map<string, int>& val)
{
    return (m_expression == nullptr) ? 0 : m_expression->interperet(val);
}

};

int main()
{
}
// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

include

using namespace std;

struct ShareState
{
string m_brand;
string m_model;
string m_color;

ShareState(const string& brand,
           const string model, const string color):m_brand(brand),m_model(model),m_color(color)
{
}

friend ostream& operator<<(ostream& os, const ShareState& ss)
{
    return os << ss.m_brand <<"\t"<< ss.m_color << "\t"<<ss.m_model<<"\n";
}

};

struct uniqueState
{
string m_owner;
string m_plate;

uniqueState(const string& owner, const string& plate)
    : m_owner(owner), m_plate(plate)
{
}

//toString
friend ostream& operator<<(ostream& os, const uniqueState& ss)
{
    return os << ss.m_owner <<"\t"<< ss.m_plate<<"\n";
}

};

//flyweight
class flyweight
{
private:
ShareState m_shareState;

public:
flyweight(const ShareState shares_state)
: m_shareState(shares_state)
{
}

void operation(uniqueState unique)
{
    cout <<"\n"<<"waibu" << "\t" <<m_shareState << "neibu" << unique;
}

};

class FlyweightFactory
{
unordered_map m_flyweigt;

public:
string getKey(const ShareState& ss)
{
return ss.m_brand + " -" + ss.m_color + "-" + ss.m_model;
}

FlyweightFactory(initializer_list<ShareState> share_states)
{
    for (auto& ss : share_states)
    {
        m_flyweigt.insert({getKey(ss), flyweight(ss)});
    }
}

flyweight* getFlyweight(const ShareState& share_state)
{
    string key = getKey(share_state);
    if (m_flyweigt.find(key) == m_flyweigt.end())
    {
        std::cout << "not find";
        m_flyweigt.insert({key, share_state});
    }
    else
    {
        cout << "find";
    }

    return &m_flyweigt.at(key);
}

void listflyw() const
{
    int count = m_flyweigt.size();
    std::cout << "has" <<count;
    for (pair<string, flyweight> it : m_flyweigt)
    {
        cout << it.first << "\n";
    }
}

};

class CarInfo
{
private:
flyweight* m_flyweight_ = nullptr;
uniqueState* m_unique_state_;

public:
CarInfo(flyweight* flyweight, uniqueState* unique_state)
: m_flyweight_(flyweight), m_unique_state_(unique_state)
{
}

void operation()
{
    m_flyweight_->operation(*m_unique_state_);
}

};

include

class policeDatabase
{
private:
list car_infos_;
public:
~policeDatabase()
{
for (auto item : car_infos_)
{
delete item;
}
}

void addcartoPolicedatabase(FlyweightFactory& ff, const string& woner, const string& plate, const string& brand,
                            const string& color, const string& model)
{
    flyweight* flyweight = ff.getFlyweight({brand, model, color});
    uniqueState unique_state(woner, plate);
    car_infos_.push_back(new CarInfo(flyweight, &unique_state));
    for (auto item : car_infos_)

        item->operation();
}

};

int main()
{
FlyweightFactory factory({
ShareState("an", "ax", "red"),
ShareState("ax", "ddd", "ff")
});
cout << "\n----------------------------------\n";
factory.listflyw();
cout << "\n----------------------------------\n";

policeDatabase database;
database.addcartoPolicedatabase(factory, "xx", "xx", "xx", "xx", "xx");
cout << "\n----------------------------------\n";

factory.listflyw();
cout << "\n----------------------------------\n";

database.addcartoPolicedatabase(factory, "yy", "yy", "an", "ay", "red");
cout << "\n----------------------------------\n";

factory.listflyw();
cout << "\n----------------------------------\n";

database.addcartoPolicedatabase(factory, "zz", "zz", "an", "ay", "red");
cout << "\n----------------------------------\n";

factory.listflyw();

}

// ConsoleApplication2.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
/**

include

class a
{
public:

};

class b:public a
{
public:

};

int main()
{
int* p;
if(typeid(int*)==typeid(p))
{
std::cout << "equal";
}
a x;
a y;
if(typeid(x)!=typeid(y))
{

    std::cout << "not ii";
}

}*/

include

using namespace std;

class A;
class B;
class C;
class D;
class E;

class Base
{
public:
class IVisitor
{
public:
virtual void visit(A*) = 0;
virtual void visit(B*) = 0;
virtual void visit(C*) = 0;
virtual void visit(D*) = 0;
virtual void visit(E*) = 0;
};

virtual void say() = 0;
virtual void accept(IVisitor*) = 0;

virtual ~Base()
{
}

};

class A : public Base
{
public:
void say() override
{
cout << "Class A" << endl;
}

void accept(IVisitor* vis) override
{
    vis->visit(this); // 匹配数据操作类中的重载函数
}

};

class B : public Base
{
public:
void say() override
{
cout << "Class B" << endl;
}

void accept(IVisitor* vis) override
{
    vis->visit(this);
}

};

class C : public Base
{
public:
void say() override
{
cout << "Class C" << endl;
}

void accept(IVisitor* vis) override
{
    vis->visit(this);
}

};

class D : public Base
{
public:
void say() override
{
cout << "Class D" << endl;
}

void accept(IVisitor* vis) override
{
    vis->visit(this);

}

};

class E : public Base
{
public:
void say() override
{
cout << "Class E" << endl;
}

void accept(IVisitor* vis) override
{
    vis->visit(this);
}

};

class calcVisitor : public Base::IVisitor
{
// 数据操作类
public:
calcVisitor(int& x) : x(x)
{
}

void visit(A* obj) override
{
    x *= 2;
}

void visit(B* obj) override
{
    x -= 3;
}

void visit(C* obj) override
{
    x += 6;
}

void visit(D* obj) override
{
    x /= 3;
}

void visit(E* obj) override
{
    x -= 2;
}

private:
int& x;
};

int main()
{
// 访问者模式实现, 类型->功能(补充知识: 解决新增功能维护难——通过让编译器提示改代码)
srand(time(0));
Base* p[5] = {nullptr};
for (int i = 0; i < 5; ++i)
{
// 第一次类指针类型转换
switch (rand() % 5)
{
case 0: p[i] = new A();
break;
case 1: p[i] = new B();
break;
case 2: p[i] = new C();
break;
case 3: p[i] = new D();
break;
case 4: p[i] = new E();
break;
}
}
int x = 1;
calcVisitor vis(x);
for (int i = 0, pre = x; i < 5; ++i)
{
p[i]->accept(&vis); // 第二次类指针类型转换
p[i]->say();
cout << pre << " -> " << x << endl;
pre = x;
}
return 0;
}

//// ConsoleApplication31.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
////
//
//#include
//class a
//{
//public:
// a(int m,int n):i(m),j(n){}
// int i;
// int j;
// void print()
// {
// std::cout << "Hello World!\n";
//
// }
//};
//void fun(std::shared_ptr f)
//{
//}
//
//int main()
//{
// std::unique_ptr f(new a(2, 4));
// f->print();
// fun(std::make_shared (3, 4));
// std::shared_ptr dd = std::make_shared (2, 3);
// std::shared_ptr ff = dd;
//
// std::cout << (*ff).i;
//}
//
//// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
//// 调试程序: F5 或调试 >“开始调试”菜单
//
//// 入门使用技巧:
//// 1. 使用解决方案资源管理器窗口添加/管理文件
//// 2. 使用团队资源管理器窗口连接到源代码管理
//// 3. 使用输出窗口查看生成输出和其他消息
//// 4. 使用错误列表窗口查看错误
//// 5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//// 6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
// ConsoleApplication1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。

include

class AbstractHero {
public:
virtual void showStatus() = 0;
int mHp, mMp, mAt, mDf;
};

class HeroA :public AbstractHero {
public:
HeroA() {
mHp = 0, mMp = 0, mAt = 0, mDf = 0;
}
virtual void showStatus() {
std::cout << "血量：" << mHp << std::endl;
std::cout << "魔法：" << mMp << std::endl;
std::cout << "攻击：" << mAt << std::endl;
std::cout << "防御：" << mDf << std::endl;
}
};

//英雄穿上某个装饰物，那么也还是一个英雄
class AbstractEquipment : public AbstractHero {
public:
AbstractEquipment(AbstractHero* hero) {
pHero = hero;
}
virtual void showStatus() {}
AbstractHero* pHero;
};

//给英雄穿上狂徒铠甲
class KuangtuEquipment :public AbstractEquipment {
public:
KuangtuEquipment(AbstractHero* hero) :AbstractEquipment(hero) {}
//增加新的功能
void AddKuangtu() {
std::cout << "新英雄穿上狂徒之后" << std::endl;
this->mHp = this->pHero->mHp;
this->mMp = this->pHero->mMp;
this->mAt = this->pHero->mAt;
this->mDf = this->pHero->mDf + 30;
}
virtual void showStatus() {
AddKuangtu();
std::cout << "血量：" << mHp << std::endl;
std::cout << "魔法：" << mMp << std::endl;
std::cout << "攻击：" << mAt << std::endl;
std::cout << "防御：" << mDf << std::endl;
}
};

int main() {

AbstractHero* hero = new HeroA;
hero->showStatus();
std::cout << "------------------------" << std::endl;
//给英雄穿上狂徒
hero = new KuangtuEquipment(hero);
hero->showStatus();

return 0;

}

// ConsoleApplication32.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

include

using namespace std;

//
class Company
{
public:
virtual string getInfo() = 0;

virtual string getName()
{
    return name;
}

virtual string getType() = 0;

protected:
string name;
string position;
int salary;
};

class ConcreteCompany : public Company
{
public:
ConcreteCompany(string name, string position, int salary)
{
this->name = name;
this->position = position;
this->salary = salary;
}

void add(Company* company)
{
    shared_ptr<Company> temp(company);
    companyList.push_back(temp);
}

string getType()
{
    return "ConcreteCompany";
}

void remove(string companyName)
{
    list<shared_ptr<Company>>::iterator iter = companyList.begin();
    for (; iter != companyList.end(); iter++)
    {
        if ((*iter).get()->getName() == companyName)
        {
            companyList.erase(iter);
            return;
        }
    }
}

list<shared_ptr<Company>> getChildList()
{
    return companyList;
}

string getInfo()
{
    string info = "";
    info = "名称：" + this->name;
    info = info + "\t职位：" + this->position;
    info = info + "\t薪水：" + to_string(this->salary);
    return info;
}

private:
list> companyList;
};

class Employee : public Company
{
public:
Employee(string name, string position, int salary)
{
this->name = name;
this->position = position;
this->salary = salary;
}

string getType()
{
    return "Employee";
}

string getInfo()
{
    string info = "";
    info = "名称：" + this->name;
    info = info + "\t职位：" + this->position;
    info = info + "\t薪水：" + to_string(this->salary);
    return info;
}

};

void disPlay(ConcreteCompany* root)
{
cout << root->getInfo() << endl;
list> tmp = root->getChildList();
list>::iterator iter = tmp.begin();
for (; iter != tmp.end(); iter++)
{
if ((iter).get()->getType() == string("Employee"))
{
cout << (*iter).get()->getInfo() << endl;
}
else
{
//递归
disPlay((ConcreteCompany)(*iter).get());
}
}
}

int main()
{
ConcreteCompany* root = new ConcreteCompany("张三", "CEO", 100000);
ConcreteCompany* develop = new ConcreteCompany("李四", "研发组长", 100000);
ConcreteCompany* sale = new ConcreteCompany("王二", "销售组长", 100000);
Employee* e1 = new Employee("A", "研发", 200);
Employee* e2 = new Employee("B", "销售", 200);
Employee* e3 = new Employee("C", "研发", 200);
Employee* e4 = new Employee("D", "销售", 200);
root->add(develop);
root->add(sale);
develop->add(e1);
develop->add(e3);
sale->add(e2);
sale->add(e4);
disPlay(root);
develop->remove("A");
disPlay(root);
delete root;
root = NULL;
}

DEV Community

disign2

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

include

Top comments (0)

Read next

Talk to Your Cloud: Effortless AI-Driven Deployments

Jetbrains Rider Endpoints

Kafka x RabbitMQ: Escolha Entre Processamento de Fluxo e Filas de Mensagens

When to Use Kafka or RabbitMQ: Choosing Between Stream Processing and Message Queues