0911，类与类之间的关系，设计原则，工厂模式

最新推荐文章于 2024-09-16 15:03:26 发布
最新推荐文章于 2024-09-16 15:03:26 发布
阅读量698 收藏 18
点赞数 5
分类专栏： 我爱学习 文章标签： c++ c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51583806/article/details/142148827
版权

01_figure.cc     //简单工厂

#include <math.h>
#include <iostream>
#include <string>
#include <memory>

using std::cout;
using std::endl;
using std::string;
using std::unique_ptr;

//-------------------------------------------------//
//-------------------------------------------------//
class Figure
{
public:
    virtual void display() const = 0;
    virtual double area() const = 0;
    //基类的析构函数设置为虚函数
    virtual ~Figure(){};
};
//-------------------------------------------------//
//-------------------------------------------------//
class Rectangle
: public Figure
{
public:
    Rectangle(double length = 0, double width = 0)
        : _length(length)
          , _width(width)
    {
        cout << "Rectangle(double = 0, double = 0)" << endl;
    }
    void display() const override{
        cout << "Rectangle";
    }
    double area() const override{
        return _length * _width;
    }
    ~Rectangle(){
        cout << "~Rectangle()" << endl;
    }
private:
    double _length;
    double _width;
};

//-------------------------------------------------//
//-------------------------------------------------//
class Circle
: public Figure
{
public:
    Circle(double radius = 0)
        : _radius(radius)
    {
        cout << "Circle(double = 0)" << endl;
    }

    void display() const override{
        cout << "Circle";
    }
    double area() const override{
        return 3.14 * _radius *_radius;;
    }
    ~Circle(){
        cout << "~Circle()" << endl;
    }

private:
    double _radius;
};

//-------------------------------------------------//
//-------------------------------------------------//
class Triangle
: public Figure
{
public:
    Triangle(double a = 0, double b = 0, double c = 0)
        : _a(a)
          , _b(b)
          , _c(c)
    {
        cout << "Triangle(double = 0, double = 0, double = 0)" << endl;
    }
    void display() const override{
        cout << "Triangle";
    }
    double area() const override{
        double tmp = (_a + _b + _c)/2;
        return sqrt(tmp * (tmp - _a) * (tmp - _b) * (tmp - _c));
    }
    ~Triangle(){
        cout << "~Triangle()" << endl;
    }
private:
    double _a;
    double _b;
    double _c;
};
//-------------------------------------------------//
//-------------------------------------------------//
//简单工厂/静态工厂：根据产品的名字生产对应的产品
//缺点：违反 单一职责 开放闭合  依赖倒置
//           
//优点：简单  名字-->产品

class Factory{
public:
    static Figure* create(const string & name){
        if(name=="triangle"){
            Triangle *ptri=new Triangle(10,20,20);
            return ptri;
        }
        else if(name=="circle"){
            Circle *pcir=new Circle(10);
            return pcir;
        }
        else if(name=="rectangle"){
            Rectangle *prec=new Rectangle(10.0,20.0);
            return prec;
        }else{
            return nullptr;
        }
    }
};
#if 0
    Figure* pcir=creat_c();
    Figure* ptri=creat_t();
    Figure* prec=creat_t();

    //读取配置文件，获取配置文件中的内容
    //配置文件的类型：txt,conf,xml,yang

    //基类接收派生类
    /* Rectangle *creat_r(){ */
    Figure *creat_r(){
        Rectangle *prec=new Rectangle(10,20);
        return prec;
    }
    Figure *creat_t(){
        Triangle *ptri=new Triangle(10,20,20);
        return ptri;
    }
    Figure *creat_c(){
        Circle *pcir=new Circle(10);
        return pcir;
    }
#endif

//-------------------------------------------------//
//-------------------------------------------------//
void func(Figure *pfig){
    pfig->display();
    cout << "的面积 : " << pfig->area() << endl;
}

//-------------------------------------------------//
//-------------------------------------------------//

void test(){
    /* Figure * pc=Factory::create("circle"); */
    /* Figure * pt=Factory::create("triangle"); */
    /* Figure * pr=Factory::create("rectangle"); */

    unique_ptr<Figure> pc(Factory::create("circle"));
    unique_ptr<Figure> pt(Factory::create("triangle"));
    unique_ptr<Figure> pr(Factory::create("rectangle"));

    func(pc.get());
    func(pt.get());
    func(pr.get());

}

int main(int argc, char **argv)
{
    test();
    return 0;
}

02_figure.cc           //工厂模式

#include <math.h>
#include <iostream>
#include <string>
#include <memory>

using std::cout;
using std::endl;
using std::string;
using std::unique_ptr;

//-------------------------------------------------//
//-------------------------------------------------//
class Figure
{
public:
    virtual void display() const = 0;
    virtual double area() const = 0;
    virtual ~Figure(){};
};
//-------------------------------------------------//
//-------------------------------------------------//
class Rectangle
: public Figure
{
public:
    Rectangle(double length = 0, double width = 0)
        : _length(length)
          , _width(width)
    {
        cout << "Rectangle(double = 0, double = 0)" << endl;
    }
    void display() const override{
        cout << "Rectangle";
    }
    double area() const override{
        return _length * _width;
    }
    ~Rectangle(){
        cout << "~Rectangle()" << endl;
    }
private:
    double _length;
    double _width;
};

//-------------------------------------------------//
//-------------------------------------------------//
class Circle
: public Figure
{
public:
    Circle(double radius = 0)
        : _radius(radius)
    {
        cout << "Circle(double = 0)" << endl;
    }

    void display() const override{
        cout << "Circle";
    }
    double area() const override{
        return 3.14 * _radius *_radius;;
    }
    ~Circle(){
        cout << "~Circle()" << endl;
    }

private:
    double _radius;
};

//-------------------------------------------------//
//-------------------------------------------------//
class Triangle
: public Figure
{
public:
    Triangle(double a = 0, double b = 0, double c = 0)
        : _a(a)
          , _b(b)
          , _c(c)
    {
        cout << "Triangle(double = 0, double = 0, double = 0)" << endl;
    }
    void display() const override{
        cout << "Triangle";
    }
    double area() const override{
        double tmp = (_a + _b + _c)/2;
        return sqrt(tmp * (tmp - _a) * (tmp - _b) * (tmp - _c));
    }
    ~Triangle(){
        cout << "~Triangle()" << endl;
    }
private:
    double _a;
    double _b;
    double _c;
};
//-------------------------------------------------//
//-------------------------------------------------//
//工厂模式，为每个产品创建对应的工厂
//优点：满足 单一职责 开放闭合  依赖倒置
//缺点：工厂的数量随着产品的数量急剧上升

class Factory{
public:
    virtual Figure* create()=0;
    virtual ~Factory(){}
};
class C_Factory
:public Factory
{
    virtual Figure* create()override{
            Circle *pcir=new Circle(10);
            return pcir;
    }
};
class R_Factory
:public Factory
{
    virtual Figure* create()override{
            Rectangle *pcir=new Rectangle(10,10);
            return pcir;
    }
};
class T_Factory
:public Factory
{
    virtual Figure* create()override{
            Triangle *pcir=new Triangle(3,4,5);
            return pcir;
    }
};

//-------------------------------------------------//
//-------------------------------------------------//
void func(Figure *pfig){
    pfig->display();
    cout << "的面积 : " << pfig->area() << endl;
}

//-------------------------------------------------//
//-------------------------------------------------//

void test(){
    
    unique_ptr<Factory> recFac(new R_Factory());//创建对象
    unique_ptr<Figure> pr(recFac->create());//调用创建函数
                                        
    unique_ptr<Factory> recCir(new C_Factory());
    unique_ptr<Figure> pc(recCir->create());

    unique_ptr<Factory> recTri(new T_Factory());
    unique_ptr<Figure> pt(recTri->create());


    func(pc.get());//unique_ptr --> Figure* 
    func(pt.get());
    func(pr.get());


}

int main(int argc, char **argv)
{
    test();
    return 0;
}

作业

01 扩展阅读（阅读，加深对面向对象的理解）
[OO真经]：https://www.cnblogs.com/leoo2sk/archive/2009/04/09/1432103.html

02 类与类之间的关系有哪几种？各自的特点怎样的？

继承/泛化  关联  组合  聚合  依赖

        结构上： 继承（竖向） 其他（横向）

        语义上：继承is，依赖use，关联/组合/聚合has

        耦合程度：依赖 <关联 < 聚合< 组合<继承

        代码层面：

        成员函数：依赖
        数据成员：聚合/关联（引用/指针） 组合（成员子对象）
        成员函数&数据成员：继承

03 面向对象设计有哪些原则？各自的特点是什么？

单一功能，开放关闭，里氏替换，实现倒置，接口分离，迪米特，组合复用

01_ 单一功能 一个类只做好一件事，只有一个引起它变化的原因
02_ 开放闭合 对抽象编程，而不是对具体编程（开放实现，关闭修改
03_ 里氏替换 派生类必须能替换基类（实现抽象，不能覆盖非抽象方法
04_ 接口分离 设置许多小而专的借口，而不是一个大的接口
05_ 依赖倒置 面向接口编程，依赖于抽象
06_ 迪米特 目标是降低耦合，也叫最少知道/最少知识原则
07_ 组合复用 用组合的方式替代继承

开放闭合是目标，里氏替换是基础，依赖倒置是手段

04 运用所学的UML类图的知识，画出“文本查询程序的扩展”作业的类图。【C++ Primer 15.9节作业】（可以贴图）

05 设计模式可以分为几类？分别有哪些？

创建型(5) 提供对象的创建机制
单例，简单工厂，工厂方法，抽象工厂，原型，建造者

结构性(7) 将类和对象组合成更大的结构，保证结构高效性灵活性
适配器，桥接，组合，装饰，外观，享元，代理

行为型(11) 沟通和对象之间的责任分配
职责链，命令，解释器，迭代器，中介者，备忘录，观察者，状态，策略，模板方法，访问者

06 什么是单例模式？它有哪些特点？

1，唯一性

2，全局访问

3，懒加载

4，控制访问（避免外部直接创建，复制

07 什么是工厂模式？它有哪些特点？

优点：满足单一职责，开放关闭，依赖倒置

缺点：类的数量随需求急剧上升

08 实现工厂模式，并画出其类图

02_figure.cc

qq_51583806 彩雷王
关注
专栏目录
常见设计模式的解读和对应代码示例，包括设计原则和软件工程中类之间的依赖关系
08-28
2、设计原则 开闭原则 里氏替换原则 依赖倒置原则 单一职责原则 接口隔离原则 迪米特法则 合成复用原则 3、设计模式 创建型模式(Creational Pattern) 单例模式(Singleton Pattern) 工厂模式(Factory Pattern) 抽象...
PHP实现设计模式中的抽象工厂模式详解
12-18
抽象工厂模式是设计模式中的一种，主要目的是为了提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们的具体类。这种模式遵循“开闭原则”，即对扩展开放，对修改关闭，允许在不修改现有代码的基础上增加新...
设计模式之类之间的关系和六大原则
konglongdanfo的博客
10-27 3755
设计模式之类之间的关系和六大原则1 类之间的关系1.1 继承关系1.2 实现关系1.3 依赖关系1.4 关联关系1.5 聚合关系1.6 组合关系1.7 总结2 六大原则2.1 单一职责原则2.2 开放-封闭原则2.3 依赖倒转原则2.4 里氏代换原则2.5 接口隔离原则2.6 迪米特法则3 各种设计模式 1 类之间的关系 类与类之间的关系大概有6种，要看懂UML图，首先需要了解这几种关系。 1.1...
深入理解设计模式-设计模式分类与关系
少说，多做
12-21 1万+
文章目录前言一、设计模式分类1.创建型模式，共五种2.结构型模式，共七种3.行为型模式，共十一种4.扩展模式二、设计模式之间的关系结尾 前言 设计模式的本质是面向对象设计原则的实际运用，是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。 正确使用设计模式具有以下优点。 可以提高程序员的思维能力、编程能力和设计能力。 使程序设计更加标准化、代码编制更加工程化，使软件开发效率大大提高，从而缩短软件的开发周期。 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。 一、设计
C++设计模式介绍、分类与设计模式原则
hanxiaoyong_的博客
05-24 2904
一、设计模式定义 二、设计模式的优点 三、设计模式缺点 四、设计模式中的抽象思维 五、抽象的方法 六、设计模式应用场景 七、设计模式分类 八、设计模式八大原则 附加知识 （1）C++面向对象三种访问修饰符 （2）父类析构函数必须为虚函数 （3）override关键字使用 （4）final关键字使用 （5）父类对象可以与子类对象相互转化吗 （6）虚函数、虚函数表介绍
Java常见设计模式总结
热门推荐
张维鹏的博客
09-18 19万+
设计模式是一套经过反复使用的代码设计经验，目的是为了重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式于己于人于系统都是多赢的，它使得代码编写真正工程化，它是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现实中都有相应的原理来与之对应，每种模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。总体来说，设计模式分为三大类：5种创建型模式、7种结构型模式、11种行为型模式
【设计模式】之工厂模式（三种）
小杰不秃头的博客
05-03 1691
今天给大家介绍23种设计模式中的工厂模式，学过Spring的小伙伴应该不陌生，今天给大家详细介绍一下它。🌈
C++ 设计模式——工厂模式
qq_68194402的博客
08-17 1646
工厂模式是一种创建对象的设计模式，主要用于将对象的创建与使用分离。它提供了一种接口来创建对象，但由子类决定实例化哪个类。工厂模式有几种变体，包括简单工厂模式、工厂方法模式和抽象工厂模式。
Java 设计模式——工厂方法模式
代码星辰的博客
07-16 2133
本文介绍了工厂方法模式的相关知识。
设计模式深度解析：工厂方法模式与抽象工厂模式的深度对比
制定明确可量化的目标，坚持默默的做事。
03-11 8684
本文旨在深入对比软件设计模式中的工厂方法模式和抽象工厂模式。工厂方法模式侧重于定义一个用于创建对象的接口，让子类决定实例化哪一个类。它提供了一种封装机制，将对象的创建与使用分离，降低了耦合度。而抽象工厂模式则提供了一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式具有更强的扩展性，能够适应更为复杂的产品结构。通过对比分析，我们发现，两种模式各有优势，工厂方法模式更适用于单一产品的创建，而抽象工厂模式在处理产品族问题时更为得力。在选择使用哪种模式时，需根据具体的应用场景和需求进行综合考量
设计模式创建型——抽象工厂模式
tszc95的博客
04-06 8518
抽象工厂模式（Abstract Factory Pattern）隶属于设计模式中的创建型模式，用于产品族的构建。抽象工厂是所有形态的工厂模式中最为抽象和最具一般性的一种形态。抽象工厂是指当有多个抽象角色时使用的一种工厂模式。抽象工厂模式可以向客户端提供一个接口，使客户端在不必指定产品的具体情况下，创建多个产品族中的产品对象。
设计模式（一）设计模式的分类与区别
HK的博客
05-17 1万+
设计模式的分类、设计模式的原则、设计模式的适用场景、设计模式的区别
设计模式基础培训材料-面向对象设计原则与模式
06-08
### 设计模式基础培训材料-面向对象设计原则与模式 #### 一、设计模式概览 设计模式是在软件工程领域中被广泛接受的一种用于解决常见问题的通用解决方案。这些模式通常涉及面向对象编程(OOP)，并且能够帮助开发...
javascript设计模式 – 工厂模式原理与应用实例分析
10-15
JavaScript中的工厂模式是一种设计模式，属于类创建型模式，它主要解决了简单工厂模式在扩展时需要修改原有代码的问题。在工厂模式中，我们定义一个创建对象的接口，并由子类来决定实例化哪个类，从而将类的实例化...
24种设计模式介绍与6大设计原则
08-30
创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：...
C++ STL中sort函数
weixin_43349440的博客
09-15 166
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 258
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 515
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
最新发布
2301_79796701的博客
09-16 804
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值