CPP 设计模式

源于Design Pattern Explanation with C++ Implementation的 设计模式 C++ 1、单例模式(Singleton Pattern ) 2、抽象工厂模式(Abstract Factory Pattern ) 3、工厂方法模式(Factory Method Pattern ) 4、简单工厂模式(Simple Factory Pattern ) 5、建造者模式(Builder Pattern ) 6、原型模式(Prototype Pattern ) 7、结构模式(Str 阅读详情
备忘录模式
  • 在一个类内部记录另一个类的快照状态的模式。可以再合适的时候跳回复用

引用文字

  • 设计备忘录的三大步骤:
  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;
}

C++ 设计模式 在C++中,设计模式(Design Patterns)是用于解决在软件设计中经常遇到的一些通用问题的最佳实践。这些设计模式是在多年的软件开发过程中积累下来的经验和智慧的结晶。定义一个操作中的算法的框架,而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤。将一个类的接口转换成客户端所期望的另一种接口,从而使得原本由于接口不兼容而无法一起工作的类能够一起工作。将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 阅读详情

相关推荐

23种设计模式的解析与Cpp实现

23种设计模式的解析与Cpp实现

23种设计模式的cpp举例

23种设计模式的cpp举例

SnailElderBro的博客 1726

Cpp设计模式:C ++设计模式

Cpp设计模式:C ++设计模式

C++设计模式

设计模式

lowB程序员 1715

c++设计模式全系列+应用场景+实例说明

1. **工厂模式(Factory Pattern)**:工厂模式是一种创建型设计模式,用于创建对象而无需指定创建对象的具体类。包括简单工厂模式、工厂方法模式和抽象工厂模式。 2. **单例模式(Singleton Pattern)**:单例模式是一种创建型设计模式,确保一个类只有一个实例,并提供一个全局访问点。 3. **观察者模式(Observer Pattern)**:观察者模式是一种行为设计模式,定义了对象间的一对多依赖关系,使得当一个对象状态发生改变时,其相关依赖对象都会收到通知并自动更新。 4. **装饰者模式(Decorator Pattern)**:装饰者模式是一种结构设计模式,允许向一个对象动态添加新功能,而无需修改其源代码。 5. **策略模式(Strategy Pattern)**:策略模式是一种行为设计模式,定义了一系列算法,并使其可以相互替换,使得算法的变化独立于使用算法的客户端。 6. **适配器模式(Adapter Pattern)**:适配器模式是一种结构设计模式,允许接口不兼容的类能够一起工作,将一个类的接口转换成客户希望的另一个接口。

非线性功率放大器对QAM传输BER性能的影响及补偿

1、线性功率放大器对传输性能的影响 为表述非线性功率放大器对传输性能的影响,以Saleh模型进行观察。具体来说,在QAM调制器之后添加一个非线性模块,使调制后的波形经历AM / AM和AM / PM转换。 在Saleh模型中,转换用四个参数表示,即AM / AM转换为????a和????a,AM / PM转换为????p和????p。 在Saleh模型中,AM / AM和AM / PM方程以输入电压u的大小表示为: 式中,FAM / AM是AM / AM转换的输出电压与输入电压的关系,而FAM

太阳帅帅的博客 2081

Cpp设计模式及举例

C++设计模式之单例模式 C++设计模式之工厂模式 C++设计模式之代理模式 C++设计模式之外观模式 C++设计模式之适配器模式 C++设计模式之模板方法模式 C++设计模式之策略模式 C++设计模式之命令模式 C++设计模式之观察者模式 C++设计模式之装饰模式 ...

weixin_44754751的博客 515

智能驾驶域控(ADCU)方案介绍

本文主要对智能驾驶域控(ADCU)方案相关知识进行总结,以加深理解,及方便后续查漏补缺。

liuxu324的博客 1583

设计模式【cpp实现版本】

单例模式是一种设计模式,确保一个类只有一个实例,并提供全局访问点。常见的实现方式包括饿汉式和懒汉式。饿汉式在程序启动时即创建实例,线程安全但可能浪费资源;懒汉式在首次使用时创建实例,需考虑线程安全问题,可通过加锁或静态局部变量实现。工厂模式则用于封装对象的创建过程,分为简单工厂、工厂方法和抽象工厂。简单工厂通过一个工厂类创建多种产品,但扩展性差;工厂方法为每种产品提供一个工厂类,扩展性好;抽象工厂则用于创建一系列相关产品,适合产品簇的场景。这些设计模式有助于提高代码的可维护性和扩展性。

qq_55317476的博客 1154

Arduino安装图文教程:小白也能轻松上手

手把手带你完成Arduino安装全过程,无论你是编程新手还是硬件小白,都能快速搭建开发环境。结合arduino安装教程与实操步骤,避开常见错误,让创作即刻启程。

weixin_35509395的博客 1110

主流算力卡性能对比分析

超大规模AI训练/HPC:优先选择NVIDIA H100或AMD MI300X,需关注显存带宽和多卡互联能力。企业级AI训练:NVIDIA A100性价比更高,生态成熟。国内自主可控需求:华为昇腾910B是首选,支持液冷和低功耗设计。本地AI推理/游戏:NVIDIA RTX 4090或RTX 5090性价比突出,但需注意显存容量限制。边缘计算/低功耗场景:华为昇腾310或清微智能TX536(能效比6.3TOPS/W@INT8)更合适。

m0_69867914的博客 7814

【CPP】一文带你掌握CPP设计模式

设计模式是软件开发中用于解决常见问题的经典解决方案。它们是由经验丰富的开发者总结出来的最佳实践,能够提高代码的可维护性、可扩展性和可复用性。设计模式是软件开发中的经典解决方案,能够提高代码的可维护性、可扩展性和可复用性。通过掌握常见的设计模式,开发者可以更好地组织代码结构,解决复杂问题。理解模式的核心思想:每个设计模式都有其独特的应用场景和解决问题的方式。灵活运用:在实际开发中,根据具体需求选择合适的设计模式。避免过度设计:设计模式是工具,而不是目标,避免为了使用模式而增加不必要的复杂性。

Ape's IT Blog 948

避开STM32中断优先级配置的坑:HAL_NVIC_SetPriority()参数你真的用对了吗?

本文深入解析STM32中断优先级配置中的关键问题,重点剖析HAL_NVIC_SetPriority()函数的正确使用方法。通过实际案例揭示优先级分组设置、抢占优先级与子优先级的区别,提供多中断系统中的优化策略和调试技巧,帮助开发者避免常见配置错误,提升系统稳定性。

weixin_42532938的博客 425

cpp_redis源码架构解析:深入理解现代C++ Redis客户端设计模式

cpp_redis是一个基于C++11的异步多平台轻量级Redis客户端库,它支持同步操作、流水线、哨兵和高可用性。这个现代化的C++ Redis客户端库设计精巧,采用了多种现代C++设计模式,为开发者提供了高效、线程安全的Redis访问能力。本文将深入解析cpp_redis的源码架构,帮助您理解其核心设计思想和实现原理。 ## 架构概览:分层设计与模块化 cpp_redis采用了清晰的分层架

gitblog_01072的博客 1007

RV1126B RV1126B-P 瑞芯微 高性能视觉处理器SoC 芯片

它集成了大量算法加速器,如 HDR、3A、LSC、3DNR、2DNR、锐化、去雾、鱼眼校正、伽马校正、特征点检测等。此外,还配备了一款最多8兆像素的 AI-ISP,作为对传统ISP 的补充,以提供卓越的空间去噪性能和增强的图像增强效果。除了先前的高性能多媒体区块外,RV1126B还包含丰富的音频、内存和其他外围接口,如I2C、SPI、PWM等。借助这-特性,来自相机的视频可以以高分辨率进行编码,并存储在本地内存中,同时还能将另-段较低分辨率的视频传输到云存储。

szhorsway的博客 1869

【K210+STM32项目】基于K210与STM32协同工作的智能垃圾分类系统设计与实现(更新3.0版本)(完整工程资料源码)

STM32F407STM32F407_2(含有app功能)

嵌入式技术开发 2498

MediaMTX 移动端 HLS 卡顿慢?调 3 个 LL-HLS 参数把首帧压到 1 秒内

你用手机在地铁、弱 WiFi 里打开直播间,画面卡在缓冲圈转了十几秒才出来——这是用 MediaMTX 分发直播时最常见的 HLS 加载慢问题。MediaMTX 是一个开箱即用的实时媒体服务器,能把 RTSP / RTMP / SRT / WebRTC 等直播流转成 **LL-HLS(低延迟 HLS)**,供手机浏览器和 App 直接播放。慢,往往不是带宽不够,而是几个配置项没调到位。下面按「排查

gitblog_01117的博客 408

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

c++ 设计模式(一)

我也是不经意间看到的,之前也学习过设计模式,只不过总是觉得“纸上得来终觉浅”,总要动手实践一下才会有所体会和感悟。 如果英语还可以的话就看这个:JakubVojvoda/design-patterns-cpp 如果英语比较菜就看这个:liu-jianhao/Cpp-Design-Patterns 参考:分享几个适合初学者的C语言/C++开源项目!涉及从基础语法到算法 另外还看到一个比较好的c项目(不是设计模式):AllAlgorithms/c ...

juluwangriyue的博客 194

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

cpp设计模式学习总结

。。。

Go_hack的博客 745

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明,包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

设计模式C++实现详解

《设计模式C++实现》是一个GitHub上的开源项目,由Jakub Vojvoda维护,它提供了C++中23种经典设计模式的实现和示例。这个项目的目标是帮助开发者更好地理解和运用这些设计模式,以便在软件开发中提高代码质量、可维护性和可扩展性。这些设计模式源自“Gang of Four”的著作《设计模式:可复用面向对象软件的基础》。 ## 2. 项目快速启动 ### 安装依赖 确保你的系统安装...

gitblog_00338的博客 539

c++ 24种设计模式

C++ 常用设计模式(学习笔记) 设计模式 1、工厂模式 在工厂模式中,我们在创建对象时不会对客户端暴露创建逻辑,并且是通过使用一个共同的接口来指向新创建的对象。工厂模式作为一种创建模式,一般在创建复杂对象时,考虑使用;在创建简单对象时,建议直接new完成一个实例对象的创建。 1.1、简单工厂模式 主要特点是需要在工厂类中做判断,从而创造相应的产品,当增加新产品时,需要修改工厂类。...

qq_37871669的博客 2435

【C++】设计模式

定义一系列算法,把它们一个个封装起来,并且使它们可互相替换(变化)。该模式使得算法可独立于使用它的客户程序(稳定)而变化(扩展,子类化)定义对象间的一种一对多(变化)的依赖关系,以便当一个对象(Subject)的状态发生改变时,所有依赖于它的对象都得到通知并自动更新。动态(组合)地给一个对象增加一些额外的职责。就增加功能而言,Decorator模式比生成子类(继承)更为灵活(消除重复代码 & 减少子类个数)。将抽象部分(业务功能)与实现部分(平台实现)分离,使它们都可以独立地变化。

IdealSanX的博客 1432

C++设计模式系列

C++设计模式——简单工厂模式 C++设计模式——工厂方法模式 C++设计模式——抽象工厂模式 C++设计模式——单例模式 C++设计模式——建造者模式 C++设计模式——原型模式 C++设计模式——适配器模式 C++设计模式——桥接模式 C++设计模式——组合模式 C++设计模式——装饰模式 C++设计模式——外观模式 C++设计模式——享元模式 C++设计模式——代理模...

CoderAldrich的专栏 2万+
上一篇: CPP STL
下一篇: 一个自己实现的Vector 完善版本
devil_1995
博客等级 码龄9年 1粉丝 6原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值