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)**:适配器模式是一种结构设计模式,允许接口不兼容的类能够一起工作,将一个类的接口转换成客户希望的另一个接口。

Windows11 升级到24H2后,原本的protel99se软件的DDB图纸文件打不开解决办法

Windows11更新后无法打开DDB文件

xingchen2837的博客 428

Cpp设计模式及举例

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

weixin_44754751的博客 515

Stata: 空间面板数据模型及Stata实现

  作者:游万海 (福州大学) Stata 连享会: 知乎 | 简书 | 码云 | 优快云   来源:Golgher 和 Voss (2016)   1. 背景介绍 由于面板数据模型所具有的众多优点 (刻画个体异质性,减弱模型共线性和增加自由度等),其被广泛应用于实证计量中。在 「 Stata: 面板数据模型-一文读懂」 文中,我们已对面板数据模型进行了介绍。 然而,当研究样本涉及到多个...

Stata连享会 7万+

设计模式【cpp实现版本】

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

qq_55317476的博客 1154

Qt5.12.12安卓开发环境搭建:Windows下避开SDK版本坑的保姆级教程

本文提供Qt5.12.12在Windows下搭建Android开发环境的详细教程,重点解决SDK版本兼容性问题,特别是cmdline-tools与JDK8的匹配陷阱。通过精准选择组件版本、手动配置路径和修复常见错误,帮助开发者高效完成环境配置,适用于Qt跨平台移动开发。

weixin_33737774的博客 543

单点DToF激光测距传感器各家产品的比较

汇总DToF 单点测距传感器的相关信息

Linux 设备驱动概述及开发环境构建 (一) 1780

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

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

Ape's IT Blog 948

中国知网文献引用导入EndNote9.X,Web of science导入endnote以及谷歌学术导入endnote图文详解,全网最细版本适用EndNote9.x,Endnote20版本

在科研中用到EndNote管理文献,遇到插入文献时,中国知网如何将参考文献导进Endnote9.x或者web of sicence,谷歌学术如何将文章,文献导入进文献管理软件EndNote的详细图文2022版本解释,全网最细的笔记教程,值得大家参考收藏学习

sakura的博客 5179

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

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

gitblog_01072的博客 1007

ADS使用Smith圆图进行阻抗匹配

在处理RF系统的实际应用问题时,总会遇到一些非常困难的工作,对各部分级联电路的不同阻抗进行匹配就是其中之一。一般情况下,需要进行匹配的电路包括天线与低噪声放大器(LNA)之间的匹配、功率放大器输出(RFOUT)与天线之间的匹配、LNA/VCO输出与混频器输入之间的匹配。匹配的目的是为了保证信号或能量有效地从“信号源”传送到“负载”。 阻抗匹配(impedance matching) 信号源内阻与所接传输线的特性阻抗大小相等且相位相同,或传输线的特性阻抗与所接负载阻抗的大小相等且相位相同,分别称为传输线的输

红茶绿茶和奶茶的博客 3万+

人像抠图 + OpenGL ES 还能这样玩?没想到吧(附带源码)

OpenGL ES 利用抠图算法实现人像留色。

字节流动 3万+

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

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

gitblog_01117的博客 408

【AI技术赋能有限元分析应用实践】Abaqus有限元分析与深度学习结合20个案例与有限元分析数据来源方法说明

结合 Abaqus 和深度学习,数据的获取和处理是关键的一步。通过从仿真、实验、公开数据库或合成数据中获取数据,经过预处理后,可以将其用于训练深度学习模型。最终,将训练好的深度学习模型与 Abaqus 集成,用于材料行为预测、结构优化、非线性分析、损伤预测等任务,从而提升仿真效率和精度。

源代码杀手的博客 3213

c++ 设计模式(一)

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

juluwangriyue的博客 194

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

cpp设计模式学习总结

。。。

Go_hack的博客 745

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

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

设计模式C++实现详解

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

gitblog_00338的博客 539

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

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、付费专栏及课程。

余额充值