windows上安装vs编写c++代码，大家一般都比较熟悉，但是，在ubuntu上编写c++代码，如何实现呢？我们可以使用vs code实现！本文博主带大家实现这个过程！

第一阶段：在您的Ubuntu训练机上安装并配置VSCode

第1步：打开终端
在Ubuntu系统中，按键盘上的 Ctrl + Alt + T 键，会弹出一个黑色（或白色）的窗口，这就是“终端”，相当于Windows的“命令提示符”或“PowerShell”。我们后续的所有安装命令都在这里输入。

第2步：安装VSCode
在终端中，逐行输入以下命令（每输入一行，按一次回车键）。系统可能会提示您输入用户密码，输入时屏幕不会有显示，输完直接回车即可。

# 1. 更新软件包列表
sudo apt update

# 2. 安装一些必要的依赖

sudo apt install -y software-properties-common apt-transport-https wget

# 3. 下载并安装微软的GPG密钥（用于验证软件）
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -o root -g root -m 644 packages.microsoft.gpg /etc/apt/trusted.gpg.d/

# 4. 将VSCode的仓库添加到系统软件源
echo "deb [arch=amd64 signed-by=/etc/apt/trusted.gpg.d/packages.microsoft.gpg] https://packages.microsoft.com/repos/vscode stable main" | sudo tee /etc/apt/sources.list.d/vscode.list

# 5. 再次更新软件包列表（此时已包含VSCode）
sudo apt update

# 6. 正式安装VSCode
sudo apt install -y code

安装完成后，您可以在Ubuntu的应用程序菜单中找到“Visual Studio Code”。

第3步：安装必要的VSCode扩展
打开VSCode，你会看到左侧有一个垂直的图标栏。

1. 点击第5个图标（一个方块叠在一起的形状），这就是 “扩展”商店。

2. 在搜索框中输入以下扩展名，分别安装：

   • 简体中文。
     

   • C/C++ (由Microsoft发布)：提供C++的智能提示、代码跳转、调试支持。
     

   • CMake Tools (由Microsoft发布)：这个非常重要，它能极大简化CMake项目的配置和编译，提供图形化按钮。
     

3. 安装完扩展后，建议重启一下VSCode。

第二阶段：创建项目并理解CMake（我们用它替代VS的“属性页”）

第0步：打开vs code
打开终端：cd到项目所在的文件夹中：

第1步：创建清晰的项目文件夹
在终端中，执行以下命令创建项目骨架：

# 创建一个总项目目录，名字您自己定，比如‘jetson_server_prototype’
mkdir -p jetson_server_prototype
# 进入这个目录
cd jetson_server_prototype

# 创建我们之前规划好的所有子文件夹和文件
mkdir -p include src models build
touch CMakeLists.txt
touch include/InferenceEngine.hpp
touch src/main.cpp

# 将您的模型文件（如 best.onnx）和 classes.txt 放入刚刚创建的 models/ 文件夹中
# 您可以通过图形界面直接拖进去，或者在终端用 cp 命令拷贝

现在您的文件夹结构应该是：

jetson_server_prototype/
├── CMakeLists.txt           # 项目构建的“总说明书”
├── build/                   # 编译产生的临时文件和最终程序放这里
├── models/
│   ├── best.onnx
│   └── classes.txt
├── include/
│   └── InferenceEngine.hpp
└── src/
    └── main.cpp

第2步：编写最简化的 CMakeLists.txt（请完全复制）
用VSCode打开整个 jetson_server_prototype 文件夹。然后打开并编辑 CMakeLists.txt 文件，输入以下内容：

# 1. 定义CMake最低版本和项目名
cmake_minimum_required(VERSION 3.16)
project(JetsonServer LANGUAGES CXX)

# 2. 设置C++标准为17
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 3. 告诉编译器去哪里找头文件（相当于VS的“附加包含目录”）
include_directories(
    ${CMAKE_SOURCE_DIR}/include   # 我们自己的头文件
    /usr/include/opencv4          # OpenCV的头文件
    /opt/onnxruntime/include      # ONNX Runtime的头文件
)

# 4. 告诉链接器去哪里找库文件（相当于VS的“附加库目录”）
link_directories(
    /opt/onnxruntime/lib          # ONNX Runtime的库文件所在目录
)

# 5. 查找OpenCV包（CMake会帮你自动设置OpenCV_INCLUDE_DIRS和OpenCV_LIBS）
find_package(OpenCV REQUIRED)

# 6. 添加我们要编译的可执行文件，并列出所有需要的.cpp源文件
add_executable(inference_server
    src/main.cpp
    # 未来您在这里添加其他.cpp文件，例如：
    # src/OnnxRuntimeEngine.cpp
    # src/NetServer.cpp
)

# 7. 为可执行文件链接必要的库（相当于VS的“附加依赖项”）
target_link_libraries(inference_server
    ${OpenCV_LIBS}                # 链接OpenCV的库
    onnxruntime                   # 链接ONNX Runtime库
    # pthread                      # 如果需要，可以链接线程库
)

# 8. 设置程序运行时查找动态库的路径（解决“找不到.so文件”的错误）
set_target_properties(inference_server PROPERTIES
    INSTALL_RPATH “/opt/onnxruntime/lib”
    BUILD_WITH_INSTALL_RPATH TRUE
)

第3步：配置、编译与调试 - 使用CMake Tools扩展
这是最关键的一步，让CMake像VS一样简单。

1. 在VSCode底部状态栏，你会看到一个类似“No Kit Selected”的按钮，点击它。
2. 在弹出的选择器中，VSCode通常会自动检测到你的GCC编译器，选择它（例如“GCC 11.4.0 x86_64-linux-gnu”）。
3. 选择后，VSCode会自动开始“配置”项目（读取CMakeLists.txt）。配置成功后，状态栏会出现“Debug”和一个播放三角按钮。
4. 编译：点击状态栏的播放三角按钮（或按 F7），VSCode就会在后台执行 cmake --build 命令，在 build/ 目录下编译出可执行文件 inference_server。所有编译信息会在“终端”面板显示。
5. 调试：按 F5 键，VSCode会启动调试。但此时你的 main.cpp 还是空的，我们需要先写点代码。

第三阶段：编写和验证一个最简单的“Hello World”服务端

第1步：填充 include/InferenceEngine.hpp

// InferenceEngine.hpp - 抽象接口
#ifndef INFERENCE_ENGINE_HPP
#define INFERENCE_ENGINE_HPP

#include <opencv2/opencv.hpp>
#include <vector>
#include <string>

struct DetectionResult {
    int classId;
    float confidence;
    std::string className;
    std::vector<float> bbox; // [x1, y1, x2, y2]
    DetectionResult(int id=-1, float conf=0.0, std::string name="")
        : classId(id), confidence(conf), className(name) {}
};

class InferenceEngine {
public:
    virtual ~InferenceEngine() = default;
    virtual bool initialize(const std::string& modelPath) = 0;
    virtual std::vector<DetectionResult> infer(const cv::Mat& image) = 0;
};

#endif // INFERENCE_ENGINE_HPP

第2步：编写一个用于测试的 src/main.cpp

#include <iostream>
#include <memory>
#include “InferenceEngine.hpp”
#include <opencv2/opencv.hpp>

// 创建一个“模拟”的推理引擎，用于验证架构
class DummyEngine : public InferenceEngine {
public:
    bool initialize(const std::string& modelPath) override {
        std::cout << “[DummyEngine] 初始化，模型路径: ” << modelPath << std::endl;
        // 这里可以模拟加载您的YOLO模型，但现在只打印
        return true; // 返回初始化成功
    }

    std::vector<DetectionResult> infer(const cv::Mat& image) override {
        std::cout << “[DummyEngine] 推理图像，尺寸: ” << image.cols << “x” << image.rows << std::endl;
        // 模拟返回一个检测结果
        std::vector<DetectionResult> results;
        results.emplace_back(0, 0.95f, “dummy_object”);
        results.back().bbox = {100, 100, 200, 200};
        return results;
    }
};

int main() {
    std::cout << “=== Jetson 服务端仿真项目启动 ===” << std::endl;

    // 1. 创建并初始化推理引擎
    std::unique_ptr<InferenceEngine> engine = std::make_unique<DummyEngine>();
    if (!engine->initialize(“./models/best.onnx”)) {
        std::cerr << “引擎初始化失败！” << std::endl;
        return -1;
    }

    // 2. 模拟一张图像（创建一个纯色图片）
    cv::Mat dummyImage(480, 640, CV_8UC3, cv::Scalar(50, 50, 50));

    // 3. 进行推理
    auto results = engine->infer(dummyImage);

    // 4. 打印结果
    std::cout << “检测到 ” << results.size() << “ 个目标：” << std::endl;
    for (const auto& res : results) {
        std::cout << “ - ” << res.className << “, 置信度: ” << res.confidence << std::endl;
    }

    std::cout << “=== 程序执行完毕 ===” << std::endl;
    return 0;
}

第3步：编译与运行

1. 在VSCode中，按 F7 进行编译。
2. 编译成功后，打开VSCode的集成终端（Ctrl + `` ）。
3. 在终端中，运行生成的可执行程序：

   cd ~/jetson_server_prototype
   ./build/inference_server
   

   您应该能看到程序成功运行，并打印出初始化、推理和结果信息。

下一步：将您的真实代码融入此框架

当上述“Hello World”项目成功运行后，您就可以开始真正的迁移工作了：

1. 将您现有的 YOLO11CLASS.h/cpp 文件 拷贝到 include/ 和 src/ 目录下。
2. 按照 DummyEngine 的示例，创建一个 OnnxRuntimeEngine 类，继承 InferenceEngine，并在其内部封装您原来的 YOLO11Classifier 对象。
3. 在 CMakeLists.txt 的 add_executable 和 target_link_libraries 部分，添加对新源文件和库的引用。
4. 在 main.cpp 中将 DummyEngine 替换为 OnnxRuntimeEngine。

至此，您已经在x86 Linux上，用VSCode和CMake搭建了一个与Visual Studio体验接近的、可扩展的C++服务端项目框架。后续的网络模块（如cpp-httplib）可以作为一个新的类逐步加入。当Jetson到货后，您只需要在Jetson上安装好VSCode，拉取这个项目代码，修改CMakeLists.txt中的头文件路径和库路径指向Jetson上的TensorRT，即可开始编译和部署。