C++图形界面开发：画图工具项目实战

本文还有配套的精品资源，点击获取

简介：本文以C++为基础，详解如何开发一个功能完整的画图工具，适用于课程设计与毕业项目。内容涵盖计算机图形学基础、面向对象设计、图形绘制算法、GUI开发、鼠标事件处理、撤销重做机制、图形保存与加载等关键技术。通过实战项目，帮助开发者掌握图形应用程序的开发流程，提升编程能力和工程实践水平。

1. C++图形学基础概述

计算机图形学是研究如何在计算机中表示、处理和显示图形信息的学科，其核心内容涵盖几何建模、图像渲染、交互操作等多个方面。在图形程序开发中，点是最基本的几何元素，通常由二维或三维坐标表示；线由两个点定义，而面则由多个线段围成。像素作为屏幕显示的最小单位，构成了图形的最终呈现形式。C++以其高性能、面向对象特性以及对底层硬件的良好控制能力，成为图形开发的首选语言之一。通过结合图形库如Qt、OpenGL等，C++可以高效实现图形绘制、交互响应和复杂渲染逻辑，为后续章节中算法实现与系统构建打下坚实基础。

2. Bresenham直线绘制算法实现

Bresenham直线绘制算法是计算机图形学中最经典的算法之一，因其高效、无浮点运算的特性，被广泛应用于早期的图形系统以及嵌入式图形引擎中。本章将从算法的数学原理出发，逐步讲解其在C++中的实现方式，并探讨如何优化与扩展该算法，以支持不同方向和样式的直线绘制。

2.1 Bresenham算法的数学原理

Bresenham算法的核心思想是通过整数运算来决定在光栅显示器上如何以最接近的方式绘制直线。与传统的基于浮点运算的DDA（Digital Differential Analyzer）算法相比，Bresenham算法避免了浮点运算带来的性能损耗，非常适合硬件实现和嵌入式开发。

2.1.1 直线斜率与误差项的计算

在二维坐标系中，直线的绘制需要从起点 (x0, y0) 到终点 (x1, y1) 逐个像素点地逼近。Bresenham算法的基本思想是通过一个误差项来判断下一个像素点是向上还是水平方向偏移。

数学模型分析

设直线的斜率为 m = (y1 - y0) / (x1 - x0) ，我们以 m ∈ [0, 1] 为例进行分析，即直线从左下向右上缓坡方向延伸。

假设当前像素点为 (x, y) ，那么下一个像素点可能是 (x+1, y) 或 (x+1, y+1) 。我们通过误差项 d 来判断哪一个更接近真实直线。

• 初始误差项为： d = 2Δy - Δx （其中 Δy = y1 - y0，Δx = x1 - x0）
• 每次 x 增加 1，d 更新为：
• 如果 d < 0，则 y 不变，d += 2Δy
• 如果 d ≥ 0，则 y 增加 1，d += 2(Δy - Δx)

这种方式避免了浮点数的使用，仅使用整数运算即可实现直线的绘制。

误差项更新逻辑示意图

使用 Mermaid 流程图展示误差项的判断逻辑如下：

graph TD
    A[初始化参数 Δx, Δy, d = 2Δy - Δx] --> B{判断 d < 0 ?}
    B -- 是 --> C[保持 y 值不变]
    C --> D[绘制 (x+1, y)]
    D --> E[d += 2Δy]
    B -- 否 --> F[y += 1]
    F --> G[绘制 (x+1, y+1)]
    G --> H[d += 2(Δy - Δx)]
    H --> I[x += 1]
    I --> J{是否到达终点?}
    J -- 否 --> B
    J -- 是 --> K[绘制完成]

2.1.2 整数运算的优势与实现逻辑

Bresenham算法的一个重要特性是 完全使用整数运算 ，这在早期计算机系统中极大地提高了性能。以下是其主要优势：

优势	描述
高效性	使用位移和加法代替乘法和除法
精确性	避免浮点精度问题
可移植性	易于在不同硬件平台上实现

为了实现整数运算，我们对误差项的更新进行了优化，将其转换为仅包含加减法和位移操作的形式：

• d += 2 * Δy 等价于 d += dy2
• d += 2 * (Δy - Δx) 等价于 d += dydx

其中 dy2 = 2 * Δy , dxdy = 2 * (Δy - Δx)

2.2 算法在C++中的编码实现

在掌握了Bresenham算法的数学原理之后，我们可以在C++中对其进行实现。本节将讲解如何将算法封装为函数，并设计合理的参数结构，同时介绍如何在绘图区域内绘制像素点。

2.2.1 函数封装与参数设计

为了实现一个通用的Bresenham直线绘制函数，我们需要设计如下参数：

• x0 , y0 ：起始点坐标
• x1 , y1 ：终止点坐标
• drawPixel(x, y) ：绘制像素点的回调函数

该函数的定义如下：

void drawLineBresenham(int x0, int y0, int x1, int y1, std::function<void(int, int)> drawPixel) {
    int dx = abs(x1 - x0);
    int dy = abs(y1 - y0);
    int sx = (x0 < x1) ? 1 : -1;
    int sy = (y0 < y1) ? 1 : -1;
    int err = dx - dy;

    while (true) {
        drawPixel(x0, y0);
        if (x0 == x1 && y0 == y1) break;
        int e2 = 2 * err;
        if (e2 > -dy) {
            err -= dy;
            x0 += sx;
        }
        if (e2 < dx) {
            err += dx;
            y0 += sy;
        }
    }
}

代码逐行解析：

• 第1行 ：定义函数，接受起点、终点和绘图回调。
• 第2~3行 ：计算横向和纵向距离，以及方向因子 sx , sy 。
• 第4行 ：初始化误差项 err = dx - dy 。
• 第6行 ：进入循环绘制点。
• 第7行 ：调用回调函数绘制当前点。
• 第8~9行 ：判断是否到达终点，若到达则跳出循环。
• 第10行 ：计算误差的两倍值。
• 第11~13行 ：判断是否向 x 方向移动。
• 第14~16行 ：判断是否向 y 方向移动。

参数说明：

• x0 , y0 , x1 , y1 ：直线的起止坐标。
• drawPixel ：一个接受 (int, int) 并无返回值的函数对象，用于绘制单个像素点。

2.2.2 绘图区域的初始化与像素点绘制

在实际应用中，我们需要一个绘图区域（如图像缓冲区）来存储绘制结果。以下是一个简单的绘图区域类 Canvas 的实现：

class Canvas {
public:
    Canvas(int width, int height) : width(width), height(height) {
        buffer = new bool*[height];
        for (int i = 0; i < height; ++i) {
            buffer[i] = new bool[width]{0};
        }
    }

    ~Canvas() {
        for (int i = 0; i < height; ++i) {
            delete[] buffer[i];
        }
        delete[] buffer;
    }

    void drawPixel(int x, int y) {
        if (x >= 0 && x < width && y >= 0 && y < height) {
            buffer[y][x] = true;
        }
    }

    void print() {
        for (int y = 0; y < height; ++y) {
            for (int x = 0; x < width; ++x) {
                std::cout << (buffer[y][x] ? '#' : '.');
            }
            std::cout << std::endl;
        }
    }

private:
    int width, height;
    bool** buffer;
};

使用示例：

int main() {
    Canvas canvas(20, 10);
    drawLineBresenham(2, 2, 15, 7, [&](int x, int y) {
        canvas.drawPixel(x, y);
    });
    canvas.print();
    return 0;
}

输出结果示例：

..#.................
...##...............
.....##.............
.......##...........
.........##.........
...........##.......
.............##.....

2.3 算法优化与扩展

虽然Bresenham算法本身已经非常高效，但在实际图形系统中，我们还需要支持不同方向的直线绘制以及多种线型（如虚线、点线等）。本节将介绍如何对算法进行优化与扩展。

2.3.1 支持任意方向的直线绘制

原生的Bresenham算法默认处理的是斜率为 0 ≤ m ≤ 1 的直线。为了支持任意方向的直线，我们需要对算法进行适配：

• 斜率大于1的情况 ：交换x和y的角色，以y为主方向进行迭代。
• 负斜率的情况 ：通过符号控制方向。

改进后的函数如下：

void drawLineGeneral(int x0, int y0, int x1, int y1, std::function<void(int, int)> drawPixel) {
    int dx = abs(x1 - x0), dy = abs(y1 - y0);
    int sx = x0 < x1 ? 1 : -1;
    int sy = y0 < y1 ? 1 : -1;
    bool isSteep = dy > dx;

    if (isSteep) {
        std::swap(dx, dy);
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    int err = dx - dy;
    while (true) {
        if (isSteep) drawPixel(y0, x0); else drawPixel(x0, y0);
        if (x0 == x1 && y0 == y1) break;
        int e2 = 2 * err;
        if (e2 > -dy) { err -= dy; x0 += sx; }
        if (e2 < dx) { err += dx; y0 += sy; }
    }
}

优化逻辑分析：

• 第6~9行 ：如果斜率大于1，则交换x、y，并标记 isSteep 。
• 第15行 ：根据 isSteep 决定是否交换x、y绘制点。

2.3.2 多种线型（虚线、点线）的实现

要实现虚线或点线，可以在绘制过程中添加一个步长控制变量，根据线型决定是否绘制当前像素点。

例如，实现一个简单的虚线模式：

enum LineStyle { SOLID, DASHED, DOTTED };

void drawLineWithStyle(int x0, int y0, int x1, int y1, LineStyle style, std::function<void(int, int)> drawPixel) {
    int dx = abs(x1 - x0), dy = abs(y1 - y0);
    int sx = x0 < x1 ? 1 : -1;
    int sy = y0 < y1 ? 1 : -1;
    bool isSteep = dy > dx;

    if (isSteep) {
        std::swap(dx, dy);
        std::swap(x0, y0);
        std::swap(x1, y1);
    }

    int err = dx - dy;
    int step = 0;

    while (true) {
        bool draw = true;
        switch (style) {
            case DASHED: draw = (step / 4) % 2 == 0; break;
            case DOTTED: draw = step % 4 == 0; break;
            default: break;
        }

        if (draw) {
            if (isSteep) drawPixel(y0, x0); else drawPixel(x0, y0);
        }

        if (x0 == x1 && y0 == y1) break;
        int e2 = 2 * err;
        if (e2 > -dy) { err -= dy; x0 += sx; }
        if (e2 < dx) { err += dx; y0 += sy; }
        step++;
    }
}

线型对照表：

线型	参数	描述
实线	SOLID	每个像素都绘制
虚线	DASHED	每4个像素绘制前两个
点线	DOTTED	每4个像素绘制第一个

使用示例：

Canvas canvas(20, 10);
drawLineWithStyle(2, 2, 15, 7, DASHED, [&](int x, int y) {
    canvas.drawPixel(x, y);
});
canvas.print();

输出示例（虚线）：

..#...............#.
...##...............
.....##.............
.......##...........
.........##.........
...........##.......
.............##.....

本章通过从Bresenham算法的数学原理入手，逐步讲解了其在C++中的实现方式，并展示了如何优化算法以支持任意方向和多种线型。这些内容为后续章节中图形类的封装与交互设计打下了坚实基础。

3. 图形对象模型设计与面向对象实现

3.1 图形对象的抽象建模

3.1.1 基类设计与继承结构

在图形系统开发中，为了实现统一的管理和扩展性，通常会采用面向对象的建模方式。图形对象（如点、线、矩形、圆形等）都具有坐标、颜色、线宽等共性属性，同时也具备渲染（绘制）和交互（点击、拖动等）行为。因此，我们可以定义一个抽象的基类 GraphicObject ，作为所有图形类的父类。

// GraphicObject.h
#ifndef GRAPHICOBJECT_H
#define GRAPHICOBJECT_H

#include <QColor>
#include <QPoint>

class GraphicObject {
public:
    virtual ~GraphicObject() = default;

    virtual void draw() = 0;        // 纯虚函数：绘制
    virtual bool isHit(const QPoint& point) = 0; // 纯虚函数：碰撞检测

    void setColor(const QColor& color) { m_color = color; }
    QColor getColor() const { return m_color; }

    void setLineWidth(int width) { m_lineWidth = width; }
    int getLineWidth() const { return m_lineWidth; }

protected:
    QColor m_color;
    int m_lineWidth;
};

#endif // GRAPHICOBJECT_H

代码逻辑解读：

• GraphicObject 是一个抽象基类，包含两个纯虚函数 draw() 和 isHit() ，分别用于绘制和交互检测。
• 提供了颜色和线宽的公共属性管理接口，子类可以直接继承使用。
• 使用了 QColor 和 QPoint 来处理颜色和坐标，适用于 Qt 平台下的图形开发。

3.1.2 接口定义与虚函数机制

面向对象设计中，接口的定义是实现多态的关键。通过定义统一的接口方法，我们可以实现不同图形对象的统一调用方式。

// Line.h
#ifndef LINE_H
#define LINE_H

#include "GraphicObject.h"
#include <QPoint>

class Line : public GraphicObject {
public:
    Line(const QPoint& start, const QPoint& end);

    void draw() override;           // 实现绘制逻辑
    bool isHit(const QPoint& point) override; // 实现点击检测

private:
    QPoint m_start;
    QPoint m_end;
};

#endif // LINE_H

代码逻辑解读：

• Line 类继承自 GraphicObject ，并实现了 draw() 和 isHit() 方法。
• 所有子类都必须实现这两个方法，以满足统一的接口需求。
• 这种机制允许我们将多个图形对象存储在一个容器中，并通过统一的接口进行操作。

3.1.3 继承结构示意图

使用 Mermaid 绘制类继承关系图：

classDiagram
    class GraphicObject {
        <<abstract>>
        +virtual void draw() = 0
        +virtual bool isHit(QPoint) = 0
        +void setColor(QColor)
        +QColor getColor()
    }
    class Line {
        +Line(QPoint, QPoint)
        +void draw()
        +bool isHit(QPoint)
    }
    class Rectangle {
        +Rectangle(QPoint, QPoint)
        +void draw()
        +bool isHit(QPoint)
    }
    class Circle {
        +Circle(QPoint, int)
        +void draw()
        +bool isHit(QPoint)
    }

    GraphicObject <|-- Line
    GraphicObject <|-- Rectangle
    GraphicObject <|-- Circle

图示说明：

• GraphicObject 是抽象基类，不能直接实例化。
• Line 、 Rectangle 、 Circle 是具体图形类，继承并实现基类接口。
• 此结构允许我们以统一方式管理所有图形对象。

3.2 图形对象的属性与行为封装

3.2.1 坐标、颜色、线宽等属性管理

封装是面向对象设计的核心原则之一。将图形对象的属性与行为封装在类内部，有助于提高代码的可维护性和安全性。

以 Line 类为例，其属性包括起点、终点、颜色和线宽：

// Line.cpp
#include "Line.h"
#include <QPainter>

Line::Line(const QPoint& start, const QPoint& end)
    : m_start(start), m_end(end) {
    setColor(Qt::black);
    setLineWidth(1);
}

void Line::draw() {
    QPainter painter; // 假设已初始化设备
    QPen pen(getColor(), getLineWidth());
    painter.setPen(pen);
    painter.drawLine(m_start, m_end);
}

代码逻辑解读：

• 构造函数设置默认颜色为黑色，线宽为1。
• draw() 方法使用 Qt 的 QPainter 类进行绘制。
• 所有属性通过封装的接口访问，如 getColor() 、 getLineWidth() 。

3.2.2 渲染与交互行为的封装

除了属性管理，图形对象的行为也需要封装。例如，点击检测逻辑应封装在类内部，由外部统一调用：

bool Line::isHit(const QPoint& point) {
    // 简化版：计算点到线段的距离是否小于阈值
    double distance = calculateDistance(point);
    return distance < 5; // 假设点击容差为5像素
}

double Line::calculateDistance(const QPoint& point) {
    // 计算点到线段的距离公式
    // 简化实现，实际应使用向量投影法
    return 0.0;
}

代码逻辑解读：

• isHit() 方法调用私有函数 calculateDistance() 实现点击检测。
• 点击容差为5像素，保证用户操作的容错性。
• 该方法封装了复杂的几何计算，对外仅暴露一个布尔判断。

3.2.3 属性与行为封装对比表

属性/行为	封装方式	说明
坐标	私有成员变量	通过构造函数初始化
颜色	封装 getter/setter	提供统一接口，避免直接访问
线宽	封装 getter/setter	同上
渲染行为	虚函数重写	统一调用，不同实现
交互行为	虚函数重写	点击检测，封装几何计算

3.3 面向对象设计在图形系统中的应用优势

3.3.1 可扩展性与可维护性分析

采用面向对象设计后，图形系统的可扩展性大大增强。例如，若需新增一个图形类型，如 Ellipse ，只需继承基类并实现相应方法，无需修改已有代码。

class Ellipse : public GraphicObject {
public:
    Ellipse(const QPoint& center, int rx, int ry);

    void draw() override;
    bool isHit(const QPoint& point) override;

private:
    QPoint m_center;
    int m_rx, m_ry;
};

优势分析：

• 开闭原则 ：对扩展开放，对修改关闭。
• 低耦合性 ：新增图形不影响已有图形逻辑。
• 可维护性 ：每个图形类职责单一，便于调试与维护。

3.3.2 示例：新增多边形类的设计与实现

假设我们要新增一个 Polygon 类，支持绘制任意多边形：

class Polygon : public GraphicObject {
public:
    Polygon(const std::vector<QPoint>& points);

    void draw() override;
    bool isHit(const QPoint& point) override;

private:
    std::vector<QPoint> m_points;
};

void Polygon::draw() {
    QPainter painter;
    QPen pen(getColor(), getLineWidth());
    painter.setPen(pen);
    painter.drawPolygon(m_points.data(), m_points.size());
}

实现说明：

• m_points 存储多边形顶点坐标。
• 使用 Qt 的 drawPolygon 函数进行绘制。
• isHit() 可通过射线法判断点是否在多边形内。

3.3.3 面向对象设计的优势总结表

设计特性	说明
可扩展性	新增图形只需继承并实现接口方法
可维护性	每个图形类独立，便于调试与维护
多态性	统一接口调用，支持多种图形类型
代码复用	公共属性与方法可在基类中统一定义
降低耦合	各类之间依赖接口，不依赖具体实现

通过本章节的设计与实现，我们构建了一个结构清晰、易于扩展的图形对象模型系统。下一章节将继续深入，介绍如何对具体图形类（如点、线、矩形、圆形）进行封装与管理。

4. 点、线、矩形、圆形等图形类封装

在图形学与图形用户界面开发中，图形对象的抽象建模是系统设计的重要基础。本章将围绕点、线、矩形、圆形等基本图形对象，构建面向对象的封装模型。通过类的继承、封装与多态机制，实现图形对象的统一管理与绘制，为后续图形交互、事件处理及图形系统扩展提供良好的基础结构。

4.1 基本图形类的定义

4.1.1 点类的设计与实现

在图形系统中， 点（Point） 是最基本的几何元素，通常由二维坐标（x, y）表示。为了便于管理和操作，我们将其封装为一个C++类。

// Point.h
#pragma once

class Point {
public:
    int x;
    int y;

    Point();
    Point(int x, int y);

    void set(int x, int y);
    void move(int dx, int dy);
    void print() const;
};

// Point.cpp
#include <iostream>
#include "Point.h"

Point::Point() : x(0), y(0) {}

Point::Point(int x, int y) : x(x), y(y) {}

void Point::set(int x, int y) {
    this->x = x;
    this->y = y;
}

void Point::move(int dx, int dy) {
    x += dx;
    y += dy;
}

void Point::print() const {
    std::cout << "Point(" << x << ", " << y << ")" << std::endl;
}

代码分析：

• 构造函数 ：默认构造函数将点初始化为原点(0, 0)，带参构造函数允许自定义坐标。
• set方法 ：用于设置坐标值。
• move方法 ：实现点的移动操作。
• print方法 ：输出点的坐标信息，便于调试和可视化验证。

此类封装了点的基本属性和操作，后续图形类（如线段、矩形）可基于此进行扩展。

4.1.2 线段类的构造与绘制方法

线段由两个端点组成，我们通过组合两个 Point 对象来表示线段。同时，线段类应提供绘制接口，便于图形系统调用。

// Line.h
#pragma once
#include "Point.h"

class Line {
private:
    Point start;
    Point end;

public:
    Line();
    Line(const Point& start, const Point& end);

    void setStart(const Point& start);
    void setEnd(const Point& end);
    void draw() const;
};

// Line.cpp
#include <iostream>
#include "Line.h"

Line::Line() : start(), end() {}

Line::Line(const Point& start, const Point& end) : start(start), end(end) {}

void Line::setStart(const Point& start) {
    this->start = start;
}

void Line::setEnd(const Point& end) {
    this->end = end;
}

void Line::draw() const {
    std::cout << "Drawing Line from ";
    start.print();
    std::cout << " to ";
    end.print();
}

代码分析：

• 成员变量 ： start 和 end 表示线段的两个端点。
• draw方法 ：模拟线段的绘制行为，后续可替换为调用图形API（如QPainter）进行真实绘制。
• 封装设计 ：通过setter方法控制线段的起始与终点，实现数据封装与行为统一。

线段类的扩展性

线段类可以进一步扩展，例如：

• 添加颜色、线宽等属性；
• 支持Bresenham算法进行像素级绘制；
• 实现线段的碰撞检测（如与矩形、圆的交点判断）。

4.2 矩形与圆形类的封装

4.2.1 矩形类的边界检测与绘制

矩形是一个由左上角坐标和宽高定义的图形对象。我们通过封装其属性和绘制逻辑，构建一个通用的矩形类。

// Rectangle.h
#pragma once
#include "Point.h"

class Rectangle {
private:
    Point topLeft;
    int width;
    int height;

public:
    Rectangle();
    Rectangle(const Point& topLeft, int width, int height);

    void setTopLeft(const Point& topLeft);
    void setWidth(int width);
    void setHeight(int height);

    Point getBottomRight() const;
    bool contains(const Point& point) const;
    void draw() const;
};

// Rectangle.cpp
#include <iostream>
#include "Rectangle.h"

Rectangle::Rectangle() : topLeft(), width(0), height(0) {}

Rectangle::Rectangle(const Point& topLeft, int width, int height)
    : topLeft(topLeft), width(width), height(height) {}

void Rectangle::setTopLeft(const Point& topLeft) {
    this->topLeft = topLeft;
}

void Rectangle::setWidth(int width) {
    this->width = width;
}

void Rectangle::setHeight(int height) {
    this->height = height;
}

Point Rectangle::getBottomRight() const {
    return Point(topLeft.x + width, topLeft.y + height);
}

bool Rectangle::contains(const Point& point) const {
    return (point.x >= topLeft.x &&
            point.x <= topLeft.x + width &&
            point.y >= topLeft.y &&
            point.y <= topLeft.y + height);
}

void Rectangle::draw() const {
    std::cout << "Drawing Rectangle at ";
    topLeft.print();
    std::cout << "Width: " << width << ", Height: " << height << std::endl;
}

代码分析：

• getBottomRight方法 ：计算矩形右下角坐标，便于绘制和碰撞检测。
• contains方法 ：实现点是否在矩形内的检测，常用于图形交互操作。
• draw方法 ：模拟矩形绘制，后续可集成图形库进行真实绘制。

矩形类的应用示例：

int main() {
    Point p1(10, 20);
    Rectangle rect(p1, 100, 50);
    Point test(30, 30);

    if (rect.contains(test)) {
        std::cout << "Point is inside the rectangle." << std::endl;
    } else {
        std::cout << "Point is outside the rectangle." << std::endl;
    }

    rect.draw();
    return 0;
}

4.2.2 圆形类的Bresenham算法实现

圆形类通常由圆心和半径定义。绘制圆形时，可采用 Bresenham圆算法 ，该算法通过判断误差项来选择下一个像素点，避免浮点运算，提高效率。

// Circle.h
#pragma once
#include "Point.h"

class Circle {
private:
    Point center;
    int radius;

public:
    Circle();
    Circle(const Point& center, int radius);

    void setCenter(const Point& center);
    void setRadius(int radius);

    void drawCircle() const;
};

// Circle.cpp
#include <iostream>
#include <vector>
#include "Circle.h"

Circle::Circle() : center(), radius(0) {}

Circle::Circle(const Point& center, int radius)
    : center(center), radius(radius) {}

void Circle::setCenter(const Point& center) {
    this->center = center;
}

void Circle::setRadius(int radius) {
    this->radius = radius;
}

void Circle::drawCircle() const {
    int x = 0;
    int y = radius;
    int d = 3 - 2 * radius;

    std::vector<std::pair<int, int>> points;

    while (x <= y) {
        // 将8个对称点加入容器
        points.emplace_back(center.x + x, center.y + y);
        points.emplace_back(center.x - x, center.y + y);
        points.emplace_back(center.x + x, center.y - y);
        points.emplace_back(center.x - x, center.y - y);
        points.emplace_back(center.x + y, center.y + x);
        points.emplace_back(center.x - y, center.y + x);
        points.emplace_back(center.x + y, center.y - x);
        points.emplace_back(center.x - y, center.y - x);

        if (d < 0) {
            d += 4 * x + 6;
        } else {
            d += 4 * (x - y) + 10;
            y--;
        }
        x++;
    }

    // 输出所有绘制点
    for (const auto& pt : points) {
        std::cout << "Plotting point: (" << pt.first << ", " << pt.second << ")" << std::endl;
    }
}

代码分析：

• Bresenham算法 ：通过误差项 d 来决定下一个点的绘制位置，避免浮点运算。
• 对称绘制 ：利用圆的对称性，一次计算8个对称点，提升效率。
• drawCircle方法 ：模拟绘制圆形，后续可替换为图形API调用。

绘制流程图（mermaid）：

graph TD
    A[初始化圆心和半径] --> B[设置初始误差项d]
    B --> C[绘制初始点]
    C --> D{d < 0?}
    D -- 是 --> E[d += 4x + 6]
    D -- 否 --> F[d += 4(x - y) + 10, y--]
    E --> G[x++]
    F --> G
    G --> H{是否x <= y?}
    H -- 是 --> C
    H -- 否 --> I[绘制结束]

4.3 图形类集合的统一管理

4.3.1 使用容器存储图形对象

为了统一管理多种图形对象（点、线、矩形、圆形等），我们可以使用C++标准库的容器类（如 std::vector ），并结合多态机制实现统一接口调用。

// Shape.h
#pragma once
#include "Point.h"

class Shape {
public:
    virtual void draw() const = 0;  // 纯虚函数，定义绘制接口
    virtual ~Shape() = default;
};

// PointShape.h
#pragma once
#include "Point.h"
#include "Shape.h"

class PointShape : public Shape {
private:
    Point point;
public:
    PointShape(const Point& point);
    void draw() const override;
};

// LineShape.h
#pragma once
#include "Line.h"
#include "Shape.h"

class LineShape : public Shape {
private:
    Line line;
public:
    LineShape(const Line& line);
    void draw() const override;
};

// ShapeManager.h
#pragma once
#include <vector>
#include "Shape.h"

class ShapeManager {
private:
    std::vector<Shape*> shapes;

public:
    void addShape(Shape* shape);
    void drawAll() const;
    ~ShapeManager();
};

// ShapeManager.cpp
#include "ShapeManager.h"

void ShapeManager::addShape(Shape* shape) {
    shapes.push_back(shape);
}

void ShapeManager::drawAll() const {
    for (const auto& shape : shapes) {
        shape->draw();
    }
}

ShapeManager::~ShapeManager() {
    for (auto shape : shapes) {
        delete shape;
    }
}

代码分析：

• Shape基类 ：定义统一的绘制接口 draw() ，所有图形类继承并实现该接口。
• ShapeManager类 ：管理所有图形对象，提供统一的添加和绘制接口。
• 内存管理 ：析构函数中释放所有动态分配的对象，避免内存泄漏。

4.3.2 对象的动态绘制与更新机制

为了支持图形的动态更新（如拖动、缩放），我们可以在图形类中添加更新接口，并在 ShapeManager 中实现更新逻辑。

// Shape.h 扩展
virtual void update(int dx, int dy);  // 虚函数，支持平移

// PointShape.cpp
void PointShape::update(int dx, int dy) {
    point.move(dx, dy);
}

// LineShape.cpp
void LineShape::update(int dx, int dy) {
    line.setStart(Point(line.getStart().x + dx, line.getStart().y + dy));
    line.setEnd(Point(line.getEnd().x + dx, line.getEnd().y + dy));
}

动态更新流程图（mermaid）：

graph TD
    A[用户输入事件] --> B[获取偏移量dx, dy]
    B --> C[调用ShapeManager::updateAll(dx, dy)]
    C --> D[遍历每个Shape对象]
    D --> E[调用Shape::update(dx, dy)]
    E --> F[具体图形类实现更新逻辑]
    F --> G[更新坐标]
    G --> H[触发重绘]

表格：图形类管理机制对比

功能	点类	线段类	矩形类	圆形类
绘制功能	✅	✅	✅	✅
更新功能（移动）	✅	✅	✅	✅
碰撞检测	❌	❌	✅	✅
多态支持	✅	✅	✅	✅

通过统一的图形类封装与管理机制，我们可以实现图形系统的模块化设计，提升代码的可扩展性与维护性，为后续图形交互与事件处理打下坚实基础。

5. QPainter绘图核心API使用

Qt 提供了强大的绘图框架，其中 QPainter 是 Qt 中用于进行 2D 绘图的核心类，它支持多种图形绘制操作，包括线条、形状、文本、图像等。在 C++ 开发中，掌握 QPainter 的核心 API 是实现图形界面绘制功能的关键。本章将深入讲解 QPainter 的基本使用方法，包括画笔、画刷、颜色设置等核心 API 的应用，并通过具体代码示例展示如何在 Qt 环境下进行高效绘图。

5.1 QPainter 类基础概念

5.1.1 QPainter 的基本作用

QPainter 类是 Qt 图形系统中的核心绘图类，它允许开发者在窗口、图像、打印设备等多种绘图设备上进行 2D 图形绘制。其主要功能包括：

• 绘制基本图形（点、线、矩形、圆形等）
• 设置画笔（QPen）和画刷（QBrush）样式
• 填充颜色和纹理
• 文字绘制
• 图像绘制与变换

5.1.2 QPainter 的绘图设备支持

Qt 中的 QPainter 可以在以下设备上进行绘制：

绘图设备类型	描述
QWidget	窗口控件，用于界面绘图
QPixmap	内存图像，用于离屏绘制
QImage	图像数据操作，支持像素级访问
QPrinter	打印输出
QSvgGenerator	生成 SVG 矢量图
QOpenGLWidget	OpenGL 渲染上下文

5.1.3 QPainter 的生命周期管理

在 Qt 中使用 QPainter 时，必须遵循其生命周期规则。通常情况下，绘图操作应在 paintEvent() 事件中完成，且 QPainter 实例应在其作用域内创建和销毁，避免在类成员中直接保存。

void MyWidget::paintEvent(QPaintEvent *event) {
    QPainter painter(this);
    painter.setPen(Qt::blue);
    painter.drawLine(0, 0, 100, 100);
}

代码说明：

• QPainter painter(this); ：构造函数传入当前控件指针，表示在该控件上绘制。
• painter.setPen(Qt::blue); ：设置画笔颜色为蓝色。
• painter.drawLine(0, 0, 100, 100); ：绘制从 (0, 0) 到 (100, 100) 的直线。

5.2 QPainter 核心 API 使用详解

5.2.1 画笔（QPen）设置

QPen 类用于定义线条的样式、宽度、颜色等属性。通过 QPainter::setPen() 方法设置当前画笔。

常用设置方法：

方法名	描述
setStyle()	设置线条样式（如 SolidLine、DashLine）
setWidth()	设置线条宽度
setColor()	设置线条颜色
setCapStyle()	设置线段端点样式
setJoinStyle()	设置线段连接样式

示例代码：

QPen pen;
pen.setColor(Qt::red);
pen.setWidth(3);
pen.setStyle(Qt::DashLine);
pen.setCapStyle(Qt::RoundCap);
pen.setJoinStyle(Qt::RoundJoin);

QPainter painter(this);
painter.setPen(pen);
painter.drawLine(50, 50, 150, 150);

逐行解读：

• 定义 QPen 对象并设置颜色为红色，宽度为 3 像素。
• 线条样式设置为虚线，端点和连接处设置为圆角。
• 在控件上绘制从 (50, 50) 到 (150, 150) 的红色虚线。

5.2.2 画刷（QBrush）设置

QBrush 类用于定义图形的填充样式，可以是纯色、渐变色、纹理等。通过 QPainter::setBrush() 方法设置当前画刷。

常用设置方法：

方法名	描述
setColor()	设置画刷颜色
setStyle()	设置填充样式（如 SolidPattern、Dense1Pattern）
setTexture()	设置纹理图像

示例代码：

QBrush brush(Qt::green, Qt::Dense2Pattern);
QPainter painter(this);
painter.setBrush(brush);
painter.drawRect(100, 100, 100, 100);

逻辑分析：

• 创建一个绿色的画刷，填充样式为密集点阵。
• 绘制一个从 (100, 100) 开始，宽高各为 100 像素的矩形，并使用绿色点阵填充。

5.2.3 颜色设置与调色板

Qt 支持多种颜色表示方式，包括 RGB、HSV、CMYK 等。常用类为 QColor ，支持多种颜色构造方式。

示例代码：

QColor color(255, 0, 0, 128); // RGBA 红色，半透明
QPainter painter(this);
painter.setPen(color);
painter.drawLine(0, 0, 200, 200);

参数说明：

• 构造 RGBA 颜色，红色值为 255，绿色和蓝色为 0，透明度为 128（半透明）。
• 设置为当前画笔颜色并绘制一条红色半透明的斜线。

5.3 QPainter 图形绘制功能实践

5.3.1 绘制基本图形

QPainter 提供了一系列绘制基本图形的方法，包括：

方法名	描述
drawLine()	绘制直线
drawRect()	绘制矩形
drawEllipse()	绘制椭圆
drawPolygon()	绘制多边形
drawText()	绘制文本

示例：绘制矩形和椭圆

QPainter painter(this);
painter.setPen(Qt::black);
painter.drawRect(50, 50, 100, 100);
painter.drawEllipse(50, 50, 100, 100);

逻辑说明：

• 设置画笔为黑色。
• 绘制一个矩形和一个内切于矩形的椭圆。

5.3.2 绘制文本与字体设置

通过 QFont 设置字体样式，并使用 QPainter::drawText() 方法绘制文本。

QFont font("Arial", 16, QFont::Bold);
QPainter painter(this);
painter.setFont(font);
painter.setPen(Qt::darkBlue);
painter.drawText(100, 100, "Hello Qt Graphics!");

参数说明：

• 设置字体为 Arial，字号 16，加粗。
• 设置画笔颜色为深蓝色。
• 在坐标 (100, 100) 处绘制文本。

5.3.3 图像绘制与变换

QPainter 还支持图像绘制和变换操作，如平移、旋转、缩放等。

示例代码：

QPixmap pixmap(":/images/logo.png");
QPainter painter(this);
painter.translate(100, 100); // 平移
painter.rotate(45);          // 旋转 45 度
painter.scale(1.5, 1.5);     // 缩放 1.5 倍
painter.drawPixmap(0, 0, pixmap);

逻辑说明：

• 加载图像资源。
• 设置变换：平移至 (100, 100)，旋转 45 度，缩放 1.5 倍。
• 在原点绘制图像。

5.4 QPainter 的状态管理与性能优化

5.4.1 状态保存与恢复

在绘制过程中，可能需要临时更改画笔、画刷等状态，使用 QPainter::save() 和 QPainter::restore() 方法可以保存和恢复当前绘图状态。

QPainter painter(this);
painter.save();
painter.setPen(Qt::red);
painter.drawLine(0, 0, 100, 100);
painter.restore();
painter.drawLine(0, 100, 100, 0);

逻辑分析：

• 保存当前绘图状态。
• 设置红色画笔绘制一条斜线。
• 恢复原状态，继续绘制另一条默认颜色的斜线。

5.4.2 绘图性能优化技巧

为了提高绘图性能，可以采用以下策略：

优化方式	描述
合并绘制操作	将多个小图形合并成一次绘制
使用双缓冲绘图	避免闪烁，提高视觉效果
减少重绘区域	仅绘制发生变化的部分
避免频繁创建对象	如 QPen、QBrush 等应复用或提前构造

示例：使用 QPixmap 进行双缓冲绘图

QPixmap buffer(size());
QPainter p(&buffer);
p.fillRect(rect(), Qt::white);
p.drawLine(...); // 多个绘图操作
p.end();

QPainter mainPainter(this);
mainPainter.drawPixmap(0, 0, buffer);

逻辑说明：

• 在内存图像 QPixmap 上进行绘图，避免频繁刷新界面。
• 最后将内存图像一次性绘制到界面上，提升流畅度。

5.5 QPainter 的实际应用场景

5.5.1 自定义控件绘制

通过重写 paintEvent() 方法，可以在自定义控件中实现复杂的图形效果，如进度条、仪表盘、图表等。

5.5.2 动画与实时渲染

结合 Qt 的定时器机制，可以实现基于 QPainter 的动画效果，例如旋转的加载图标、动态图表等。

5.5.3 图形编辑器开发

在图形编辑器中， QPainter 可用于绘制图形对象、实现选择、移动、缩放等交互功能，结合鼠标事件监听实现完整的交互逻辑。

5.6 小结

本章系统讲解了 Qt 中 QPainter 的核心 API 使用方法，包括画笔、画刷、颜色、字体、图像绘制等关键功能，并通过具体代码示例演示了其在 C++ 图形开发中的实际应用。此外，还介绍了状态管理与性能优化技巧，为后续章节中的图形交互功能开发打下了坚实基础。

后续章节提示： 第六章将围绕鼠标事件监听机制展开，详细介绍如何实现图形的交互操作，如拖动绘制、动态渲染等功能。

6. 鼠标事件监听与图形交互操作

鼠标作为图形界面中最直接的交互设备，其事件处理机制在图形应用开发中占据核心地位。C++结合Qt框架提供了完善的鼠标事件处理体系，使得开发者能够灵活地捕捉用户的点击、拖动、释放等行为，并将其映射到图形对象的交互逻辑中。

本章将围绕Qt平台下鼠标事件的基础处理机制展开，逐步深入图形交互操作的实现，包括拖动绘制、动态预览、多对象切换等高级交互功能，并在最后探讨如何优化事件处理逻辑，集成键盘辅助操作，提升图形系统的响应效率与用户体验。

6.1 鼠标事件的基础处理

Qt 提供了丰富的事件类与虚函数，开发者可通过继承 QWidget 或其他绘图组件，并重写 mousePressEvent() 、 mouseMoveEvent() 和 mouseReleaseEvent() 等函数来实现对鼠标行为的监听与响应。

6.1.1 鼠标点击、移动、释放事件的捕获

在 Qt 中，鼠标事件的捕获主要通过重写以下三个虚函数实现：

• void mousePressEvent(QMouseEvent *event) ：当鼠标按键被按下时触发。
• void mouseMoveEvent(QMouseEvent *event) ：当鼠标移动时触发。
• void mouseReleaseEvent(QMouseEvent *event) ：当鼠标按键被释放时触发。

以下是一个基础的鼠标事件处理示例：

class MyCanvas : public QWidget {
public:
    MyCanvas(QWidget *parent = nullptr) : QWidget(parent) {}

protected:
    void mousePressEvent(QMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            startPoint = event->pos(); // 记录起点
            drawing = true;
        }
    }

    void mouseMoveEvent(QMouseEvent *event) override {
        if (drawing) {
            endPoint = event->pos(); // 更新终点
            update(); // 触发重绘
        }
    }

    void mouseReleaseEvent(QMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            endPoint = event->pos();
            drawing = false;
            // 添加图形对象到列表
            addLine(startPoint, endPoint);
        }
    }

private:
    QPoint startPoint, endPoint;
    bool drawing = false;

    void addLine(const QPoint &start, const QPoint &end) {
        // 将线段添加到图形集合中
    }
};

代码逻辑分析

• mousePressEvent() ：检测鼠标左键按下，记录初始坐标，并将 drawing 标志设为 true 。
• mouseMoveEvent() ：若处于绘制状态，则不断更新终点坐标并触发界面重绘。
• mouseReleaseEvent() ：释放鼠标左键时，最终确定线段的终点，并调用 addLine() 方法将线段添加到图形集合中。

6.1.2 坐标转换与事件响应机制

Qt 中的坐标系统默认以左上角为原点 (0,0) ，向右为 x 轴正方向，向下为 y 轴正方向。但在图形处理中，有时需要将屏幕坐标转换为绘图坐标系或其他逻辑坐标。

例如，若希望以窗口中心为原点 (0,0) ，可进行如下转换：

QPoint convertToLogical(QPoint screenPos) {
    int centerX = width() / 2;
    int centerY = height() / 2;
    return QPoint(screenPos.x() - centerX, centerY - screenPos.y());
}

此外，Qt 提供了 QTransform 和 QPainter::setWorldTransform() 方法用于更复杂的坐标变换。

方法	作用
event->pos()	获取当前鼠标在控件内的位置（屏幕坐标）
event->globalPos()	获取鼠标在全局屏幕上的位置
QTransform::translate()	设置坐标系平移变换
QTransform::scale()	设置缩放变换

6.2 图形交互操作的实现

在基础事件捕获的基础上，我们可以实现更复杂的图形交互操作，如鼠标拖动绘制图形、实时预览图形轮廓等。

6.2.1 图形绘制过程中的鼠标拖动

在图形编辑器中，常见的拖动绘制行为包括：

• 画线：按下鼠标左键后拖动，释放时完成绘制。
• 画矩形：按下左键后拖动，形成矩形选区，释放时确认。

以下是一个基于拖动绘制矩形的示例代码：

void MyCanvas::mousePressEvent(QMouseEvent *event) {
    if (event->button() == Qt::LeftButton) {
        rectStart = event->pos();
        isDrawingRect = true;
    }
}

void MyCanvas::mouseMoveEvent(QMouseEvent *event) {
    if (isDrawingRect) {
        rectEnd = event->pos();
        update();
    }
}

void MyCanvas::mouseReleaseEvent(QMouseEvent *event) {
    if (event->button() == Qt::LeftButton && isDrawingRect) {
        rectEnd = event->pos();
        QRect rect(rectStart, rectEnd);
        addRect(rect); // 添加矩形到图形集合
        isDrawingRect = false;
        update();
    }
}

在 paintEvent() 中绘制当前矩形：

void MyCanvas::paintEvent(QPaintEvent *event) {
    QPainter painter(this);
    if (isDrawingRect) {
        painter.setPen(Qt::DashLine);
        painter.drawRect(QRect(rectStart, rectEnd));
    }
    // 绘制已添加的图形对象
}

参数说明

• rectStart ：矩形绘制的起始点。
• rectEnd ：矩形绘制的当前终点。
• isDrawingRect ：标记是否正在进行矩形绘制。

6.2.2 动态预览与实时渲染

在拖动绘制过程中，实时渲染图形轮廓可提升用户交互体验。Qt 的 QPainter 支持双缓冲绘制，可以减少界面闪烁。

void MyCanvas::paintEvent(QPaintEvent *event) {
    QPainter painter(this);
    painter.setRenderHint(QPainter::Antialiasing); // 抗锯齿

    // 绘制已存在的图形对象
    for (auto &shape : shapes) {
        shape->draw(&painter);
    }

    // 绘制当前正在绘制的图形
    if (isDrawingLine && drawing) {
        painter.setPen(Qt::red);
        painter.drawLine(startPoint, endPoint);
    }
}

实时渲染流程图（mermaid）

graph TD
    A[鼠标按下] --> B[记录起始点]
    B --> C[进入拖动状态]
    C --> D{是否释放鼠标?}
    D -- 否 --> E[更新终点并重绘]
    D -- 是 --> F[添加图形对象并结束]

6.3 事件处理的优化与扩展

随着图形交互功能的复杂化，原始的事件处理方式可能难以满足多对象操作、多交互模式的需求。因此，需要对事件处理机制进行优化与扩展。

6.3.1 支持多图形对象的交互切换

在图形编辑器中，用户可能需要选择不同的图形类型（如线段、矩形、圆形）进行绘制。可以通过按钮点击或快捷键切换当前绘制模式。

enum DrawMode {
    Line,
    Rectangle,
    Circle
};

DrawMode currentMode = Line;

void MyCanvas::setDrawMode(DrawMode mode) {
    currentMode = mode;
}

然后在事件处理中根据 currentMode 执行不同的绘制逻辑：

void MyCanvas::mouseReleaseEvent(QMouseEvent *event) {
    switch (currentMode) {
        case Line:
            addLine(startPoint, endPoint);
            break;
        case Rectangle:
            addRect(QRect(startPoint, endPoint));
            break;
        case Circle:
            addCircle(startPoint, distance(startPoint, endPoint));
            break;
    }
}

模式	功能说明
Line	绘制线段
Rectangle	绘制矩形
Circle	绘制圆，半径由起点到终点距离决定

6.3.2 键盘辅助操作的集成设计

键盘可以作为鼠标操作的补充，提升图形交互的效率。例如：

• Esc ：取消当前绘制
• Shift ：限制为正方形或圆形绘制
• Ctrl+Z ：撤销上一步操作

以下为键盘事件处理示例：

void MyCanvas::keyPressEvent(QKeyEvent *event) {
    switch (event->key()) {
        case Qt::Key_Escape:
            cancelDrawing(); // 取消当前绘制
            break;
        case Qt::Key_Z:
            if (event->modifiers() & Qt::ControlModifier) {
                undoLastShape(); // 撤销上一个图形
            }
            break;
    }
}

参数说明

• event->key() ：获取按下的键值。
• event->modifiers() ：获取当前是否按下修饰键（如 Ctrl、Alt、Shift）。

优化建议

• 使用状态机管理绘图状态（空闲、绘制中、选择中）。
• 使用信号与槽机制将事件处理逻辑解耦。
• 对复杂操作进行异步处理，避免阻塞主线程。

通过本章内容的学习，读者应掌握如何在 Qt 中捕获鼠标事件、实现图形交互操作、动态预览图形效果，并能够通过键盘辅助提升交互效率。下一章将围绕颜色选择功能展开，介绍 Qt 提供的颜色选择器与自定义实现方式。

7. 颜色选择器功能实现

在图形绘制应用中，颜色选择功能是用户交互的重要组成部分。本章将围绕如何在C++ Qt框架下实现颜色选择器功能展开讲解，包括标准颜色对话框的调用、自定义颜色面板的设计与实现，以及如何将选中的颜色应用于图形对象的填充与描边。此外，我们还将介绍如何将该功能集成到主界面并进行功能测试与异常处理。

7.1 颜色选择器的界面设计

7.1.1 Qt中颜色对话框的调用

Qt 提供了 QColorDialog 类，用于快速实现颜色选择功能。开发者可以通过调用静态函数 QColorDialog::getColor() 直接获取用户选择的颜色。

QColor color = QColorDialog::getColor(Qt::white, this, "选择颜色");
if (color.isValid()) {
    qDebug() << "选择的颜色为：" << color.name();
}

代码说明：
- Qt::white ：初始颜色设置为白色。
- this ：父窗口指针，用于模态对话框的显示。
- "选择颜色" ：对话框标题。
- color.isValid() ：判断是否点击了“取消”按钮。

该方式适合快速集成标准颜色选择器，尤其适合不需要高度定制的应用场景。

7.1.2 自定义颜色面板的实现

如果需要更灵活的界面控制，开发者可以自定义颜色面板。以下是一个简单的颜色面板实现示例，使用 QPushButton 显示颜色块，并通过信号与槽机制传递颜色值：

class ColorPanel : public QWidget {
    Q_OBJECT
public:
    explicit ColorPanel(QWidget *parent = nullptr) : QWidget(parent) {
        layout = new QHBoxLayout(this);
        for (const QColor &color : QColor::colorNames()) {
            QPushButton *btn = new QPushButton();
            btn->setFixedSize(30, 30);
            btn->setStyleSheet(QString("background-color: %1").arg(color.name()));
            connect(btn, &QPushButton::clicked, this, [this, color]() {
                emit colorSelected(color);
            });
            layout->addWidget(btn);
        }
    }

signals:
    void colorSelected(const QColor &color);

private:
    QHBoxLayout *layout;
};

参数说明：
- QColor::colorNames() ：获取所有预定义颜色名称。
- setStyleSheet ：设置按钮背景颜色。
- emit colorSelected(color) ：当按钮被点击时，发射颜色信号。

该方式可以实现更灵活的界面布局和交互逻辑，适合需要定制化颜色选择器的应用。

7.2 颜色数据的获取与应用

7.2.1 颜色值的获取与传递

在颜色选择器中，选中的颜色通常以 QColor 类型存储。开发者可以将其转换为 QBrush 或 QPen 对象，用于图形绘制。

QColor selectedColor = QColorDialog::getColor();  // 获取颜色
QBrush brush(selectedColor);                     // 创建画刷
QPen pen(selectedColor);                         // 创建画笔

参数说明：
- QBrush ：用于图形填充。
- QPen ：用于图形轮廓绘制。

通过上述方式，开发者可以将颜色选择器的输出结果直接应用于图形绘制功能中。

7.2.2 应用到图形对象的填充与描边

以 QPainter 为例，将颜色应用于图形对象的填充与描边操作如下：

void MyGraphicsView::paintEvent(QPaintEvent *event) {
    QPainter painter(this);
    painter.setPen(pen);      // 设置描边颜色
    painter.setBrush(brush);  // 设置填充颜色
    painter.drawRect(50, 50, 100, 100);  // 绘制矩形
}

执行逻辑说明：
- painter.setPen(pen) ：设置画笔，用于绘制图形轮廓。
- painter.setBrush(brush) ：设置画刷，用于图形填充。
- painter.drawRect(...) ：绘制矩形，使用当前设置的颜色。

通过将颜色选择器的结果传递给 QPen 与 QBrush ，即可实现动态颜色绘制。

7.3 颜色选择功能的集成与测试

7.3.1 与主界面功能的联动

为了实现主界面与颜色选择器的联动，可以将颜色选择按钮与绘图区域绑定。例如：

connect(ui->colorButton, &QPushButton::clicked, [this]() {
    QColor color = QColorDialog::getColor();
    if (color.isValid()) {
        currentPen.setColor(color);
        currentBrush.setColor(color);
        update();  // 触发重绘
    }
});

参数说明：
- ui->colorButton ：主界面上的颜色选择按钮。
- currentPen 、 currentBrush ：当前绘图使用的画笔与画刷。
- update() ：触发界面重绘，使新颜色立即生效。

该逻辑可以实现主界面中颜色选择与图形绘制的实时同步。

7.3.2 功能测试与异常处理策略

在开发过程中，应对颜色选择功能进行充分测试，包括以下方面：

测试项	测试内容	预期结果
空颜色选择	用户点击取消	返回无效颜色，不触发绘图
非法颜色值	输入非法颜色格式	程序应抛出异常或提示错误
多次调用	多次点击颜色按钮	每次都能正确获取并应用新颜色

异常处理策略：
- 使用 QColor::isValid() 判断颜色是否合法。
- 添加日志输出或弹窗提示机制，便于调试。
- 使用 try-catch 块捕获可能的异常，防止程序崩溃。

例如：

try {
    if (!color.isValid()) {
        throw std::invalid_argument("无效的颜色值");
    }
    // 正常处理
} catch (const std::exception &e) {
    QMessageBox::warning(this, "错误", e.what());
}

该方式可以增强程序的健壮性，提高用户体验。

本文还有配套的精品资源，点击获取

简介：本文以C++为基础，详解如何开发一个功能完整的画图工具，适用于课程设计与毕业项目。内容涵盖计算机图形学基础、面向对象设计、图形绘制算法、GUI开发、鼠标事件处理、撤销重做机制、图形保存与加载等关键技术。通过实战项目，帮助开发者掌握图形应用程序的开发流程，提升编程能力和工程实践水平。

本文还有配套的精品资源，点击获取