QtC++设计模式代码集-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_32312889/article/details/143096969

简介：设计模式是解决软件设计问题的行业标准最佳实践，本集合提供了一个学习C++与Qt框架中设计模式的资源。内容涵盖了如何使用Qt的信号与槽机制实现观察者模式，以及如何利用Qt的其他特性来实现单例、工厂、抽象工厂、建造者、代理、模板方法、装饰和外观等设计模式。通过这些示例代码，开发者可以更深入理解C++和Qt的应用，并将设计模式有效应用于实际项目，提升代码的灵活性、可维护性和可扩展性。 QtC++设计模式代码

1. 设计模式在软件开发中的重要性

在软件工程领域，设计模式是软件设计的基石。它们是针对特定问题的通用解决方案，以一种可复用的方式捕捉了人们在软件设计过程中的最佳实践。设计模式的引入，不仅提高了开发效率，而且有助于创建出更加灵活、易于维护和扩展的系统。

设计模式概述

设计模式的定义和起源

设计模式最初由建筑领域概念衍生而来，被引入软件工程是在1994年，由Erich Gamma、Richard Helm、Ralph Johnson和John Vlissides共同撰写的《Design Patterns: Elements of Reusable Object-Oriented Software》一书中。该书提出了23种设计模式，分为创建型、结构型和行为型三大类。

设计模式的作用和分类

设计模式的作用主要体现在促进软件模块化、降低模块间的耦合度、提升代码复用率以及应对软件项目中的常见问题。它们通常按照功能需求和解决方案的相似性被分为三大类：创建型模式、结构型模式和行为型模式。这些分类有助于开发者更好地理解每个模式的应用场景和设计意图。

设计模式的核心原则

设计模式遵循一些核心的设计原则，这些原则是设计模式能够成功实现其目标的关键。

开闭原则、里氏替换原则

开闭原则强调软件实体应对扩展开放，对修改封闭。它鼓励设计的模块化，以支持系统的可扩展性。里氏替换原则表明，所有使用基类的地方都应该能够透明地使用其子类对象。

依赖倒置原则、接口隔离原则

依赖倒置原则主张高层模块不应该依赖低层模块，它们都应该依赖抽象。接口隔离原则则是关于不应该强迫客户依赖于它们不用的方法，即客户端应该依赖于最小的接口集合。

合成复用原则、迪米特法则

合成复用原则强调要尽量使用对象组合，而不是类继承。迪米特法则（也称为最少知识原则）建议一个对象应该对其他对象有尽可能少的了解。

设计模式与软件质量

设计模式在提升软件整体质量方面发挥着重要作用。

提高代码的可维护性和扩展性

设计模式通过提供经证实的解决方案，促进了代码结构的清晰化和模块化。这种组织方式简化了代码的维护工作，并且使得向系统中添加新功能变得更为容易。

促进代码复用和降低耦合度

利用设计模式的策略，开发者可以构建出更加模块化的组件，这有助于提高代码的复用性，并且减少了不同模块间的依赖关系，从而降低了整体系统的耦合度。

增强系统的稳定性和可理解性

设计模式使得软件系统的行为更加可预测，因为它遵循了共同认可的模式和结构。此外，模式的使用还提高了代码的可读性，使新加入项目的成员更快理解系统结构。

通过以上各点，我们可以看到设计模式不仅是理论上的指导原则，更是实践中帮助开发人员构建高效、可靠和易于维护软件的有力工具。在后续章节中，我们将深入探讨设计模式在Qt框架中的具体实现以及它们在实际项目中的应用和好处。

2. Qt框架概述及其跨平台能力

Qt框架简介

Qt的历史和版本迭代

Qt，一个跨平台的C++应用程序框架，由Trolltech公司（后来被Nokia收购）于1991年启动开发，首次公开发布于1995年。它的设计初衷是为了解决软件开发者面临的平台依赖问题，使他们能够编写一次代码，然后在多个平台上编译和运行而无需做重大改动。

版本迭代过程中的亮点包括： - Qt 1.x ：提供了初步的跨平台GUI支持。 - Qt 2.x ：引入了更复杂的组件和对网络与数据库的支持。 - Qt 3.x ：对图形、网络和数据库功能进行了大范围的增强。 - Qt 4.x ：引入了信号与槽的改进、强大的2D图形引擎和QML。 - Qt 5.x ：重构了模块系统、改进了性能、支持了现代C++特性。

Qt的基本架构和核心组件

Qt的基本架构是模块化的，它将广泛的功能划分为不同的模块，每个模块负责一组特定的功能。核心组件包括：

Qt Widgets ：提供了一组丰富的预设计控件，用于构建交互式桌面应用程序。
Qt Quick ：一个用于开发动态和流畅的用户界面的框架，特别适合触摸屏设备。
Qt Multimedia ：提供处理音频、视频、相机和收音机的API。
Qt Network ：包含用于网络编程的类，支持TCP/IP和UDP协议。
Qt SQL ：包含用于数据库操作的API。
Qt WebEngine ：用于在应用程序中嵌入网页内容的模块。

Qt的跨平台特性

跨平台机制的实现原理

Qt框架跨平台的核心机制在于其抽象层。Qt定义了一个抽象层，为不同的操作系统提供了统一的API。开发者编写应用程序时，通过Qt提供的抽象层API进行编程，Qt在底层会将这些调用转换为对应平台的本地调用。

Qt支持的平台和编译器

Qt框架支持广泛的平台和编译器。目前，它几乎可以在所有主流的操作系统上运行，包括：

Windows（包括Windows XP至最新的Windows 10）
macOS（包括从OS X开始的所有版本）
Linux（以及基于Linux的各种发行版）
Android
iOS

为了编译Qt应用程序，官方支持的编译器包括：

GCC（适用于Linux和macOS）
Clang（适用于Linux、macOS和Windows）
MSVC（适用于Windows）
MinGW（适用于Windows）

Qt在实际项目中的应用案例

桌面应用程序开发

Qt是一个非常受欢迎的桌面应用程序开发框架。例如，著名的文件管理器、资源管理器和视频播放器等都是用Qt开发的。Qt提供了丰富的控件和样式，使得开发者能够快速开发出美观且功能强大的桌面应用程序。

移动和嵌入式设备应用开发

Qt的Qt Quick模块非常适合开发触摸屏幕和移动应用程序，特别是那些需要动画和流畅用户体验的应用。Qt为Android和iOS等平台提供了一套完整的开发解决方案，使得一次编写代码，轻松部署到多个平台成为可能。

实际项目案例分析

假设我们需要为一家企业开发一个跨平台的库存管理系统。使用Qt框架，可以将开发的工作量集中在业务逻辑的实现上，而界面和平台特定的部分则可以利用Qt的跨平台特性和丰富的组件库来完成。代码可以在各个平台下编译和运行，而无需做大规模的修改，大大提高了开发效率和软件质量。

3. C++面向对象编程语言特性

C++作为一门支持面向对象编程（OOP）的语言，它的面向对象特性是其强大功能的核心所在。本章将详细介绍C++的面向对象编程特性，包括类与对象的定义、继承、多态、封装，以及C++11及之后版本引入的高级特性。

C++概述

C++的发展历史和语言特点 C++是Bjarne Stroustrup于1979年在贝尔实验室开始设计的一种通用编程语言，它旨在提供一种高效、灵活且接近硬件的编程语言，同时也支持高级的抽象机制。C++是C语言的超集，它在C语言的基础上增加了面向对象的特性、异常处理、泛型编程等现代语言特性。C++支持面向对象的三大特性：封装、继承和多态，这使得C++成为了开发复杂系统和高性能应用程序的首选语言。

C++与面向对象编程的关系面向对象编程是一种编程范式，它使用“对象”来设计软件。C++的OOP特性，尤其是类和对象的构造，继承、多态等概念，使程序员能够创建结构化的代码和模块化的设计。C++的设计哲学鼓励程序员在编程时考虑数据结构以及这些数据结构的操作。这种将数据和操作封装在一起的方法有助于保持数据的完整性和安全性，同时简化代码的维护和扩展。

C++核心特性

类和对象的定义与使用在C++中，类是创建对象的蓝图。一个类可以包含数据成员（变量）和成员函数（方法），用以描述对象的状态和行为。通过关键字 class 或 struct 来定义一个类，然后使用这个类来创建对象。

class MyClass {
public:
    void myMethod() {
        // ...
    }
};

int main() {
    MyClass obj; // 创建对象
    obj.myMethod(); // 调用对象的方法
}

继承、多态和封装的实现继承允许新定义的类（派生类）继承一个或多个已存在的类（基类）的属性和方法。这在C++中使用冒号（ : ）后跟访问级别（ public , protected , private ）和基类名来实现。

多态允许使用基类的指针或引用来指向派生类的对象，并调用在基类中声明的方法，具体调用哪个派生类的实现将由对象的实际类型决定。在C++中，多态性通常是通过虚函数实现的。

封装是OOP的一个重要原则，它隐藏了对象的内部状态和实现细节，只暴露必要的操作接口给外界。C++中通过访问控制符（public, private, protected）来实现封装。

模板编程及其在设计模式中的应用模板是C++中用于编写泛型代码的特性，允许创建可以适用于多种数据类型的函数或类。模板编程在设计模式中有广泛的应用，例如，工厂模式可以使用模板来创建不同类型的产品。

template <typename T>
class GenericFactory {
public:
    T create() {
        return T();
    }
};

// 使用模板工厂来创建不同类型的对象
GenericFactory<MyClass> factory;
MyClass myObject = factory.create();

C++高级特性及其实践

智能指针和资源管理为了避免内存泄漏等问题，C++11引入了智能指针的概念，主要包括 std::unique_ptr 、 std::shared_ptr 和 std::weak_ptr 。智能指针在对象生命周期结束时自动释放其管理的资源。

C++11及之后版本的新特性介绍 C++11及其后续版本引入了许多新特性，包括lambda表达式、移动语义、范围for循环、自动类型推导（auto）、变参模板等。这些特性增强了C++的表达能力，使得编写更简洁、更安全的代码成为可能。例如，使用lambda表达式可以创建匿名函数对象：

auto lambda = [] (int x, int y) { return x + y; };
int result = lambda(3, 5); // 结果为8

随着C++的发展，新的特性和优化不断被加入，这使得C++成为了一个持续进化的语言，不断地为软件开发领域带来新的可能性。

4. Qt中的设计模式实现与应用

单例模式实现及在Qt中的应用

单例模式是软件开发中最常用的设计模式之一。它的主要思想是确保一个类只有一个实例，并提供一个全局访问点来获取这个实例。单例模式在Qt框架中的应用广泛，从配置管理器到日志记录器，再到应用程序级别的单个实例服务。通过其独特的实现方式，Qt利用元对象系统和信号与槽机制为单例模式提供了便捷的实现路径。

单例模式的原理和实现方法

单例模式的实现通常包含以下几个关键步骤：

构造函数私有化：防止外部通过new创建对象实例。
静态方法提供实例：通过一个静态方法返回类的唯一实例。
静态实例变量：在类内部持有一个静态指针变量，用以存储该类的唯一实例。
线程安全：确保在多线程环境下，单例的实例化是线程安全的。

在Qt中，这些步骤可以通过使用 Q_GLOBAL_STATIC 宏简化实现，该宏自动管理静态变量的创建和销毁，并提供了一个便捷的函数用于访问实例。

Qt中单例模式的实践案例

在Qt中实现单例模式，一个常用的方式是定义一个单例类，并使用 Q_GLOBAL_STATIC 宏，下面是一个简单的例子：

// Singleton.h

#ifndef SINGLETON_H
#define SINGLETON_H

class Singleton
{
    Q_OBJECT

public:
    static Singleton* getInstance();

signals:

public slots:

private:
    Singleton();
    ~Singleton();
    Q_DISABLE_COPY(Singleton)
};

#endif // SINGLETON_H

// Singleton.cpp

#include "Singleton.h"

Q_GLOBAL_STATIC(Singleton, singletonInstance)

Singleton* Singleton::getInstance()
{
    return singletonInstance();
}

Singleton::Singleton()
{
}

Singleton::~Singleton()
{
}

// Usage
Singleton* singleton = Singleton::getInstance();

在上面的代码中，通过 Q_GLOBAL_STATIC 宏，我们定义了一个全局可访问的单例类 Singleton 。用户只需要通过 getInstance 静态方法即可安全地访问 Singleton 的唯一实例。需要注意的是，虽然单例模式简化了实例的管理，但也可能带来代码测试和维护上的困难，特别是在大型项目中。

观察者模式实现及信号与槽机制

观察者模式是另一种在Qt框架中得到广泛应用的设计模式。它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会收到通知。

观察者模式的理论基础和实现技巧

观察者模式通常由以下几个主要部分组成：

Subject（主题） ：维护观察者列表，提供注册和移除观察者的方法，同时在状态改变时通知所有观察者。
Observer（观察者） ：提供一个更新接口，用于接收主题的更新通知。
ConcreteSubject（具体主题） ：具体主题类，状态改变时会调用 notify 方法。
ConcreteObserver（具体观察者） ：实现更新接口，响应具体主题的通知。

在Qt中，观察者模式与信号与槽机制紧密结合。信号可以看作是事件的发射点，槽则是接收信号并响应的函数。Qt的信号与槽机制是基于对象的元编程技术，能够动态地连接对象的信号到对应的槽函数。

信号与槽在Qt事件处理中的应用

在Qt中，定义一个信号和槽非常简单，下面是一个典型的例子：

// MyClass.h

#ifndef MYCLASS_H
#define MYCLASS_H

#include <QObject>

class MyClass : public QObject
{
    Q_OBJECT

public:
    explicit MyClass(QObject *parent = nullptr);

signals:
    void valueChanged(int newValue);

public slots:
    void updateValue(int newValue);
};

#endif // MYCLASS_H

// MyClass.cpp

#include "MyClass.h"

MyClass::MyClass(QObject *parent) : QObject(parent)
{
}

void MyClass::updateValue(int newValue)
{
    emit valueChanged(newValue);
}

// Usage
MyClass myClass;
QObject::connect(&myClass, &MyClass::valueChanged, [](int newValue){
    // Handle valueChanged signal
});

在这个例子中， MyClass 定义了一个 valueChanged 信号，并提供了一个 updateValue 槽函数。当 updateValue 函数被调用时，它会发射 valueChanged 信号。在使用端，我们使用 QObject::connect 函数连接信号和槽函数，当信号发射时，对应的槽函数会被调用。

观察者模式允许组件之间解耦，提高软件的可维护性和可扩展性。Qt的信号与槽机制进一步简化了观察者模式的实现，使其在事件处理和对象间通信方面变得异常强大。

工厂模式和抽象工厂模式在Qt中的实现

工厂模式是一种创建型设计模式，用于创建对象而不暴露创建逻辑给客户端，并且通过使用一个共同的接口来指向新创建的对象。在Qt中，工厂模式的应用也很广泛，尤其在需要解耦对象创建和对象使用时。

工厂模式的分类和应用场景

工厂模式主要有以下几种：

简单工厂模式 ：不遵循开闭原则，但它提供了一个创建对象的静态方法，根据输入参数决定创建哪种类型的产品。
工厂方法模式 ：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。
抽象工厂模式 ：提供一个接口用于创建相关或依赖对象的家族，而不需要明确指定具体类。

在Qt中，工厂方法模式和抽象工厂模式的应用可以看作是通过元对象系统和对象创建函数来实现的。

抽象工厂模式在Qt中的具体应用

抽象工厂模式在Qt中的一个实际应用是在界面组件的创建上。例如，使用Qt创建一个应用程序时，可以使用 QStyleFactory 来根据不同的平台或风格需求，获取对应的风格对象：

// Usage
QStyle *style = QStyleFactory::create("Fusion");

上述代码中， QStyleFactory::create 就是抽象工厂模式的一个具体实现。它根据传入的风格名称字符串（如"Fusion"）来创建相应的风格对象。这种方法允许应用程序在不修改代码的情况下，更换界面组件风格，实现了界面组件的灵活替换。

Qt框架借助其强大的元对象编译器（MOC）和信号与槽机制，对设计模式的实现和应用提供了极高的灵活性。无论是单例模式、观察者模式还是工厂模式，Qt都提供了符合其语言特性的独特实现方式，为开发者提供了一套高效、灵活的设计模式解决方案。

5. 设计模式在实际项目中的应用和好处

常用设计模式的具体实现

设计模式不仅仅是理论，它们在实际的软件开发项目中拥有广泛的应用。理解并熟练运用设计模式可以帮助开发者编写出更加清晰、灵活和可维护的代码。在本章节中，我们将探讨几种在实际项目中较为常见的设计模式，并通过代码示例展示其在Qt框架下的实现。

建造者模式

建造者模式是一种创建型设计模式，它允许你将一个复杂对象的构建与它的表示分离，这样同样的构建过程可以创建不同的表示。

示例代码：

class Product {
public:
    void addPart(const std::string& part) {
        // 添加部件到产品中
    }
};

class Builder {
protected:
    Product product;

public:
    virtual void buildPartA() = 0;
    virtual void buildPartB() = 0;

    Product getResult() {
        return product;
    }
};

class ConcreteBuilder : public Builder {
public:
    void buildPartA() override {
        product.addPart("Part A");
    }

    void buildPartB() override {
        product.addPart("Part B");
    }
};

int main() {
    ConcreteBuilder builder;
    builder.buildPartA();
    builder.buildPartB();
    Product product = builder.getResult();
    // 使用product对象
}

代理模式

代理模式为其他对象提供一种代理以控制对这个对象的访问。

示例代码：

class Subject {
public:
    virtual void request() = 0;
};

class RealSubject : public Subject {
public:
    void request() override {
        // 真实对象的实现
    }
};

class Proxy : public Subject {
private:
    RealSubject* realSubject;

public:
    void request() override {
        if (realSubject == nullptr) {
            realSubject = new RealSubject();
        }
        realSubject->request();
    }
};

模板方法模式

模板方法模式定义了一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

示例代码：

class AbstractClass {
public:
    void templateMethod() {
        primitiveOperation1();
        primitiveOperation2();
    }

protected:
    virtual void primitiveOperation1() = 0;
    virtual void primitiveOperation2() = 0;
};

class ConcreteClass : public AbstractClass {
protected:
    void primitiveOperation1() override {
        // 具体实现
    }
    void primitiveOperation2() override {
        // 具体实现
    }
};

在Qt框架中，代理模式和模板方法模式都有其特定的应用案例。例如，Qgraphicsproxywidget提供了一个图形场景中的widget的代理；而Qthread的run方法是一个模板方法，允许派生类实现自己的线程逻辑。