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

简介：C++ Builder是由Embarcadero开发的集成开发环境，适用于Windows桌面及跨平台应用程序开发。本教程“C++Builder教程”包含从基础语法到高级应用的全面内容，涵盖环境配置、VCL界面设计、数据库连接、内存管理、多线程编程等关键技术点。压缩包内包含PDF、HTML或视频等教学资源，适合初学者和进阶开发者学习C++ Builder开发技能。

1. C++ Builder开发环境搭建

C++ Builder 是 Embarcadero 推出的一款集可视化界面设计与高效 C++ 开发于一体的集成开发环境（IDE），特别适用于快速开发 Windows 桌面应用程序。本章将从零开始，逐步讲解如何在 Windows 平台上安装和配置 C++ Builder 的开发环境。

1.1 安装步骤

首先，访问 Embarcadero 官网 下载 C++ Builder 的安装包。目前主流版本包括 C++ Builder 10.x 及以上版本，推荐使用最新的 C++ Builder 12。

安装步骤如下：

1. 双击下载的安装程序，启动安装向导。
2. 选择安装路径（默认为 C:\Program Files (x86)\Embarcadero\Studio\23.0 ）。
3. 选择组件：勾选“C++ Builder”及相关库文件。
4. 设置许可证类型（可选择试用或输入许可证密钥）。
5. 等待安装完成，重启系统。

安装完成后，打开 IDE 即可进入开发界面。

2. C++语言基础语法讲解

本章将深入探讨C++语言的基础语法，从数据类型、变量定义到控制结构、函数机制，再到指针、引用与面向对象的基础概念，帮助读者构建坚实的编程基础。这些内容不仅是理解C++程序设计的关键，也是掌握C++ Builder开发环境的前提。

2.1 数据类型与变量定义

在C++中，数据类型决定了变量可以存储的数据种类以及对这些数据可以执行的操作。正确使用数据类型和理解变量的生命周期，是编写高效程序的基础。

2.1.1 基本数据类型与复合数据类型

C++提供了多种基本数据类型，包括整型、浮点型、字符型和布尔型。此外，还支持数组、结构体、联合和指针等复合数据类型。

数据类型	关键字	占用字节数（典型）	描述
整型	int	4	用于存储整数
长整型	long	4 或 8	更大范围的整数
浮点型	float	4	单精度浮点数
双精度浮点型	double	8	更高精度的浮点数
字符型	char	1	存储单个字符
布尔型	bool	1	true 或 false
空类型	void	0	不表示任何类型

示例代码：基本数据类型使用

#include <iostream>
using namespace std;

int main() {
    int age = 30;
    double salary = 5000.50;
    char grade = 'A';
    bool isEmployed = true;

    cout << "Age: " << age << endl;
    cout << "Salary: " << salary << endl;
    cout << "Grade: " << grade << endl;
    cout << "Employed: " << (isEmployed ? "Yes" : "No") << endl;

    return 0;
}

逐行解析：

1. #include <iostream> ：包含标准输入输出库。
2. using namespace std; ：使用标准命名空间，避免每次写 std:: 。
3. int main() ：主函数入口。
4. int age = 30; ：定义一个整型变量 age 并赋值为 30。
5. double salary = 5000.50; ：定义一个双精度浮点型变量 salary 。
6. char grade = 'A'; ：定义字符型变量 grade 。
7. bool isEmployed = true; ：定义布尔型变量 isEmployed 。
8. cout << "Age: " << age << endl; ：输出变量值到控制台。
9. return 0; ：程序正常结束。

2.1.2 变量的作用域与生命周期

变量的作用域指的是变量在程序中可以被访问的区域，而生命周期则是变量在内存中存在的时间长度。

• 局部变量 ：定义在函数或代码块内部，生命周期仅限于该代码块执行期间。
• 全局变量 ：定义在所有函数之外，生命周期贯穿整个程序运行期间。
• 静态变量 ：使用 static 关键字定义，其生命周期长于函数调用，但作用域受限。

示例代码：变量作用域演示

#include <iostream>
using namespace std;

int globalVar = 100; // 全局变量

void func() {
    int localVar = 50; // 局部变量
    static int staticVar = 0; // 静态变量

    cout << "Local Var: " << localVar << endl;
    cout << "Static Var: " << ++staticVar << endl;
}

int main() {
    cout << "Global Var: " << globalVar << endl;
    func();
    func();
    return 0;
}

输出结果：

Global Var: 100
Local Var: 50
Static Var: 1
Local Var: 50
Static Var: 2

逻辑分析：

• globalVar 是全局变量，在 main 函数中可访问。
• localVar 每次调用 func 都重新定义，值不变。
• staticVar 在函数调用之间保持其值，说明其生命周期长于函数作用域。

2.2 控制结构与函数机制

C++提供了丰富的控制结构来实现条件判断、循环执行等逻辑控制。函数机制则支持代码模块化和复用。

2.2.1 条件语句与循环语句

C++的控制结构包括：

• if...else ：条件判断
• switch ：多分支选择
• for 、 while 、 do...while ：循环结构

示例代码：条件与循环结构

#include <iostream>
using namespace std;

int main() {
    int score = 85;

    if (score >= 90) {
        cout << "A" << endl;
    } else if (score >= 80) {
        cout << "B" << endl;
    } else {
        cout << "C" << endl;
    }

    for (int i = 0; i < 5; i++) {
        cout << "Loop iteration " << i + 1 << endl;
    }

    return 0;
}

执行流程图：

graph TD
    A[开始] --> B{score >=90}
    B -->|是| C[A]
    B -->|否| D{score >=80}
    D -->|是| E[B]
    D -->|否| F[C]
    C --> G[输出结果]
    E --> G
    F --> G
    G --> H[进入循环]
    H --> I[i初始化为0]
    I --> J{i < 5}
    J -->|是| K[打印迭代次数]
    K --> L[i++]
    L --> J
    J -->|否| M[结束]

逻辑分析：

• 根据 score 的值输出不同的等级。
• 使用 for 循环打印五次信息。

2.2.2 函数的定义、调用与重载

函数是实现模块化编程的核心。C++支持函数重载，即多个同名函数具有不同的参数列表。

示例代码：函数定义与重载

#include <iostream>
using namespace std;

// 函数原型
int add(int a, int b);
double add(double a, double b);

int main() {
    cout << "Int Add: " << add(2, 3) << endl;
    cout << "Double Add: " << add(2.5, 3.5) << endl;
    return 0;
}

int add(int a, int b) {
    return a + b;
}

double add(double a, double b) {
    return a + b;
}

输出结果：

Int Add: 5
Double Add: 6

逻辑分析：

• 定义两个 add 函数，分别接受 int 和 double 类型参数。
• 编译器根据参数类型自动选择合适的函数。

2.3 指针与引用

指针和引用是C++中处理内存和对象的重要机制，它们允许我们直接操作内存地址，实现更高效的程序设计。

2.3.1 指针的基本操作与使用技巧

指针是一个变量，它存储的是另一个变量的地址。

示例代码：指针操作

#include <iostream>
using namespace std;

int main() {
    int value = 100;
    int* ptr = &value;

    cout << "Value: " << value << endl;
    cout << "Address of value: " << &value << endl;
    cout << "Pointer to value: " << ptr << endl;
    cout << "Value via pointer: " << *ptr << endl;

    *ptr = 200;
    cout << "New value: " << value << endl;

    return 0;
}

输出结果：

Value: 100
Address of value: 0x7ffeee5a5a4c
Pointer to value: 0x7ffeee5a5a4c
Value via pointer: 100
New value: 200

逻辑分析：

• ptr 指向 value 的地址。
• 通过 *ptr 修改 value 的值。

2.3.2 引用与指针的区别及适用场景

引用是变量的别名，不能为 NULL ，必须初始化。

示例代码：引用与指针对比

#include <iostream>
using namespace std;

void swapByPointer(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void swapByReference(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 5, y = 10;
    swapByPointer(&x, &y);
    cout << "After pointer swap: x=" << x << ", y=" << y << endl;

    x = 5, y = 10;
    swapByReference(x, y);
    cout << "After reference swap: x=" << x << ", y=" << y << endl;

    return 0;
}

输出结果：

After pointer swap: x=10, y=5
After reference swap: x=10, y=5

逻辑分析：

• swapByPointer 使用指针交换值，需要取地址。
• swapByReference 使用引用，更直观，无需取地址操作。

2.4 面向对象基础

C++是一种面向对象的编程语言，支持类、对象、继承、多态等核心特性。

2.4.1 类与对象的定义

类是对象的蓝图，对象是类的具体实例。

示例代码：类与对象定义

#include <iostream>
using namespace std;

class Person {
private:
    string name;
    int age;

public:
    void setName(string n) { name = n; }
    void setAge(int a) { age = a; }

    string getName() { return name; }
    int getAge() { return age; }

    void introduce() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

int main() {
    Person p1;
    p1.setName("Alice");
    p1.setAge(25);
    p1.introduce();

    return 0;
}

输出结果：

Name: Alice, Age: 25

逻辑分析：

• Person 类封装了姓名和年龄。
• p1 是 Person 类的一个实例。

2.4.2 构造函数与析构函数

构造函数在对象创建时自动调用，析构函数在对象销毁时调用。

示例代码：构造函数与析构函数

#include <iostream>
using namespace std;

class MyClass {
public:
    MyClass() { cout << "Constructor called!" << endl; }
    ~MyClass() { cout << "Destructor called!" << endl; }
};

int main() {
    MyClass obj;
    return 0;
}

输出结果：

Constructor called!
Destructor called!

逻辑分析：

• 创建 obj 时调用构造函数。
• 程序结束时自动调用析构函数。

2.4.3 继承与多态的实现方式

继承允许一个类继承另一个类的属性和方法；多态允许不同类的对象对同一消息作出不同响应。

示例代码：继承与多态

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() { cout << "Animal sound" << endl; }
};

class Dog : public Animal {
public:
    void sound() override { cout << "Bark!" << endl; }
};

class Cat : public Animal {
public:
    void sound() override { cout << "Meow!" << endl; }
};

int main() {
    Animal* a1 = new Dog();
    Animal* a2 = new Cat();

    a1->sound(); // Bark!
    a2->sound(); // Meow!

    delete a1;
    delete a2;

    return 0;
}

逻辑分析：

• Animal 是基类， Dog 和 Cat 是派生类。
• 使用 virtual 实现运行时多态。
• 通过基类指针调用派生类方法。

本章内容覆盖了C++语言的核心基础，从数据类型、控制结构、函数机制，到指针引用，再到面向对象的基础概念，为后续深入学习C++ Builder开发环境打下坚实基础。

3. VCL（可视化组件库）界面设计

在C++ Builder开发中，VCL（Visual Component Library）作为其核心的可视化组件库，承载了界面构建、事件处理、控件交互等关键功能。本章将深入探讨VCL的架构设计、组件分类、控件布局技巧，以及如何通过事件响应机制和自定义控件扩展来提升界面交互体验。我们将从VCL的基础类结构入手，逐步过渡到界面设计实践与自定义控件开发。

3.1 VCL组件概述

VCL是C++ Builder中实现可视化界面的核心库，其设计基于面向对象思想，具备高度可扩展性和良好的继承体系。掌握VCL组件的结构关系和分类方式，是构建复杂用户界面的基础。

3.1.1 VCL框架结构与组件分类

VCL采用层次化设计，以 TObject 为根类，逐步派生出 TComponent 、 TControl 、 TWinControl 等核心类，形成组件与控件的继承体系。组件大致分为以下几类：

类型	描述说明	典型代表类
非可视组件	不在界面上显示，用于数据管理或逻辑处理	TTimer、TDataSource
可视控件	在窗体上可见并可交互的组件	TButton、TEdit、TLabel
窗口控件	具有Windows句柄的控件	TListBox、TComboBox
容器控件	可以容纳其他控件的控件	TPanel、TGroupBox

VCL组件的结构如下图所示：

classDiagram
    TObject <|-- TComponent
    TComponent <|-- TControl
    TControl <|-- TWinControl
    TWinControl <|-- TButton
    TWinControl <|-- TEdit
    TWinControl <|-- TLabel
    TComponent <|-- TTimer
    TComponent <|-- TDataSource

该图展示了VCL中最基本的类继承关系。 TObject 是所有类的基类，提供基本的运行时类型信息（RTTI）和内存管理功能； TComponent 引入了组件生命周期管理、持久化（如流式加载）等功能； TControl 是可视控件的基类； TWinControl 则为具有Windows句柄的控件提供了支持。

3.1.2 TControl、TComponent等基础类关系

• TComponent 是非可视组件的基类，支持组件注册、设计时支持（IDE中拖拽）、事件发布等功能。
• TControl 是可视控件的基类，定义了位置（Left、Top）、大小（Width、Height）等属性。
• TWinControl 派生于 TControl ，为需要窗口句柄的控件提供支持，如按钮、文本框等。
• TCustomControl 是一个抽象类，用于创建自定义的窗口控件，支持绘图和事件响应。

理解这些类之间的关系，有助于在开发过程中合理选择基类，提升控件的性能与可维护性。

示例代码：从TButton派生一个自定义按钮类

class TMyButton : public TButton {
private:
    int FClickCount;
    void __fastcall OnClickBtn(TObject *Sender);
protected:
    void __fastcall CreateParams(TCreateParams &Params);
public:
    __fastcall TMyButton(TComponent* Owner);
    __property int ClickCount = {read = FClickCount};
};

代码分析：

• TMyButton 继承自 TButton ，保留了所有按钮功能。
• FClickCount 用于记录点击次数。
• OnClickBtn 是自定义的点击事件处理函数。
• CreateParams 用于设置窗口样式，比如自定义绘制。
• ClickCount 是一个只读属性，供外部访问点击次数。

这个类可以进一步扩展，例如添加自定义绘制逻辑、动画效果或事件绑定机制。

3.2 界面布局与事件响应

VCL提供强大的窗体设计器（Form Designer），允许开发者通过拖拽方式快速构建用户界面。同时，事件驱动机制使得控件之间的交互更加灵活。

3.2.1 表单设计器的使用

C++ Builder的表单设计器提供了直观的拖拽控件方式，支持对齐、布局、锚定（Anchors）等布局功能。

布局技巧：

• Align属性 ：将控件自动对齐到窗体的某个边缘（如 alTop 、 alClient ）。
• Anchors属性 ：控制控件在窗体缩放时的位置变化，例如 akLeft 、 akTop 。
• 布局控件 ：使用 TPanel 、 TScrollBox 、 TGroupBox 等容器控件组织界面。

示例：使用 TPanel 和 TButton 布局登录界面

__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
    Panel1 = new TPanel(this);
    Panel1->Parent = this;
    Panel1->Align = alClient;
    Panel1->BevelOuter = bvNone;

    Button1 = new TButton(this);
    Button1->Parent = Panel1;
    Button1->Caption = "登录";
    Button1->Width = 80;
    Button1->Height = 30;
    Button1->Left = (Panel1->Width - Button1->Width) / 2;
    Button1->Top = Panel1->Height - Button1->Height - 20;
}

代码分析：

• 创建了一个 TPanel 作为主容器，设置其 Align = alClient 使其填满整个窗体。
• TButton 作为登录按钮，放置在面板底部中央。
• 使用表达式动态计算按钮位置，避免硬编码。

3.2.2 控件事件绑定与响应函数编写

VCL采用事件驱动模型，开发者可以通过双击控件自动绑定事件函数，如 OnClick 、 OnChange 等。

示例：按钮点击事件绑定

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    ShowMessage("登录成功！");
}

事件绑定流程图：

graph TD
    A[用户点击按钮] --> B[触发OnClick事件]
    B --> C[调用绑定的响应函数]
    C --> D[显示登录成功提示]

代码逻辑说明：

• Button1Click 是按钮的点击事件处理函数。
• ShowMessage 为VCL提供的弹窗函数，用于调试或提示信息。
• 事件函数中可以加入验证逻辑、网络请求、数据处理等操作。

3.3 自定义界面控件

虽然VCL自带了丰富的控件库，但在实际开发中往往需要根据特定需求进行扩展，甚至完全自定义控件。

3.3.1 继承现有控件并扩展功能

继承是扩展控件功能的最常见方式。例如，我们可以继承 TEdit 实现一个只允许输入数字的编辑框。

示例：自定义数字输入框

class TNumericEdit : public TEdit {
private:
    void __fastcall OnKeyPress(TObject *Sender, wchar_t &Key);
public:
    __fastcall TNumericEdit(TComponent* Owner);
};

__fastcall TNumericEdit::TNumericEdit(TComponent* Owner)
    : TEdit(Owner)
{
    OnKeyPress = OnKeyPress;
}

void __fastcall TNumericEdit::OnKeyPress(TObject *Sender, wchar_t &Key)
{
    if (!isdigit(Key) && Key != VK_BACK)
        Key = 0;  // 拦截非数字字符
}

代码分析：

• 继承 TEdit ，并重写 OnKeyPress 事件。
• 在按键事件中判断输入是否为数字或退格键。
• 若不符合要求，将 Key 设为0，表示忽略该按键。

3.3.2 实现自定义绘图与交互逻辑

对于更复杂的控件，如自定义图表、进度条等，可以继承 TCustomControl 并重写 Paint 方法实现绘图。

示例：绘制一个圆形进度条

class TCircleProgress : public TCustomControl {
private:
    int FProgress;
    void __fastcall Paint();
public:
    __fastcall TCircleProgress(TComponent* Owner);
    __property int Progress = {read=FProgress, write=FProgress, default=0};
};

实现绘制函数：

void __fastcall TCircleProgress::Paint()
{
    Canvas->Brush->Color = clWhite;
    Canvas->FillRect(ClientRect);

    int radius = Min(Width, Height) / 2 - 10;
    int cx = Width / 2;
    int cy = Height / 2;

    Canvas->Pen->Color = clBlue;
    Canvas->Arc(cx - radius, cy - radius,
                cx + radius, cy + radius,
                cx, cy - radius, cx, cy + radius);

    // 绘制进度扇形
    double angle = 2 * M_PI * FProgress / 100;
    int x1 = cx + radius * cos(angle);
    int y1 = cy + radius * sin(angle);
    Canvas->Pie(cx - radius, cy - radius,
                cx + radius, cy + radius,
                cx, cy - radius, x1, y1);
}

代码逻辑说明：

• 使用 Canvas 绘图接口绘制圆形。
• Arc 绘制空心圆， Pie 绘制扇形表示进度。
• Progress 属性控制进度值，范围为0~100。
• Paint() 方法在控件重绘时自动调用。

使用自定义控件

void __fastcall TForm1::FormCreate(TObject *Sender)
{
    TCircleProgress *progress = new TCircleProgress(this);
    progress->Parent = this;
    progress->Align = alClient;
    progress->Progress = 75;
}

效果说明：

• 控件自动填充窗体。
• 显示75%的进度圆环。

小结

本章从VCL组件的基础类结构出发，深入讲解了控件分类、继承体系，以及如何利用表单设计器构建界面。通过事件响应机制的分析，展示了如何实现控件交互。最后，通过自定义控件的实例，演示了如何继承现有控件并扩展功能，以及如何实现自定义绘图逻辑。这些内容为后续章节中组件封装与数据库绑定打下了坚实基础。

4. RTTI与元类的使用

在C++开发中，运行时类型信息（RTTI）和元类（MetaClass）是实现动态类型识别与运行时反射机制的关键技术。尤其在C++ Builder与VCL（Visual Component Library）框架中，RTTI不仅支持类型安全的动态转换，还为组件动态创建、属性访问、事件绑定等高级功能提供了底层支撑。本章将从RTTI的基础概念入手，深入剖析其在VCL中的应用，并结合元类的实现机制，探讨其在动态调用与反射中的具体实践。

4.1 RTTI（运行时类型信息）基础

RTTI（Runtime Type Information）是C++标准中用于在运行时获取对象类型信息的机制。它主要包括 typeid 和 dynamic_cast 两个核心运算符。在C++ Builder中，RTTI的功能被进一步扩展，特别是在VCL控件中，RTTI是实现组件动态创建和属性访问的基础。

4.1.1 RTTI的作用与实现机制

RTTI的主要作用包括：

• 运行时类型识别 ：在程序运行过程中，判断一个对象的实际类型。
• 类型安全的向下转型 ：通过 dynamic_cast 实现安全的类型转换。
• 异常处理类型匹配 ：用于 catch 块中匹配抛出的异常类型。

RTTI的实现机制

RTTI的实现依赖于编译器在编译时为每个具有虚函数的类生成类型信息结构（ type_info 对象）。这些信息包括类名、继承关系、虚函数表指针等。当使用 typeid 或 dynamic_cast 时，程序会访问这些结构以完成类型识别或转换。

以下是一个简单的示例，展示 typeid 的使用：

#include <iostream>
#include <typeinfo>

class Base {
public:
    virtual void dummy() {}
};

class Derived : public Base {};

int main() {
    Base base;
    Derived derived;

    std::cout << "Type of base: " << typeid(base).name() << std::endl;       // 输出 Base
    std::cout << "Type of derived: " << typeid(derived).name() << std::endl; // 输出 Derived

    Base* ptr = &derived;
    std::cout << "Type of ptr: " << typeid(*ptr).name() << std::endl; // 输出 Derived（因为有虚函数）
}

代码解析：

• Base 类中定义了一个虚函数 dummy() ，这使得 Base 成为一个多态类型。
• typeid 用于获取变量或对象的类型名。
• 当 ptr 指向 Derived 对象时， typeid(*ptr) 返回的是 Derived ，而不是 Base ，这表明 RTTI 支持运行时的类型识别。

表格：RTTI 运算符对比

运算符	功能描述	是否支持运行时识别	是否需要虚函数
typeid	获取对象或类型的运行时信息	是	否
dynamic_cast	安全地将基类指针转换为派生类指针	是	是

4.1.2 typeid 与 dynamic_cast 的使用

dynamic_cast 的使用

dynamic_cast 主要用于多态类型之间的转换，确保转换是安全的。如果转换失败，返回 nullptr （对于指针）或抛出异常（对于引用）。

Base* basePtr = new Derived();
Derived* derivedPtr = dynamic_cast<Derived*>(basePtr);
if (derivedPtr) {
    std::cout << "Cast successful!" << std::endl;
} else {
    std::cout << "Cast failed!" << std::endl;
}

代码逻辑分析：

• basePtr 是一个指向 Base 的指针，实际指向的是 Derived 对象。
• 使用 dynamic_cast 尝试将 basePtr 转换为 Derived* 。
• 因为 Base 是多态类型（含有虚函数），所以 dynamic_cast 能够识别实际类型并成功转换。

使用场景对比：

场景	推荐使用
获取类型信息（调试/日志）	typeid
安全类型转换（多态向下转型）	dynamic_cast

4.2 元类（MetaClass）概念解析

在VCL中， 元类（MetaClass） 是一种特殊的类类型，用于在运行时表示类的类型信息。它不仅包含了类的名称、父类、属性、方法等信息，还支持在运行时动态创建类的实例。

4.2.1 TObject 与 TRttiObject 的继承体系

VCL 中的类继承体系以 TObject 为根类，所有 VCL 对象都继承自 TObject 。而 TRttiObject 则是 Delphi RTTI 系统中用于封装 RTTI 信息的类，在 C++ Builder 中也有相应的实现。

类继承关系（简化）

classDiagram
    TObject <|-- TComponent
    TObject <|-- TPersistent
    TPersistent <|-- TControl
    TComponent <|-- TControl
    TControl <|-- TButton
    TControl <|-- TEdit

关键类说明：

• TObject ：所有 VCL 类的基类，提供基本的对象管理功能。
• TPersistent ：支持对象持久化，如保存和加载到流。
• TComponent ：支持组件注册、拥有者机制和运行时访问。
• TControl ：UI 控件的基础类，定义了位置、大小、颜色等基本属性。
• TButton 、 TEdit ：具体的 UI 控件。

4.2.2 元类在 VCL 控件动态创建中的应用

VCL 利用 RTTI 和元类机制，支持通过类名字符串来动态创建控件。这种机制在组件面板、对象序列化、插件系统中非常常见。

示例：通过类名创建控件

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"

TForm1 *Form1;

__fastcall TForm1::TForm1(TComponent* Owner)
    : TForm(Owner)
{
}

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    TClass* classType = GetClass("TButton"); // 获取 TButton 类的元类
    if (classType) {
        TControl* ctrl = (TControl*)classType->NewInstance(); // 创建实例
        ctrl->Create(this); // 设置父控件
        ctrl->SetBounds(10, 10, 100, 30); // 设置位置和大小
        TButton* btn = dynamic_cast<TButton*>(ctrl);
        if (btn) {
            btn->Caption = "Dynamic Button";
        }
        this->InsertControl(ctrl);
    }
}

代码逐行解析：

1. GetClass("TButton") ：通过类名获取对应的元类。
2. NewInstance() ：调用元类的 NewInstance 方法创建对象实例。
3. SetBounds() ：设置控件的显示位置和大小。
4. InsertControl() ：将控件插入到当前窗体中。

使用流程图：

graph TD
    A[获取类名] --> B[调用GetClass获取元类]
    B --> C{元类是否存在?}
    C -->|是| D[调用NewInstance创建实例]
    D --> E[初始化控件属性]
    E --> F[插入到窗体布局中]
    C -->|否| G[抛出异常或提示错误]

4.3 反射与动态调用

RTTI 不仅可以用于类型识别，还可以实现反射机制，即在运行时动态访问类的成员变量和方法。C++ Builder 提供了 TRttiContext 和 TRttiType 等类，用于实现这一功能。

4.3.1 通过 RTTI 获取类成员信息

VCL 中的 RTTI 支持访问类的属性、方法等成员信息。虽然 C++ 本身的标准 RTTI 不支持直接访问成员函数或属性，但在 C++ Builder 中，可以通过 VCL 提供的扩展 RTTI 系统来实现。

示例：获取类的属性列表

#include <System.Rtti.hpp>

class MyClass {
private:
    int value;
    String name;

public:
    __property int Value = { read = value, write = value };
    __property String Name = { read = name, write = name };
};

void PrintProperties() {
    TRttiContext ctx;
    TRttiType* type = ctx.GetType(__classid(MyClass));
    if (type) {
        for (TRttiProperty* prop : type->GetProperties()) {
            std::cout << "Property: " << prop->GetName() << " (" << prop->GetValueType()->GetName() << ")" << std::endl;
        }
    }
}

代码解析：

• TRttiContext ：用于获取类的 RTTI 信息。
• GetType(__classid(MyClass)) ：获取 MyClass 的类型信息。
• GetProperties() ：返回类的所有属性。
• prop->GetName() ：获取属性名称。
• prop->GetValueType() ：获取属性类型。

属性信息输出示例：

Property: Value (int)
Property: Name (UnicodeString)

4.3.2 实现运行时方法调用和属性访问

在实际开发中，有时需要在运行时根据方法名动态调用某个类的方法，或根据属性名读写属性值。C++ Builder 提供了 RTTI 支持来实现这一点。

示例：动态调用方法

class MyClass {
public:
    void SayHello(const String& name) {
        ShowMessage("Hello, " + name);
    }
};

void CallMethodDynamically() {
    TRttiContext ctx;
    TRttiType* type = ctx.GetType(__classid(MyClass));
    MyClass obj;

    TRttiMethod* method = type->GetMethod("SayHello");
    if (method) {
        TValue args[1];
        args[0] = String("World");
        method->Invoke(&obj, args, 1);
    }
}

代码解析：

• GetMethod("SayHello") ：获取名为 SayHello 的方法。
• TValue args[1] ：构造方法参数。
• method->Invoke(&obj, args, 1) ：调用方法。

参数说明：

• &obj ：方法调用的目标对象。
• args ：参数数组。
• 1 ：参数个数。

表格：反射机制功能对比

功能	支持的 RTTI 机制	是否需要虚函数	是否支持私有成员
类型识别	typeid	否	否
安全类型转换	dynamic_cast	是	否
获取属性/方法信息	VCL RTTI（TRttiType）	否	是（需特殊处理）
动态方法调用	VCL RTTI（TRttiMethod）	否	否

总结

本章从 RTTI 的基本概念入手，详细讲解了其在 C++ Builder 中的应用，包括类型识别、动态转换和元类机制。通过结合 VCL 组件的动态创建与反射调用实例，展示了 RTTI 在大型 GUI 框架中的实际作用。下一章将围绕 C++ Builder 中预定义组件的调用与开发展开，进一步探讨如何在实际项目中高效使用 VCL 提供的丰富控件资源。

5. 预定义组件的调用与开发

在C++ Builder中，预定义的VCL组件是构建应用程序界面和实现业务逻辑的重要基础。本章将深入探讨如何调用和使用标准UI组件、实现数据绑定与组件联动，并进一步介绍如何开发和封装可复用的自定义组件，最终将其发布到IDE组件面板中。本章内容不仅适用于初学者，也能为有经验的开发者提供进阶思路与技巧。

5.1 标准UI组件使用

C++ Builder内置了丰富的标准UI组件，如按钮、编辑框、标签、菜单、工具栏等，开发者可以利用这些组件快速构建功能完善、交互性强的用户界面。

5.1.1 TButton、TEdit、TLabel等控件的常用操作

TButton、TEdit 和 TLabel 是最基础也是最常用的控件。它们的使用方式虽然简单，但通过合理的布局与事件绑定，可以实现复杂的用户交互逻辑。

1. TButton 的使用

TButton 是用于触发动作的控件。其核心事件是 OnClick ，当用户点击按钮时触发。

示例代码：

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    Label1->Caption = "按钮被点击了！";
}

• __fastcall 是C++ Builder中用于指定函数调用约定的关键字。
• TForm1::Button1Click 是TButton控件的点击事件处理函数。
• Label1->Caption 用于设置 TLabel 控件的显示文本。

参数说明：

• TObject *Sender ：指向触发事件的对象的指针，可用于识别是哪个按钮被点击。
• TObject 是VCL中所有类的基类，支持多态和运行时类型识别（RTTI）。

2. TEdit 的使用

TEdit 用于接收用户的文本输入，通常用于表单数据收集。

void __fastcall TForm1::Button1Click(TObject *Sender)
{
    String input = Edit1->Text;
    Label1->Caption = "你输入的是：" + input;
}

• Edit1->Text 获取用户在编辑框中输入的内容。
• String 是C++ Builder中封装的字符串类，支持自动内存管理。

3. TLabel 的使用

TLabel 用于显示静态文本，常用于提示信息。

Label1->Caption = "欢迎使用C++ Builder！";

• Caption 属性控制显示的文本内容。

4. 组件布局技巧

在表单设计器中，可以通过 Align 属性控制控件的对齐方式，例如：

• alTop ：控件顶部对齐
• alClient ：控件填满整个容器
• alLeft ：控件左对齐

此外，使用 Anchors 属性可以让控件在窗口大小变化时保持相对位置。

5.1.2 菜单、工具栏与状态栏的布局与实现

在现代应用程序中，菜单栏、工具栏和状态栏是不可或缺的界面元素。C++ Builder提供了 TMainMenu 、 TToolBar 和 TStatusBar 组件，帮助开发者快速实现这些功能区域。

1. 菜单栏的实现（TMainMenu）

TMainMenu 组件用于创建应用程序的主菜单。可以在表单设计器中添加菜单项并设置事件处理。

步骤如下：

1. 拖放 TMainMenu 组件到窗体上。
2. 双击组件，打开菜单编辑器，添加“文件”、“编辑”等顶级菜单项。
3. 为每个菜单项添加子菜单，并设置其 OnClick 事件。

void __fastcall TForm1::Exit1Click(TObject *Sender)
{
    Close(); // 关闭应用程序
}

2. 工具栏的实现（TToolBar）

TToolBar 提供了快速访问常用功能的按钮。通常与 TActionList 配合使用，以实现统一的命令管理。

示例：

1. 添加 TToolBar 和 TActionList 到窗体。
2. 在 TActionList 中添加动作（Action），如“新建”、“保存”等。
3. 将 TActionList 中的动作拖拽到 TToolBar 上，自动生成按钮。

void __fastcall TForm1::ActionNewExecute(TObject *Sender)
{
    Memo1->Clear(); // 清空文本编辑区域
}

3. 状态栏的实现（TStatusBar）

TStatusBar 用于显示状态信息，如当前操作提示、光标位置等。

示例：

StatusBar1->SimpleText = "就绪";

或者设置多个面板（Panels）以显示不同信息：

StatusBar1->Panels->Items[0]->Text = "行号：" + IntToStr(currentLine);
StatusBar1->Panels->Items[1]->Text = "列号：" + IntToStr(currentColumn);

4. 布局结构图（Mermaid流程图）

graph TD
    A[窗体] --> B[菜单栏 TMainMenu]
    A --> C[工具栏 TToolBar]
    A --> D[状态栏 TStatusBar]
    B --> B1(文件)
    B --> B2(编辑)
    C --> C1(新建)
    C --> C2(保存)
    D --> D1(状态面板1)
    D --> D2(状态面板2)

5.2 数据绑定与组件联动

在实际应用中，界面组件之间常常需要进行数据联动，尤其是在数据库应用中。C++ Builder 提供了强大的数据绑定机制，通过 TDataSource 、 TDBGrid 等组件，可以实现界面控件与数据源的自动同步。

5.2.1 TDBGrid、TDataSource等数据库控件的绑定

1. TDBGrid 与 TDataSource 的绑定

TDBGrid 是一个用于显示数据库表数据的表格控件。它必须通过 TDataSource 与数据库连接组件（如 TADOTable ）进行绑定。

绑定步骤：

1. 添加 TADOTable 、 TDataSource 和 TDBGrid 到窗体。
2. 设置 TADOTable 的 Connection 属性，连接数据库。
3. 设置 TDataSource 的 DataSet 属性为 TADOTable 。
4. 设置 TDBGrid 的 DataSource 属性为 TDataSource 。

代码示例：

ADOTable1->TableName = "Employees";
ADOTable1->Open();

• ADOTable1->Open() 打开数据表并加载数据。
• TDBGrid 自动显示 Employees 表中的数据。

2. 数据绑定参数说明

控件	属性	说明
TADOTable	Connection	指定数据库连接对象
TDataSource	DataSet	绑定的数据集对象
TDBGrid	DataSource	绑定的数据源对象

5.2.2 控件之间的数据联动与事件触发

控件之间的联动通常通过事件驱动实现。例如，选择一个下拉框的值，自动更新另一个控件的内容。

1. 示例：TComboBox 与 TLabel 联动

void __fastcall TForm1::ComboBox1Change(TObject *Sender)
{
    Label1->Caption = "你选择了：" + ComboBox1->Text;
}

• ComboBox1->Text 获取当前选中项的文本。
• Label1->Caption 实时更新显示内容。

2. 数据联动结构图（Mermaid流程图）

graph LR
    A[TComboBox] -->|选择变化| B[TLabel]
    B --> C[更新显示]

5.3 自定义组件封装与发布

除了使用预定义组件，开发者还可以创建自定义组件，以提高代码复用率和开发效率。

5.3.1 开发可复用的自定义组件

自定义组件通常通过继承现有的VCL组件来实现功能扩展。

1. 创建自定义按钮组件（继承 TButton）

// MyButton.hpp
#ifndef MyButtonH
#define MyButtonH

#include <vcl.h>

class PACKAGE TMyButton : public TButton
{
private:
    int FClickCount;
    void __fastcall OnClickBtn(TObject *Sender);
public:
    __fastcall TMyButton(TComponent* Owner);
    __property int ClickCount = { read = FClickCount };
};

#endif

// MyButton.cpp
#include "MyButton.h"

__fastcall TMyButton::TMyButton(TComponent* Owner)
    : TButton(Owner), FClickCount(0)
{
    this->OnClick = OnClickBtn;
}

void __fastcall TMyButton::OnClickBtn(TObject *Sender)
{
    FClickCount++;
    Caption = "已点击 " + IntToStr(FClickCount) + " 次";
}

• PACKAGE 关键字用于将类导出到包中。
• FClickCount 是一个私有成员变量，记录点击次数。
• OnClickBtn 是新的点击事件处理函数，更新按钮文本。

2. 使用自定义组件

在窗体中添加 TMyButton 组件后，每次点击按钮都会显示点击次数。

5.3.2 将组件加入IDE组件面板

为了方便在多个项目中使用自定义组件，可以将其封装为组件包（BPL），并添加到IDE的组件面板中。

1. 步骤如下：

1. 在C++ Builder中创建一个新的组件包项目（Package）。
2. 将自定义组件的 .cpp 和 .hpp 文件添加到项目中。
3. 编译项目生成 .bpl 文件。
4. 在IDE中选择 Component > Install Packages ，浏览并安装该 .bpl 文件。
5. 重新启动IDE后，组件将出现在组件面板中。

2. 安装组件流程图（Mermaid）

graph LR
    A[编写组件代码] --> B[创建组件包]
    B --> C[添加组件文件]
    C --> D[编译生成BPL]
    D --> E[安装到IDE]
    E --> F[组件出现在面板]

本章通过详细介绍标准UI组件的使用、数据绑定与组件联动机制，以及自定义组件的开发与发布，为开发者构建功能丰富、结构清晰的C++ Builder应用程序提供了完整的解决方案。下一章将深入探讨数据库连接与访问技术，包括ADO、BDE与ODBC的实际应用。

6. 数据库连接与访问技术（ADO/BDE/ODBC）

在现代软件开发中，数据库连接与访问技术是构建企业级应用程序不可或缺的一部分。C++ Builder 提供了多种数据库连接技术，包括 ADO（ActiveX Data Objects）、BDE（Borland Database Engine）和 ODBC（Open Database Connectivity），每种技术都有其特点与适用场景。本章将深入讲解这些数据库连接机制的原理、配置方式、数据访问操作以及事务处理机制，帮助开发者在实际项目中选择合适的数据库访问策略。

6.1 数据库连接基础

数据库连接是进行数据操作的前提，选择合适的连接技术对于系统的性能、稳定性和可维护性具有决定性影响。本节将介绍 ADO、BDE 和 ODBC 的基本原理，并重点讲解数据源的配置与连接字符串的设置方法。

6.1.1 ADO、BDE、ODBC 的基本原理

技术	全称	特点	适用场景
ADO	ActiveX Data Objects	基于 COM 技术，支持多种数据库类型，接口简单，功能强大	Windows 平台下的数据库应用
BDE	Borland Database Engine	Borland 自研技术，适合本地数据库（如 Paradox、dBase）和远程数据库（如 Oracle、MySQL）	传统 Delphi/C++ Builder 应用程序
ODBC	Open Database Connectivity	标准数据库接口，跨平台，兼容性强	多种数据库系统的统一访问接口

• ADO 是 Microsoft 推出的一组 COM 接口，封装了数据库访问的底层细节，适合快速开发，尤其适用于 SQL Server 和 Access。
• BDE 是 Borland 自主开发的数据库引擎，支持本地和远程数据库访问，但已被逐渐淘汰。
• ODBC 是一个开放标准，提供统一接口访问不同数据库，灵活性强，适用于多平台和异构数据库环境。

6.1.2 数据源配置与连接字符串设置

在使用 ADO 或 ODBC 时，通常需要配置数据源（DSN），或者直接在代码中设置连接字符串。

示例：使用 ADOConnection 配置连接字符串（SQL Server）

TADOConnection *Conn = new TADOConnection(this);
Conn->ConnectionString = "Provider=SQLOLEDB.1;"
                         "Password=your_password;"
                         "Persist Security Info=True;"
                         "User ID=sa;"
                         "Initial Catalog=YourDatabase;"
                         "Data Source=YourServerName;";
Conn->LoginPrompt = false;
try {
    Conn->Open();
    ShowMessage("连接成功！");
} catch (Exception &e) {
    ShowMessage("连接失败：" + e.Message);
}

代码解析：

• Provider=SQLOLEDB.1 ：指定使用的数据库驱动为 SQL Server 的 OLE DB 提供程序。
• Password 和 User ID ：数据库登录凭据。
• Initial Catalog ：默认数据库名称。
• Data Source ：数据库服务器地址。
• LoginPrompt = false ：关闭登录弹窗。
• Open() ：尝试建立连接。

示例：ODBC 连接字符串（MySQL）

Conn->ConnectionString = "Driver={MySQL ODBC 8.0 Driver};"
                         "Server=localhost;"
                         "Database=testdb;"
                         "User=root;"
                         "Password=123456;"
                         "Option=3;";

参数说明：

• Driver ：指定使用的 ODBC 驱动。
• Server ：MySQL 数据库服务器地址。
• Database ：目标数据库名称。
• User 和 Password ：登录账号与密码。
• Option=3 ：启用 ANSI 模式，提升兼容性。

6.2 数据库访问操作

完成数据库连接后，下一步是执行数据库操作，包括查询、插入、更新和删除等。C++ Builder 提供了丰富的数据库访问组件，如 TADOTable 、 TADOQuery 等，可灵活支持不同场景的数据访问需求。

6.2.1 使用 TADOConnection 与 TADOTable 操作数据

TADOTable 是 ADO 的表操作组件，适合对单一表进行操作，支持数据浏览、编辑、插入和删除。

示例：使用 TADOTable 查询和修改数据

TADOTable *Table = new TADOTable(this);
Table->Connection = Conn; // 已配置的 TADOConnection 实例
Table->TableName = "Customers";
Table->Open(); // 打开表

// 遍历记录
while (!Table->Eof) {
    String name = Table->FieldByName("CustomerName")->AsString;
    ShowMessage(name);
    Table->Next();
}

// 插入新记录
Table->Append();
Table->FieldByName("CustomerName")->AsString = "New Customer";
Table->FieldByName("ContactName")->AsString = "John Doe";
Table->Post(); // 提交更改

逻辑分析：

• TableName ：指定要操作的数据表。
• Open() ：打开数据表并加载记录。
• FieldByName() ：通过字段名获取字段对象。
• Append() / Post() ：插入新记录并提交更改。
• Eof ：判断是否到达数据表末尾。

6.2.2 SQL 语句执行与结果集处理

对于复杂查询和跨表操作，使用 TADOQuery 更加灵活。

示例：使用 TADOQuery 执行 SQL 查询

TADOQuery *Query = new TADOQuery(this);
Query->Connection = Conn;
Query->SQL->Text = "SELECT * FROM Customers WHERE Country = :Country";
Query->Parameters->ParamByName("Country")->Value = "USA";
Query->Open();

while (!Query->Eof) {
    ShowMessage(Query->FieldByName("CustomerName")->AsString);
    Query->Next();
}

参数说明：

• SQL->Text ：设置 SQL 查询语句。
• Parameters->ParamByName() ：使用命名参数绑定，防止 SQL 注入。
• Open() ：执行查询并打开结果集。
• FieldByName() ：获取字段值。

流程图：TADOQuery 数据访问流程

graph TD
    A[创建 TADOQuery 实例] --> B[设置 Connection]
    B --> C[设置 SQL 查询语句]
    C --> D[绑定参数]
    D --> E[调用 Open() 执行查询]
    E --> F[遍历结果集]
    F --> G{是否还有记录?}
    G -- 是 --> H[读取字段数据]
    H --> F
    G -- 否 --> I[释放资源]

6.3 数据库事务与并发控制

在高并发环境下，事务管理与并发控制是确保数据一致性和系统稳定性的关键。C++ Builder 提供了事务处理接口，支持 ADO 的事务管理机制。

6.3.1 事务管理机制

事务是一组数据库操作，要么全部成功，要么全部失败，保证数据的原子性、一致性、隔离性和持久性（ACID）。

示例：使用 ADOConnection 管理事务

Conn->BeginTrans(); // 开始事务

try {
    TADOQuery *Query = new TADOQuery(this);
    Query->Connection = Conn;

    // 插入记录
    Query->SQL->Text = "INSERT INTO Orders (CustomerID, OrderDate) VALUES (1001, GETDATE())";
    Query->ExecSQL();

    // 更新记录
    Query->SQL->Text = "UPDATE Customers SET Balance = Balance - 100 WHERE CustomerID = 1001";
    Query->ExecSQL();

    Conn->CommitTrans(); // 提交事务
} catch (Exception &e) {
    Conn->RollbackTrans(); // 回滚事务
    ShowMessage("事务失败：" + e.Message);
}

逻辑分析：

• BeginTrans() ：开始事务。
• CommitTrans() ：提交事务，所有更改生效。
• RollbackTrans() ：回滚事务，撤销所有未提交的更改。
• ExecSQL() ：执行不返回结果集的 SQL 语句（如 INSERT、UPDATE、DELETE）。

6.3.2 多用户并发访问时的冲突解决策略

在多用户环境中，多个事务同时访问同一数据可能导致脏读、不可重复读、幻读等问题。可以通过设置事务隔离级别来控制并发行为。

隔离级别	脏读	不可重复读	幻读	说明
Read Uncommitted	是	是	是	最低隔离级别，允许读取未提交的数据
Read Committed	否	是	是	大多数数据库默认级别
Repeatable Read	否	否	是	保证同一事务中多次读取相同数据的结果一致
Serializable	否	否	否	最高隔离级别，完全隔离事务

设置事务隔离级别（以 ADO 为例）

Conn->IsolationLevel = ilReadCommitted;

参数说明：

• ilReadUncommitted 、 ilReadCommitted 、 ilRepeatableRead 、 ilSerializable ：分别为不同的隔离级别。

小结

本章系统讲解了 C++ Builder 中的数据库连接与访问技术，涵盖了 ADO、BDE 和 ODBC 的基本原理、连接配置、数据操作及事务管理等内容。通过实际代码示例和流程图，帮助开发者深入理解数据库访问机制，并掌握构建高并发、稳定数据库应用的核心技术。

7. 内存管理机制与优化

7.1 内存分配与释放机制

C++ Builder 提供了多种内存分配和释放机制，开发者可以灵活选择使用 new/delete 或 malloc/free ，但它们在底层实现和使用方式上存在显著差异。

7.1.1 new/delete 与 malloc/free 的使用与区别

new 和 delete 是 C++ 运算符，用于动态分配和释放对象，支持构造函数和析构函数的自动调用。而 malloc 和 free 是 C 标准库函数，只分配原始内存，不会调用构造函数。

// 使用 new/delete
MyClass* obj1 = new MyClass();  // 调用构造函数
delete obj1;

// 使用 malloc/free
MyClass* obj2 = (MyClass*)malloc(sizeof(MyClass));  // 不调用构造函数
new(obj2) MyClass();  // 显式调用构造函数（placement new）
obj2->~MyClass();     // 显式调用析构函数
free(obj2);

特性	new/delete	malloc/free
是否调用构造函数	是	否
是否类型安全	是	否（需强制类型转换）
是否可重载	是	否
返回类型	指向对象的指针	void*

7.1.2 C++ Builder 的内存管理器（Memory Manager）

C++ Builder 使用内置的内存管理器（Memory Manager）来优化内存分配行为。它在底层封装了 new 和 delete 的调用，通过内存池机制减少频繁的系统调用开销。

可以通过以下方式查看或替换内存管理器：

#include <memory>

// 获取当前内存管理器
IMemoryManager* oldMgr = MemoryManager;

// 自定义内存管理器示例
struct MyMemoryManager : public IMemoryManager {
    void* __stdcall Allocate(size_t size) override {
        return malloc(size);
    }

    void __stdcall Deallocate(void* p) override {
        free(p);
    }
};

MyMemoryManager myMgr;
MemoryManager = &myMgr;  // 设置自定义内存管理器

使用自定义内存管理器可以更好地控制内存分配策略，例如实现内存池、日志记录或性能监控。

7.2 内存泄漏检测与优化

7.2.1 使用调试工具检测内存泄漏

C++ Builder 提供了内置的内存泄漏检测工具，可以通过以下方式启用：

#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>

int main() {
    _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);

    int* p = new int[10];  // 故意不释放
    return 0;
}

运行程序后，如果存在内存泄漏，控制台将输出类似以下信息：

Detected memory leaks!
Dumping objects ->
{123} normal block at 0x004A1F50, 40 bytes long.
Data: <                > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.

此外，还可以使用第三方工具如 Valgrind（Linux） 、 Visual Leak Detector（Windows） 等进行更全面的内存分析。

7.2.2 避免内存碎片与提升分配效率

频繁地进行小块内存的申请和释放会导致内存碎片，影响性能。常见的优化策略包括：

• 使用内存池 ：预先分配大块内存，避免频繁调用 new/delete 。
• 对象复用 ：通过 std::deque 或自定义对象池管理对象生命周期。
• 对齐分配 ：确保内存对齐以提高缓存命中率。

以下是一个简单的内存池实现示例：

class MemoryPool {
private:
    std::vector<char*> blocks;
    size_t blockSize;
public:
    MemoryPool(size_t size) : blockSize(size) {}

    void* allocate() {
        char* block = new char[blockSize];
        blocks.push_back(block);
        return block;
    }

    void deallocateAll() {
        for (char* b : blocks)
            delete[] b;
        blocks.clear();
    }
};

7.3 资源释放与对象生命周期管理

7.3.1 智能指针的使用（如 std::unique_ptr 、 std::shared_ptr ）

C++11 引入了智能指针，能够自动管理资源生命周期，避免手动释放带来的内存泄漏问题。

#include <memory>

void useSmartPointer() {
    std::unique_ptr<MyClass> uptr(new MyClass());  // 独占所有权
    // 离开作用域时自动释放

    std::shared_ptr<MyClass> sptr1(new MyClass());
    std::shared_ptr<MyClass> sptr2 = sptr1;  // 引用计数增加
    // 当最后一个 shared_ptr 离开作用域时释放
}

智能指针类型	特性说明
unique_ptr	独占资源，不可复制，性能最优
shared_ptr	共享资源，引用计数控制生命周期
weak_ptr	观察 shared_ptr，防止循环引用

7.3.2 RAII 编程模式在资源管理中的应用

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期自动管理资源的技术。典型应用包括文件句柄、锁、网络连接等资源的自动释放。

class FileGuard {
private:
    FILE* fp;
public:
    FileGuard(const char* filename) {
        fp = fopen(filename, "r");
        if (!fp) throw std::runtime_error("Open file failed");
    }

    ~FileGuard() {
        if (fp) fclose(fp);
    }

    FILE* get() { return fp; }
};

void readFile() {
    FileGuard guard("test.txt");  // 构造即资源获取，析构自动释放
    // 读取文件操作
}

通过 RAII 模式，资源释放逻辑与对象生命周期绑定，极大提升了代码的安全性和可维护性。

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

简介：C++ Builder是由Embarcadero开发的集成开发环境，适用于Windows桌面及跨平台应用程序开发。本教程“C++Builder教程”包含从基础语法到高级应用的全面内容，涵盖环境配置、VCL界面设计、数据库连接、内存管理、多线程编程等关键技术点。压缩包内包含PDF、HTML或视频等教学资源，适合初学者和进阶开发者学习C++ Builder开发技能。

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