本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：本文介绍了一个基于C++开发的小型实用工具，能够连接SQL Server数据库、执行数据查询，并将结果导出为Excel文件，同时支持雷达图的生成。该工具利用ODBC或ADO技术实现数据库通信，结合libxl等库进行Excel操作，并借助Qt、SFML或gnuplot等图形库绘制雷达图。适用于数据处理、报表自动化以及C++数据库和文件操作的学习实践，帮助开发者掌握实际项目中的多技术集成能力。

C++连接SQL Server数据库与Excel自动化导出实战指南

在现代企业级应用开发中，数据的持久化存储与高效访问是系统设计的核心环节之一。尤其是在金融、制造、电信等关键领域，对性能和稳定性的要求极为苛刻——这时候，C++的优势就凸显出来了。它不像Python那样“慢”，也不像Java那样“重”，而是以一种近乎裸金属的方式贴近硬件运行，同时又能通过丰富的库生态实现复杂功能。

而当我们面对的是SQL Server这样典型的商业关系型数据库时，问题来了： 如何让这个高性能语言既能安全可靠地读写数据，又能把结果漂亮地呈现给业务人员？

这正是我们今天要深入探讨的主题。我们将从底层通信协议讲起，穿越ODBC、cpp-odbc、sqlsrv三大技术栈，最终构建一个完整的“数据库查询 → 数据处理 → Excel报表生成 → 雷达图可视化”的闭环流程。整个过程不仅涉及代码实现，更包含架构思考、安全性考量以及工程落地的最佳实践。

准备好了吗？🚀 让我们一起揭开这场跨层协作的技术面纱！

想象一下这样的场景：你正在为一家大型制造企业开发生产监控系统。每分钟都有成千上万条设备状态记录被写入SQL Server数据库。管理层需要每天早上8点准时收到一份包含关键指标趋势分析的Excel报告，甚至希望看到各部门KPI对比的雷达图。

传统做法可能是用SSIS做ETL + SSRS出报表，但灵活性差、维护成本高；或者干脆写个Python脚本定时跑……可一旦并发量上来，性能瓶颈立刻显现。有没有一种方式，既能保证高速吞吐，又能灵活控制输出格式？

答案就是： C++ + 原生驱动 + 第三方库集成 。

为什么选择C++来做这件事？

  • ✅ 极致性能 ：相比解释型语言，编译后的二进制执行效率高出数倍；
  • ✅ 内存可控 ：避免GC停顿，适合长时间运行的服务；
  • ✅ 类型安全 ：编译期检查减少运行时错误；
  • ✅ 跨平台部署 ：Windows/Linux均可运行（配合UnixODBC）；
  • ✅ 深度集成能力 ：可直接调用Windows API、COM组件、DLL等底层资源。

当然，代价也很明显：学习曲线陡峭、容易出错、缺乏“开箱即用”的高级抽象。但我们可以通过良好的封装来弥补这些缺陷。

让我们先回到最根本的问题： C++是怎么跟SQL Server“对话”的？ 

graph TD
    A[应用程序] --> B[客户端驱动]
    B --> C[TDS协议传输]
    C --> D[SQL Server实例]
    D --> E[(数据存储)]

没错，这一切都始于 TDS（Tabular Data Stream）协议 —— 微软专为SQL Server设计的应用层通信协议。你可以把它理解为HTTP之于Web服务，只不过它是面向数据库请求/响应的二进制流协议。

所有上层技术（ODBC、OLE DB、ADO.NET）本质上都是对TDS的不同封装形式。而在C++世界里，我们最常见的入口就是 ODBC 。

ODBC：跨数据库时代的基石

如果你是一个老派开发者，一定听说过一句话：“学会ODBC，走遍天下都不怕。” 虽然有点夸张，但它确实道出了ODBC的核心价值： 标准化接口 + 多数据库兼容性 。

开放数据库互连（Open Database Connectivity, ODBC）是由微软主导制定的一套C API规范，目标是屏蔽不同数据库厂商之间的差异。只要你的数据库提供了ODBC驱动，理论上就能用同一套代码访问它。

比如：

  • SQL Server → ODBC Driver 17 for SQL Server
  • Oracle → Oracle in OraClient19c_home1
  • MySQL → MySQL ODBC 8.0 Driver
  • PostgreSQL → psqlODBC

是不是很诱人？但这背后也有代价：抽象层级越高，性能损耗越大。不过对于大多数企业应用来说，这点开销完全可以接受。

ODBC的分层架构解析

ODBC采用典型的四层模型：

组件 职责 示例
应用程序 发起SQL请求、处理结果 使用 SQLExecDirect 执行查询
驱动管理器 加载/卸载驱动、转发调用 odbc32.dll （Windows）或 unixODBC
数据源名称（DSN） 存储连接信息（服务器、端口、认证方式） “MySqlServerDSN”
驱动程序 实现具体数据库通信协议 msodbcsql17.dll

这个结构可以用一张图清晰表达：

graph TD
    A[C++ Application] --> B[ODBC Driver Manager]
    B --> C{Is DSN configured?}
    C -->|Yes| D[DSN Entry in Registry/File]
    C -->|No| E[DSN-less Connection String]
    D --> F[SQL Server ODBC Driver]
    E --> F
    F --> G[(SQL Server Instance)]

💡 小知识：你在Windows“ODBC数据源管理器”里配置的那个“系统DSN”，其实就是注册表里的一个键值对集合。驱动管理器会根据DSN名查找对应的驱动路径并加载 .dll 文件。

但问题是——现在谁还手动配DSN啊？特别是在Docker容器或CI/CD流水线中，根本没法弹窗让你点“添加数据源”。于是，“ DSN-less连接字符串 ”成了现代应用的事实标准。

如何用原生API连接SQL Server？

别急，我们马上动手写一段真正的C++代码。下面是一个使用ODBC API连接本地SQL Server的完整示例：

#include <sql.h>
#include <sqlext.h>
#include <iostream>

bool ConnectToSQLServer() {
    SQLHENV hEnv = nullptr;
    SQLHDBC hDbc = nullptr;
    SQLRETURN ret;

    // 1. 分配环境句柄
    ret = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv);
    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
        std::cerr << "Failed to allocate environment handle." << std::endl;
        return false;
    }

    // 2. 设置ODBC版本为3.x
    ret = SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
        std::cerr << "Failed to set ODBC version." << std::endl;
        SQLFreeHandle(SQL_HANDLE_ENV, hEnv);
        return false;
    }

    // 3. 分配连接句柄
    ret = SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc);
    if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) {
        std::cerr << "Failed to allocate connection handle." << std::endl;
        SQLFreeHandle(SQL_HANDLE_ENV, hEnv);
        return false;
    }

    // 4. 尝试连接（假设已配置DSN名为"TestDB"）
    SQLCHAR dsn[] = "TestDB";
    SQLCHAR user[] = "sa";
    SQLCHAR pass[] = "your_password";

    ret = SQLConnect(hDbc, dsn, SQL_NTS, user, SQL_NTS, pass, SQL_NTS);
    if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) {
        std::cout << "Connected to SQL Server successfully!" << std::endl;
    } else {
        std::cerr << "Connection failed with return code: " << ret << std::endl;
        ShowSQLError(SQL_HANDLE_DBC, hDbc);  // 自定义错误显示函数
        SQLFreeHandle(SQL_HANDLE_DBC, hDbc);
        SQLFreeHandle(SQL_HANDLE_ENV, hEnv);
        return false;
    }

    // 清理资源
    SQLDisconnect(hDbc);
    SQLFreeHandle(SQL_HANDLE_DBC, hDbc);
    SQLFreeHandle(SQL_HANDLE_ENV, hEnv);

    return true;
}

看着挺多？其实逻辑非常清晰：

  1. 🧱 先建“环境”（Environment Handle），这是所有ODBC操作的起点；
  2. ⚙️ 设置版本号，必须是 SQL_OV_ODBC3 才支持Unicode和现代特性；
  3. 🔗 再拿个“连接句柄”，相当于数据库会话；
  4. 🔑 最后调 SQLConnect 或 SQLDriverConnect 登录。

📌 注意：这里的 SQLRETURN 不是布尔值！常见返回码有：
- SQL_SUCCESS : 成功
- SQL_SUCCESS_WITH_INFO : 成功但有警告（如字段截断）
- SQL_ERROR : 出错了
- SQL_INVALID_HANDLE : 句柄无效（通常是前面某步失败了）

而且别忘了——每个 AllocHandle 都要配对 FreeHandle ，否则就会内存泄漏。这也是为什么很多人觉得原生ODBC“反人类”的原因：繁琐、易错、缺乏异常安全。

那有没有更好的办法？当然有！

拥抱现代化：cpp-odbc让一切变得优雅

社区早就意识到这个问题，于是出现了各种C++风格的ODBC封装库。其中 cpp-odbc 因其轻量、头文件-only、RAII友好等特点脱颖而出。

它的设计理念很简单： 把C风格的句柄操作变成符合现代C++习惯的对象模型 。

举个例子，上面那段几十行的连接代码，在cpp-odbc中可以简化为：

#include "cpp_odbc.h"

auto env = std::make_shared<cpp_odbc::environment>();
auto conn = env->make_connection("DRIVER={ODBC Driver 17 for SQL Server};SERVER=localhost;DATABASE=TestDB;UID=sa;PWD=pass;");

就这么两行！👏

不仅如此，它还内置了以下贴心功能：

  • ✅ 异常抛出代替返回码判断
  • ✅ 智能指针自动管理生命周期
  • ✅ 支持 std::string / std::vector 等STL容器
  • ✅ 类型映射：自动将SQL类型转为C++基本类型
  • ✅ 流式语法： .prepare().execute_select() 链式调用超顺滑

我们可以基于它封装一个线程安全的连接包装类：

class ConnectionWrapper {
private:
    std::unique_ptr<cpp_odbc::connection> conn_;

public:
    explicit ConnectionWrapper(const std::string& connectionString) {
        try {
            auto env = std::make_shared<cpp_odbc::environment>();
            conn_ = std::make_unique<cpp_odbc::connection>(env->make_connection(connectionString));
            std::cout << "Connection established via cpp-odbc." << std::endl;
        } catch (const std::exception& e) {
            throw std::runtime_error("Failed to connect: " + std::string(e.what()));
        }
    }

    bool is_valid() const {
        return conn_ && conn_->is_connected();
    }

    void execute_non_query(const std::string& sql) {
        auto stmt = conn_->make_statement();
        stmt->prepare(sql);
        stmt->execute_non_query();
    }

    std::vector<std::vector<cpp_odbc::column>> fetch_all(const std::string& sql) {
        auto stmt = conn_->make_statement();
        stmt->prepare(sql);
        auto result = stmt->execute_select();

        std::vector<std::vector<cpp_odbc::column>> rows;
        while (result->next_row()) {
            std::vector<cpp_odbc::column> row;
            for (size_t i = 0; i < result->get_column_count(); ++i) {
                row.push_back(result->get_column(i));
            }
            rows.push_back(row);
        }
        return rows;
    }
};

看，完全不用操心句柄释放，也不用手动查返回值。如果连接失败，直接抛异常，交给上层捕获即可。

更重要的是， 这种设计天然支持连接池雏形 ：多个 ConnectionWrapper 实例可以共享同一个 environment 对象，复用底层上下文资源。

生产级考虑：连接健康监测与自动重连

但在真实环境中，网络波动、数据库重启、防火墙策略变更都可能导致连接中断。你总不能让用户手动重启服务吧？

所以我们得加个“心跳检测”机制：

bool ping() {
    try {
        auto stmt = conn_->make_statement();
        stmt->prepare("SELECT 1");
        auto rs = stmt->execute_select();
        return rs->next_row();
    } catch (...) {
        return false;
    }
}

void ensure_connected(const std::string& connStr) {
    if (!is_valid() || !ping()) {
        std::cout << "Reconnecting..." << std::endl;
        conn_.reset();  // 显式析构旧连接
        auto env = std::make_shared<cpp_odbc::environment>();
        conn_ = std::make_unique<cpp_odbc::connection>(env->make_connection(connStr));
    }
}

然后配合一个定时器线程定期检查：

std::thread heartbeat([](ConnectionWrapper& cw, const std::string& cs) {
    while (true) {
        std::this_thread::sleep_for(std::chrono::seconds(30));
        cw.ensure_connected(cs);
    }
}, std::ref(conn), connectionString);

这样一来，哪怕中间断了几秒，也能自动恢复，对外表现为“无感知”。

性能王者：Microsoft SQL Server Native Client（sqlsrv）

说完了通用方案，我们来看看微软自家的“终极武器”—— SQL Server Native Client 。

虽然官方文档已经标记为“deprecated”，但在很多遗留系统中仍然广泛使用。它整合了ODBC和OLE DB的功能，并针对TDS协议做了深度优化，尤其擅长：

  • ✅ 批量插入（Bulk Copy API）
  • ✅ 快照隔离级别（Snapshot Isolation）
  • ✅ 异步IO操作
  • ✅ AlwaysOn可用组支持

可惜的是，它的编程接口基于COM，代码看起来有点“复古”：

#include <sqlncli.h>

ISQLServer* pServer = nullptr;
HRESULT hr = CoCreateInstance(CLSID_SQLServer, NULL, CLSCTX_INPROC_SERVER,
                              IID_ISQLServer, (void**)&pServer);
if (SUCCEEDED(hr)) {
    hr = pServer->Connect(L"localhost", L"sa", L"password");
    if (SUCCEEDED(hr)) {
        pServer->ExecuteNonQuery(L"INSERT INTO ...");
    }
    pServer->Release();
}

说实话，这种写法在2025年已经不太推荐了。✅ 更好的选择是继续使用 ODBC Driver 17+ ，它不仅性能接近原生客户端，还持续更新支持最新功能（比如TLS 1.3、Azure AD认证等）。

安全加固：别再硬编码密码了！

说到连接字符串，这里必须强调一点： 永远不要把用户名密码写死在代码里！

看看这段代码有多危险：

// ❌ 千万别这么干！
std::string connStr = "DRIVER={ODBC Driver 17 for SQL Server};SERVER=localhost;UID=sa;PWD=mysecretpassword;";

万一代码泄露，整个数据库就暴露了。

正确姿势应该是：

✔️ 方法一：环境变量注入

export DB_CONN_STR="DRIVER={ODBC Driver 17 for SQL Server};SERVER=localhost;UID=appuser;PWD=$(vault read -field=password secret/db)"

C++中读取：

char* connStrEnv = getenv("DB_CONN_STR");
if (!connStrEnv) {
    throw std::runtime_error("Missing DB_CONN_STR environment variable");
}
std::string connectionString = connStrEnv;

✔️ 方法二：Windows凭据管理器（Credential Manager）

利用DPAPI加密敏感信息：

#include <windows.h>
#include <dpapi.h>

BOOL EncryptData(const char* pData, DWORD len, BYTE** ppEncrypted, DWORD* pEncLen) {
    DATA_BLOB in, out;
    in.pbData = (BYTE*)pData;
    in.cbData = len;
    return CryptProtectData(&in, L"DB Password", nullptr, nullptr, nullptr, CRYPTPROTECT_UI_FORBIDDEN, &out);
}

✔️ 方法三：云密钥管理服务（如Azure Key Vault）

适用于混合云部署场景，结合AAD身份验证实现零信任架构。

总之， 纵深防御才是王道 。即使攻击者拿到了二进制文件，也无法轻易提取凭证。

查询执行与结果集处理：不只是fetch那么简单

连接上了，接下来自然是要执行SQL语句。

ODBC提供了两种主要方式：

  • SQLExecDirect() ：一次性执行静态SQL（适合简单查询）
  • SQLPrepare() + SQLExecute() ：预编译+参数绑定（防SQL注入、提升性能）

后者是我们强烈推荐的做法，尤其是当你需要多次执行相同SQL时：

SQLHSTMT hStmt;
SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt);

SQLPrepare(hStmt, (SQLCHAR*)"UPDATE employees SET salary = ? WHERE id = ?", SQL_NTS);

// 绑定参数
SQLLEN salaryLen = sizeof(double), idLen = sizeof(int);
double newSalary = 8000.0;
int empId = 1001;

SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &newSalary, 0, &salaryLen);
SQLBindParameter(hStmt, 2, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 0, 0, &empId, 0, &idLen);

// 执行
SQLExecute(hStmt);

看到了吗？问号占位符 + SQLBindParameter ，完美防止 ' OR 1=1 -- 这类注入攻击。

至于查询结果的获取，则依赖经典的游标模型：

while (SQLFetch(hStmt) == SQL_SUCCESS) {
    int id;
    char name[64] = {0};
    double salary;

    SQLGetData(hStmt, 1, SQL_C_LONG, &id, 0, NULL);
    SQLGetData(hStmt, 2, SQL_C_CHAR, name, sizeof(name), NULL);
    SQLGetData(hStmt, 3, SQL_C_DOUBLE, &salary, 0, NULL);

    printf("ID: %d, Name: %s, Salary: %.2f\n", id, name, salary);
}

SQLFetch 移动到下一行， SQLGetData 按列提取数据。注意列索引是从1开始的哦！

但如果你想构建一个通用的结果集处理器，就不能只靠固定结构体了。你需要动态获取元数据：

SQLSMALLINT colCount;
SQLNumResultCols(hStmt, &colCount);

for (int i = 1; i <= colCount; ++i) {
    SQLCHAR colName[128], typeName[32];
    SQLSMALLINT nameLen, decimalDigits, nullable;
    SQLULEN colSize;
    SQLSMALLINT dataType;

    SQLDescribeCol(hStmt, i, colName, sizeof(colName), &nameLen,
                   &dataType, &colSize, &decimalDigits, &nullable);

    SQLColAttribute(hStmt, i, SQL_DESC_TYPE_NAME, typeName, sizeof(typeName), nullptr, nullptr);

    std::cout << "Column " << i << ": "
              << colName << " (" << typeName << ", "
              << colSize << " chars)" << std::endl;
}

有了这些信息，你就可以动态决定如何展示每一列内容，比如日期自动居中、数字右对齐、文本换行等。

内存优化：大数据量下的分页与流式处理

当结果集达到百万级时，你还敢一次性全加载进内存吗？😱

std::vector<Row> resultSet;  // 几百MB甚至GB的堆内存占用？

显然不行。我们必须采取流式处理策略：

方案一：OFFSET-FETCH分页

SELECT id, name, salary 
FROM employees 
ORDER BY id 
OFFSET :offset ROWS FETCH NEXT :limit ROWS ONLY;

在C++中封装成迭代器模式：

class PagedResultIterator {
    size_t offset_, limit_, total_;
    size_t current_page_start_ = 0;
    std::vector<Row> current_page_;

public:
    bool next(Row& row) {
        if (current_page_.empty() || current_page_start_ >= offset_ + total_) {
            fetch_next_page();
        }
        if (!current_page_.empty()) {
            row = current_page_.back();
            current_page_.pop_back();
            return true;
        }
        return false;
    }
};

每页拉1000条，处理完再拉下一页，极大降低内存压力。

方案二：边查边写（Streaming Export）

更进一步，直接“查一条，写一条”到Excel：

while (SQLFetch(hStmt)) {
    Cell cells[3];
    SQLGetData(...); // 提取字段
    writer.writeRow(cells); // 实时写入文件
}

这种方式称为“流式导出”，特别适合定时任务生成日报、月报。

把数据变成报表：C++也能玩转Excel！

终于到了最激动人心的部分： 如何把冷冰冰的数据变成老板爱看的花哨报表？

目前主流的C++ Excel操作库有两个选择：

库名 是否收费 格式支持 特点
libxl 商业授权（免费版带水印） XLS/XLSX 高性能、样式丰富、支持公式图表
ExcelFormat 开源免费 XLS（仅旧格式） 轻量、无依赖、适合简单导出

我们以 libxl 为例，演示如何创建专业级报表：

#include "libxl.h"
using namespace libxl;

Book* book = xlCreateBook();
Sheet* sheet = book->addSheet(L"员工薪资表");

// 设置表头样式
Format* headerFmt = book->addFormat();
headerFmt->setFontBold(true);
headerFmt->setPatternBackgroundColor(Color(180, 200, 255));
headerFmt->setAlignH(ALIGNH_CENTER);

sheet->writeStr(0, 0, L"ID", headerFmt);
sheet->writeStr(0, 1, L"姓名", headerFmt);
sheet->writeStr(0, 2, L"薪资", headerFmt);

// 冻结首行 + 启用筛选
sheet->split(1, 0);
sheet->autoFilter(sheet->range(0, 0, 1000, 2));

// 写入数据
for (int i = 0; i < rowCount; ++i) {
    sheet->writeNum(i+1, 0, data[i].id);
    sheet->writeStr(i+1, 1, widen(data[i].name).c_str());
    sheet->writeNum(i+1, 2, data[i].salary);
}

// 自动调整列宽
adjustColumnWidth(sheet, data);

book->save(L"report.xlsx");
book->release();

瞧，不到50行代码，你就拥有了一个带筛选、冻结、自动列宽的专业表格。👍

可视化升级：用雷达图展示多维指标

光有表格还不够，领导们更喜欢“一眼看懂”的图表。比如部门KPI对比，最适合用 雷达图（Radar Chart） 来表现。

虽然 libxl 不支持内嵌图表（除非用OLE），但我们可以通过外部工具解决。

推荐方案：gnuplot命令行绘图

轻量、跨平台、无需GUI依赖，简直是自动化系统的最佳搭档。

先写个gnuplot脚本模板：

set terminal png size 800,600
set output 'radar.png'
set polar
set grid polar
set angles degrees
set size square
unset border
set style fill transparent solid 0.5

plot '-' using 1:2 with filledcurve lc rgb "red" title "Team A"
0 80
72 60
144 90
216 50
288 70
e

然后用C++动态生成并调用：

FILE* pipe = _popen("gnuplot", "w");
fprintf(pipe, "set terminal png; set output 'chart.png'; set polar; ...\n");

for (auto& pt : points) {
    double angle = 360.0 * i / n;
    fprintf(pipe, "%.1f %.1f\n", angle, value);
}
fprintf(pipe, "e\n");
fflush(pipe);
_pclose(pipe);

最后把生成的 chart.png 插入Excel：

sheet->insertPicture(5, 5, L"chart.png");

搞定！🎉

构建完整流水线：从数据库到最终报告

现在我们把所有模块串起来，形成一个端到端的数据管道：

graph TD
    A[连接SQL Server] --> B[执行SELECT查询]
    B --> C[解析结果集并结构化]
    C --> D[导出至Excel基础表格]
    D --> E[调用gnuplot生成雷达图]
    E --> F[将图像插入Excel]
    F --> G[保存最终报表.xlsx]

并且支持JSON配置驱动：

{
  "connection": "Driver={ODBC Driver 17 for SQL Server};Server=localhost;...",
  "query": "SELECT Dept, KPI1, KPI2, KPI3 FROM Performance",
  "excelOutput": "report/performance.xlsx",
  "charts": [
    {
      "type": "radar",
      "columns": ["KPI1", "KPI2", "KPI3"],
      "title": "部门绩效雷达图"
    }
  ]
}

通过 nlohmann/json 解析后，即可自动执行整个流程。

结语：C++依然强大，只是需要正确打开方式

回过头看，我们完成了一项看似不可能的任务：用C++实现了从数据库连接到Excel可视化的全链路自动化。

这其中的关键在于：

  • 🛠️ 选择合适的抽象层次：底层用ODBC保证兼容性，上层用cpp-odbc提升开发效率；
  • 🔐 重视安全性：绝不硬编码密码，优先使用环境变量或密钥管理服务；
  • 📈 关注性能与资源：大数据量采用分页或流式处理；
  • 🎨 提升用户体验：通过样式美化和图表增强报表可读性；
  • 🔄 实现自动化闭环：配置驱动 + 定时调度 = 真正的无人值守报表系统。

所以你看，C++并不是只能写算法题或操作系统内核。只要善用现代C++特性和优秀第三方库，它同样可以在企业级应用开发中大放异彩。

毕竟， 速度快、资源省、控制细——这才是工业级系统的终极追求 。💪

要不要试试看自己动手做一个？我已经迫不及待想看到你的第一个自动化报表了！😉

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：本文介绍了一个基于C++开发的小型实用工具，能够连接SQL Server数据库、执行数据查询，并将结果导出为Excel文件，同时支持雷达图的生成。该工具利用ODBC或ADO技术实现数据库通信，结合libxl等库进行Excel操作，并借助Qt、SFML或gnuplot等图形库绘制雷达图。适用于数据处理、报表自动化以及C++数据库和文件操作的学习实践，帮助开发者掌握实际项目中的多技术集成能力。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

AI Agent 评测指南（上）：从指标设计到准出标准

但上线一周后，用户反馈 Agent "有时候死循环""经常选错工具""10次里有3次任务没完成"。普通 LLM 评测只关心"回答好不好"。Agent 评测要关心"事有没有办成"——这中间多了工具调用、多步规划、错误恢复、SubAgent 协作。由于 Agent 的输出是非确定性的（不同路径可能都对），LLM-as-Judge 是做 Agent 评测最实用的方式。这是 Agent 评测的北极星指标—

avatar AI Agent技术社区

AI Agent 评测指南（下）：从指标设计到准出标准

Agent 评测的核心原则：1. 任务完成度是北极星指标不管 Agent 多聪明、工具用得多好，最终只看"事有没有办成"。2. 评测集必须覆盖端到端任务链不能只用"回答得好不好"来评测 Agent。需要完整的工具调用链、SubAgent 协作、错误恢复场景。3. 死循环和幻觉是 Agent 的红线这两项指标不能有任何妥协。死循环率必须为 0%，幻觉率必须持续压低。4. 按风险投入评测资源Promp

avatar AI Agent技术社区
cover

第一章：AI Agent概览：开启智能体时代

avatar AI Agent技术社区