CPP 设计模式

最新推荐文章于 2022-08-22 16:08:12 发布
最新推荐文章于 2022-08-22 16:08:12 发布
阅读量632 收藏 2
点赞数
分类专栏： CPP学习 文章标签： c++ 设计模式 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/devil_1995/article/details/103803892
版权
备忘录模式
  • 在一个类内部记录另一个类的快照状态的模式。可以再合适的时候跳回复用

引用文字

  • 设计备忘录的三大步骤：
  1. 设计记录的节点，存储记录
    2.设计记录的存储： vector list map set 可以使 链表 图 数组 树
    3.操作记录的类，记录节点状态，设置节点状态，显示节点状态
策略模式

  • 策略模式针对一组算法，将每一个算法封装到具有共同接口的独立类中。

  • 从而使得他们可以相互转换，策略模式可以在不影响客户端的情况下使算法发生改变。策略模式把行为和环境分离开来，环境类负责维持和查询行为类。

  • 策略模式依赖多态，策略模式的抽象类，接口，抽象类的指针可以访问所有子类对象（纯虚函数）

  • 各种策略的实现类。都必须集成抽象类。

  • 策略的设置接口类。设置不同的策略
    =======

设计模式 抽象工厂模式

  • 工厂模式： 客户类和工厂类分开。
  • 消费者需要任何产品，只需要和工厂请求就可以了。
  • 消费者无需修改就可以接纳新产品，缺点是当产品修改时，工厂类也要做相应的修改

=======

设计模式

简单工厂模式
  • 基类存放数据 派生类存放操作
  • 再实现一个调用各个操作的静态类，调用时返回派生类指针

代码：

#include <iostream>
#include <string>

using namespace std;

class OP
{
public:
    double a;
    double b;
    virtual double jisuan()
    {
        return 0;
    }
};

class add : public OP
{
    double jisuan()
    {
        return a + b;
    }
};

class sub : public OP
{
    double jisuan()
    {
        return a - b;
    }
};

class divv : public OP
{
    double jisuan()
    {
        return a / b;
    }
};

class mul : public OP
{
    double jisuan()
    {
        return a * b;
    }
};

class Fac
{
public:
    static OP *selectop(char c)
    {
        switch (c)
        {
        case '+':
            return new add();
            break;

        case '-':
            return new sub();
            break;

        case '*':
            return new mul();
            break;

        case '/':
            return new divv();
            break;

        default:
            printf("you entered wrong caculation!!");
            break;
        }
    }
};

int main(void)
{
    OP *opr = Fac::selectop('/');
    opr->a = 100;
    opr->b = 5;
    cout << opr->jisuan() << endl;

    return 0;
}
方法工厂模式
  • 把操作和实例化工厂的类分别抽象出来
  • 通过继承抽象类实现不同的操作
  • 方法工厂模式就是简单工厂模式把工厂进行抽象并且进行封装后得到的

代码：

#include <iostream>
#include <string>
using namespace std;


class OP
{
public:
    double a, b;
    virtual double jisuan()
    {
        return 0;
    }
};

class add : public OP
{
    double jisuan()
    {
        return a + b;
    }
};

class sub : public OP
{
    double jisuan()
    {
        return a - b;
    }
};

class divv : public OP
{
    double jisuan()
    {
        return a / b;
    }
};

class mul : public OP
{
    double jisuan()
    {
        return a * b;
    }
};

class IFac
{
private:
    /* data */
public:
    virtual OP *selectop() = 0;
};

class addop : public IFac
{
public:
    static OP *selectop()
    {
        return new add();
    }
};

class subop : public IFac
{
public:
    static OP *selectop()
    {
        return new sub();
    }
};

class divop : public IFac
{
public:
    static OP *selectop()
    {
        return new divv();
    }
};

class mulop : public IFac
{
public:
    static OP *selectop()
    {
        return new mul();
    }
};

int main(void)
{
    IFac *opp = mulop::selectop();
    opp->a=90;
    opp->b=100;
    cout << opp->jisuan()<<endl;
    return 0;
}
抽象工厂模式
  • 工厂模式： 客户类和工厂类分开。
  • 消费者需要任何产品，只需要和工厂请求就可以了。
  • 消费者无需修改就可以接纳新产品，缺点是当产品修改时，工厂类也要做相应的修改
  • 消费者 工厂 商品都有自己的抽象类并且通过继承 实例化 抽象接口 ，提供不同的服务
单例模式
  • 单例模式确认某个类只有只有一个实例
  • 有两种实现模式： 1.匿名类的声明   2.通过内部的静态类指针来实现
  • 单例模式：单例模式确保某一个类只有一个实例，
  • 而且自行实例化并向整个系统提供这个实例单例模式
  • 单例模式只应在有真正的“单一实例”的需求时才可使用。
    public:
    int a=100;
    }aa;

#include <iostream>
#include <string>

class
{
public:
    int a = 100;
} aa;

class SingleInstance
{
private:
    /* data */

    int i = 0;

public:
    static SingleInstance *instance;
    SingleInstance(int a)
    {
        this->i = a;
    }

    static SingleInstance *get_instance()
    {
        return instance;
    }
};

SingleInstance *SingleInstance::instance = new SingleInstance(1995);


class B:public SingleInstance
{

};

int main(void)
{
    SingleInstance *s1=SingleInstance::get_instance();
    SingleInstance *s2=B::get_instance();

    std::cout<<(s1==s2)<<std::endl;

    std::cin.get();

    return 0;
}
代理模式
  • 代理模式：代理模式给某一个对象提供一个代理对象，
  • 并由代理对象控制对源对象的引用。
  • 代理就是一个人或一个机构代表另一个人或者一个机构采取行动。
  • 某些情况下，客户不想或者不能够直接引用一个对象，
  • 代理对象可以在客户和目标对象直接起到中介的作用。
  • 客户端分辨不出代理主题对象与真实主题对象。
  • 代理模式可以并不知道真正的被代理对象，
  • 而仅仅持有一个被代理对象的接口，这时候代理对象不能够创建被代理对象，
  • 被代理对象必须有系统的其他角色代为创建并传入。
#include <iostream>
#include <string>

using namespace std;

class  girl
{
public:
	 girl(string);
	 girl();
	~ girl();
	string name;
private:

};

 girl:: girl(string s1)
{
	 name = s1;
}

 girl::~ girl()
{
}

 girl::girl()
 {
	 name = "不知名的!";
 }


 class gift {
 public:
	 virtual void gift1() = 0;
	 virtual void gift2() = 0;
 };


 class gg:public gift
 {
 public:
	 gg(girl);
	 ~gg();


	void gift1()
	 {
		 cout << mm.name << "送你礼物1" << endl;
	 }

	void gift2()
	{
		cout << mm.name << "送你礼物2" << endl;
	}
 private:
	 girl mm;
 };

 gg::gg(girl m)
 {
	 mm = m;
 }

 gg::~gg()
 {
 }



 class proxy :public gift
 {
 private :
	 gg gg1;

 public:

	 proxy(girl mm) :gg1(mm)
	 {

	 }

	 void gift1()
	 {
		 gg1.gift1();
	 }

	 void gift2()
	 {
		 gg1.gift2();
	 }
 };



int main(void)
{

	girl mm1("小妹妹");
	proxy p1(mm1);
	p1.gift1();
	p1.gift2();


	cin.get();


	return 0;
}
迭代器模式
  • 迭代子模式：迭代子模式可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。
  • 多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。
命令行模式

  • 把执行命令单独建一个类。专职做命令的执行工作

  • 命令的执行者专么建一个基类，存放执行不同命令的类继承自这个基类。通过执行不同命令划分。

  • 再建一个类统筹这些执行命令的类，调用执行命令的类。

  • 代码：

  • 命令模式示例代码

#include <iostream>
#include <string>
#include <list>

using namespace std;



class doing
{
public:

	void action1() {
		cout << "lalala 吃饭了" << endl;
	}

	void action2()
	{
		cout << "是时候运动了！！！！！" << endl;
	}
private:

};

class  Command
{

public:
	Command(doing * d) {
		reciver = d;
	}

	virtual void do_doing() = 0;

	protected:
		doing* reciver;

		

};


class action1_command:public Command
{
public:
	action1_command(doing* d) :Command(d)
	{

	}

	void do_doing()
	{
		reciver->action1();
	}

};

class action2_command :public Command
{
public:
	action2_command(doing* d) :Command(d)
	{

	}

	void do_doing()
	{
		reciver->action2();
	}

};

class waiter
{
public:

	void set_action(Command* c)
	{
		this->command = c;
	}

	void do_action()
	{
		this->command->do_doing();
	}

protected:
	Command* command;

};

class waiter_n {

public:
	void set_action(Command* c)
	{
		this->command.push_back(c);
	}

	void do_action()
	{
		auto n = command.begin();
		while (n!=command.end())
		{
			(*n)->do_doing();
			n++;
		}
	}

private:
	list<Command*> command;
};


int main(void)
{
	doing* dd = new doing();
	Command* action_command1 = new action1_command(dd);
	Command* action_command2 = new action2_command(dd);
	waiter* w = new waiter();
	w->set_action(action_command1);
	w->do_action();
	w->set_action(action_command2);
	w->do_action();
	cout << endl;
	waiter_n* ww = new waiter_n();
	ww->set_action(action_command1);
	ww->set_action(action_command2);
	ww->do_action();
	return 0;
}
责任链模式：
  • 一级传达另一级，知道没有上级，直到最高级
  • 责任链模式示例
#include <iostream>
#include <string>


using namespace std;

class  Request
{
public:
	string request_name;
	string request_type;
	int n;
private:
	
};


class Manager {
public:
	Manager(string n, string j, int id)
	{
		name = n;
		job = j;
		classid = id;
	}

	void setSuper(Manager *p)
	{
		this->super = p;
	}

	virtual void  apply(Request*) = 0;
	int classid;
	Manager* super;
	string name;
	string job;
private:

	
	
};

class  zhuguan:public Manager
{
public:
	zhuguan(string n,  int id) :Manager(n,"主管", id) {}

	void apply(Request* r)
	{
		if (r->n > this->classid)
		{
			cout << r->request_type << "\t" << r->request_name << "\t 被" << this->job << this->name << "审阅！无权限，将继续向上递交！！" << "classid=" << this->classid << endl;
			super->apply(r);
		}
		else
		{
			cout << r->request_type << "\t" << r->request_name << "\t 被"<<this->job<<this->name<<"批准！！！"<<"classid="<<this->classid<< endl;
		}
	}

private:

};

class  zongjian :public Manager
{
public:
	zongjian(string n, int id) :Manager(n, "总监", id) {}

	void apply(Request* r)
	{
		if (r->n > this->classid)
		{
			cout << r->request_type << "\t" << r->request_name << "\t 被" << this->job << this->name << "审阅！无权限，将继续向上递交！！" << "classid=" << this->classid << endl;
			super->apply(r);
		}
		else
		{
			cout << r->request_type << "\t" << r->request_name << "\t 被" << this->job << this->name << "批准！！！" << "classid=" << this->classid << endl;
		}
	}

private:

};


class  zongjingli :public Manager
{
public:
	zongjingli(string n) :Manager(n, "总经理", 1000) {}

	void apply(Request* r)
	{
		
			cout << r->request_type << "\t" << r->request_name << "\t 被" << this->job << this->name << "批准！！！" << "classid=" << this->classid << endl;
		
	}

private:

};


int main(void)
{
	Request* request = new Request();
	request->request_name = "生病请10天假";
	request->request_type = "病假";
	request->n = 50;

	zhuguan* zg = new zhuguan("小芳", 10);
	zongjian* zj = new zongjian("小明", 30);
	zongjingli* zjl = new zongjingli("老大");
	zg->setSuper(zj);
	zj->setSuper(zjl);

	zg->apply(request);
	return 0;
}

20140903数据结构与算法

总览

sjjg.jpg

概论

gl.png

算法的特性

sf.jpg

算法的衡量标准

sfbz.jpg

Boost和算法

boost Array 第一只boost 程序

  • 使用boost 必须下载安装适当的编译好的包。

  • 各个VS 使用的版本不一样

  • Linux只能自己编译

  • boost 的命名空间为boost

  • boost第一个程序（array)

#include <iostream>
#include <boost/array.hpp>
#include <string>

using namespace std;

int main(void)
{
	boost::array<int,10> arr = { 0,1,2,3,4,5,6,7,8,9 };

	boost::array<int, 10>::iterator ib = arr.begin();
	boost::array<int, 10>::iterator ie = arr.end();

	for (;ib!=ie;ib++)
	{
		cout << *ib << endl;
	}

	cin.get();
	return 0;
}
boost 库的学习 boost_array_bind_fun_ref
std 方式
  • 绑定已有函数增加新的参数但是不改变原来的函数(std 方式)
  • 使用：
    • 1执行操作的类继承自 std::binary_function<>
    • 2.使用bind1st()
  • 代码：
    • bind1st示例代码(bind1st.cpp)
#include <iostream>
#include <string>
#include <functional>
#include <list>
#include <algorithm>
#include "boost/bind.hpp"

using namespace std;
using namespace boost;

class jia:public binary_function<int,int,void>
{
public:
void operator ()( int i, int j) const
{
	cout << i+j << endl;
}

private:

};



int main(void)
{
	list <int> ls1;
	ls1.push_back(5);
	ls1.push_back(15);
	ls1.push_back(125);

	for_each(ls1.begin(), ls1.end(), bind1st(jia(),10));


	cin.get();
	return 0;
}
boost方式
  • boost::bind示例代码
#include <iostream>
#include <string>
#include <functional>
#include <list>
#include <algorithm>
#include "boost/bind.hpp"

using namespace std;
using namespace boost;

class jia:public binary_function<int,int,void>
{
public:
void operator ()( int i, int j) const
{
	cout << i+j << endl;
}

private:

};

void add(int i, int j)
{
	cout << i + j << endl;
}


int main(void)
{
	list <int> ls1;
	ls1.push_back(5);
	ls1.push_back(15);
	ls1.push_back(125);

	//std 方式
	for_each(ls1.begin(), ls1.end(), bind1st(jia(),10));

	//boost 方式
	for_each(ls1.begin(), ls1.end(), bind(add,13, _1));
	cin.get();
	return 0;
}
  • boost详解
    这个从新做一个文章吧，在这里放不下。。。
boost::function 库
  • boost::function 库提供了一个类模板 boost::function。它是一个仿函数类，用于封装各种函数指针通常用来和bind结合起来使用。当仿函数没有绑定任何指针时，会抛出 boost::bad_function_call异常。
boost::ref
  • 不能拷贝对象用boost::ref()
RAII
  • 避免内存泄漏，把堆上的内存当做栈使用
智能指针 smartpointers 库

类的虚函数表

  • 类有一个虚函数表，存储着所有虚函数的地址。
  • 类总是把虚函数表放在最前面
  • 一种访问类的虚函数的方法（代码如下：）
  • 不管基类中是公有，私有，都不影响子类集成虚函数
  • 虚函数顺序：基类-》子类
  • 多重继承子类会有多个虚函数表，每个虚函数表继承自每个基类的虚函数表
#include <iostream>

using namespace std;

class A
{
public:


	void virtual a() {
	
		std::cout << "A --> a" << endl;
	}

	void virtual b() {

		std::cout << "A--> b" << endl;
	}

	void virtual c() {

		std::cout << "A--> c" << endl;
	}
private:

};


class B :public A
{
public:
	void virtual a()
	{
		std::cout << "B--> a" << endl;
	}

	void virtual b() {

		std::cout << "B--> b" << endl;
	}
};


typedef  void (*Pfunc) (void);

int main(void)
{
	B b;
	cout << "B is " <<sizeof(b) << endl;
	
	Pfunc pfc;
	for (int i = 0; i < 3; i++)
	{

		/*	  (&b) 取出B的地址 
			(int *)(&b) 转换b的地址为int 类型，方便后期访问紧跟着它的内存
			*(int *)(&b)   取出B里面的内容（虚函数表的地址）
			(int *) *(int *)(&b) 把虚函数表的地址转换为int类型，方便后期访问紧跟着它的内存
			(int *) *(int *)(&b) + i  利用地址存储的机制，+1 自动跳过4（8）个字节，访问下一个内存内容，访问存储在虚函数表里面的函数地址
			(Pfunc)*   将虚函数表李的函数指针地址转换为 pFunc 类型的函数指针地址，方便调用
					  pfc(); 调用
			

		*/
		pfc = (Pfunc)*((int *) *(int *)(&b) + i);
		pfc();
	}




	cin.get();

	return 0;
}
devil_1995
关注
专栏目录
23种设计模式的解析与Cpp实现
05-20
23种设计模式的解析与Cpp实现
LObject.cpp 设计模式的 状态 和行为模式的实现文件
04-13
头文件，包含 状态的基础类 ，行为的基础类，以及继承类，可应用于各种复杂环境中，后续将继续传递应用等相关文件资源
Cpp设计模式及举例
weixin_44754751的博客
02-20 377
C++设计模式之单例模式 C++设计模式之工厂模式 C++设计模式之代理模式 C++设计模式之外观模式 C++设计模式之适配器模式 C++设计模式之模板方法模式 C++设计模式之策略模式 C++设计模式之命令模式 C++设计模式之观察者模式 C++设计模式之装饰模式 ...
Cpp-设计模式
Cutepingping的博客
08-29 425
http://www.jianshu.com/p/ecabec602791   链接
java 23种设计模式
weixin_33725722的博客
02-10 356
2019独角兽企业重金招聘Python工程师标准>>> ...
cpp设计模式学习总结
Go_hack的博客
04-07 613
。。。
CPP.rar_C++ Qt 设计模式_Qt 开发框架_cpp设计模式_qt 设计模式_qt框架
09-20
《C++设计模式——基于Qt4的开源跨平台开发框架》是一份深入探讨C++与Qt结合使用的专业文档，特别关注于设计模式在Qt开发中的应用。Qt是一个强大的跨平台应用程序开发框架，支持多种操作系统，如Windows、Linux、...
c++设计模式全系列+应用场景+实例说明
最新发布
04-01
1. **工厂模式（Factory Pattern）**：工厂模式是一种创建型设计模式，用于创建对象而无需指定创建对象的具体类。包括简单工厂模式、工厂方法模式和抽象工厂模式。 2. **单例模式（Singleton Pattern）**：单例模式...
design_patterns_cpp:设计模式范例整理
04-05
设计模式范例整理 面向对象设计最大的优势在于：抵御变化，重置多的替代，把变化所带来的影响降为最小 设计原则是基础（根基），通过原则可以实现不同的模式，以原则为基础 设计模式中的改变和不改变（稳定和偏差）...
C/Cpp / 设计模式 / 模板模式
布袋和尚
11-08 385
一、定义 定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。 二、栗子 1、模板方法模式（通用版） （1）UML图 （2）UML说明 AbstractClass 叫抽象模板，其方法分为两类： 基本方法：即基本操作，是由子类实现的方法，并且在模板方法被调用。 模板方法：可以有一个或几个，一般是一个具体方法，即一个框架，实现对基本方法的调度，完成固定的逻辑 注：为了防止被恶意操作，C++中可以使用两种方式 模板方法最后.
Cpp设计模式：C ++设计模式
02-02
Cpp设计模式：C ++设计模式
C++设计模式课件
08-24
本课件详细介绍了23种最常用的C++设计模式，通过学习本课件读者能够掌握面向对象设计原则，重构技法改善设计和GOF核心设计模式等
区分重载(overload)，覆盖(Override)和隐藏(hide)
jixingzhong的专栏
10-31 3293
    重载overload，这个概念是大家熟知的。在同一可访问区内被声名的几个具有不同参数列的（参数的类型、个数、顺序不同）同名函数，程序会根据不同的参数列来确定具体调用哪个函数，这种机制就是重载。重载不关心函数的返回值类型，即返回类型不同无法构成重载。此外，C++ 中的const成员函数也可以构成overload。    总结一下重载的特征：　　1、处在相同的空间中，即相同的范围内；　　2、函
CPP 23个设计模式 听课笔记 (一)
Nancy_fairy的博客
06-22 257
教学视频链接：https://www.bilibili.com/video/BV1kW411P7KS?p=2 P01- 设计模式简介(21/6/22) 理解松耦合设计思想 掌握面向对象设计原则 掌握重构技法改善设计 掌握GOF核心设计模式 一、 推荐教材《设计模式：可复用面向对象软件的基础》 注意：设计模式的关键是可复用 CPP中大对数继承是public继承 如果是利用父类进行多态，那么vecotr内部要传入指针，不能是对象。 如果vector等内部是指针，那么传入内容时必须是栈对象
C/Cpp / 设计模式 / 简单工厂模式
布袋和尚
03-19 219
--------------------------------------------- -- 时间：2019-03-19 -- 创建人：Ruo_Xiao -- 邮箱：xclsoftware@163.com --------------------------------------------- 一、实质 本质是工厂实例创建并输出产品类实例的过程。 二、栗子 1、产品...
C++设计模式
lowB程序员
08-22 1438
设计模式
《CPP设计模式》09 抽象模式
Nancy_fairy的博客
09-30 153
1. 抽象模式是工厂模式的升级，可以说工厂模式是抽象模式的特例，但是工厂模式和抽象模式仍然是各自有各自的适应范围，不代表工厂模式可以适用的，抽象模式就更好。 2. 这里我们构建一个案例，未知品牌的数据库的操作，如可能是对MySQL, Oracle,等几种不同品牌的数据库的操作。这里由于变化的是品牌，不变的是所需操作，如包括:Connection、Command，以及DataReader等。首先利用工厂模式，具体需要实现的类和函数大致如下： 2.1 这里可以看到只要外界传入指定品牌的相应的工厂类即可，如MSQ
把信送给加西亚--行为型模式之五：中介者模式的实例
不积跬步无以至千里，不积小流无以成江海
12-25 1266
原创，转载请注明出处，谢谢！ 1 故事         公司组织去奥林匹克公园team building，主题是“把信送给加西亚”。头天，组长组织大家秘密商讨，主题时如何夺取第二天的ipad2大奖的计划。由于人员众多，组长怕大家不认识，要求每个人用一句话形容自己，然后顺时针把剩下的所有人描述自己的话再重复出来，这样经过2轮，名字基本记住了，虽然免不了张冠李戴：比如GC同学异常肯定的把硬件部
初识cppunit，设计模式
canjianx的专栏
05-03 496
本来没有这篇，但是看到前面的目标，只好写一下这篇了。 cppunit是一个单元测试框架，从junit移植而来，单元测试应该是比较清楚的，TDD对这个框剪应该比较敏感，TDD是测试驱动开发，第一次听说XP(极限编程)的时候对这个TDD没什么感觉，后来工作了才发现TDD是多么好的一个开发模式。而上天看那个《走出软件作坊》其中看到国内的中小IT企业大都没有单元测试，直接黑盒测试，交付产品。以至于
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值