C++代码格式规范

海参崴-2026-04-06 13:00

C++代码格式规范

C++代码格式规范是提升代码可读性、可维护性、可扩展性的核心基础，也是团队协作开发的必备准则，更是专业开发者素养的直接体现。规范的代码格式并非"形式主义"，而是经过长期开发实践总结的实用准则------它不仅能让开发者快速理解代码逻辑、降低阅读与沟通成本，还能避免因格式混乱导致的语法隐患、逻辑误解，减少调试时间，同时便于后续代码的修改、迭代与多人协作维护。无论是个人独立开发，还是大型团队协同项目，统一的代码格式都能显著提升开发效率，保证代码质量的一致性，为项目长期稳定发展提供支撑。

本文将从命名规范、缩进与换行、注释规范、代码结构、特殊语法格式、文件组织、团队协作补充规范、常见格式错误及规避方法等核心维度，结合大量实例（正确示例+错误示例+详细解析），全面、细致地梳理C++代码格式的标准要求，兼顾通用性与实用性，覆盖基础语法、面向对象、模板编程、异常处理等各类C++开发场景。

一、命名规范（核心准则，贯穿全场景）

命名是代码格式的基础，也是代码可读性的首要保障。好的命名能让开发者仅通过名称就快速判断标识符的类型、用途与作用域，无需查看具体实现逻辑，从而大幅提升阅读效率。命名需严格遵循"清晰易懂、语义明确、统一风格、无歧义"的核心原则，杜绝模糊、随意的命名方式，同时区分变量、常量、函数、类、结构体、枚举等不同标识符的命名差异，避免出现"同名不同义""同义不同名"的混乱情况。

核心禁忌：禁止使用单字母命名（临时变量除外）、模糊缩写、中文命名、关键字命名，禁止大小写混用混乱，避免与标准库标识符重名，确保命名的唯一性与可读性。

1.1 变量命名

变量命名是最基础、最常用的命名场景，需结合变量的用途、类型，采用统一的命名风格，确保语义清晰、无歧义。

  • 基本原则：统一采用"驼峰命名法"（小驼峰），即首字母小写，后续每个单词的首字母大写，其余字母小写；语义上必须明确体现变量的用途、类型（可选），避免单字母命名（循环变量、临时变量除外），禁止使用无意义的缩写、拼音缩写（特殊场景约定除外）。
  • 补充说明：变量命名需简洁且全面，既不能过于冗长（避免堆砌无关词汇），也不能过于简略（避免语义模糊），尽量使用英文单词组合，不建议使用拼音、数字开头命名，禁止使用特殊符号（如下划线、@、#等）开头（全局变量除外，后续单独说明）。
  • 正确示例（含不同类型变量）：
cpp 复制代码 
// 基本数据类型变量
int studentAge;         // 语义明确，体现"学生年龄"，小驼峰命名
double totalScore;      // 体现"总分"用途，符合小驼峰规范
char userName;          // 清晰区分"用户姓名"，无歧义
bool isStudentValid;    // 布尔类型变量，前缀用is/has/has等，语义清晰
long long maxMemorySize;// 长整型变量，体现"最大内存大小"用途

// 临时变量（允许单字母命名）
for (int i = 0; i < 10; i++) { // 循环临时变量i，符合规范
    cout << i << endl;
}

// 数组变量
int studentScores[50];  // 体现"学生成绩数组"，语义明确
string courseNames[10]; // 体现"课程名称数组"，符合命名规范

// 指针变量（后缀可加ptr，可选）
int* pStudentAge;       // 指针变量，后缀加ptr，清晰区分
char* pUserName;        // 指针变量命名，语义与类型明确
  • 错误示例（详细解析错误原因）：
cpp 复制代码 
int a;                 // 错误：单字母命名，语义模糊，无法判断用途
double fs;             // 错误：缩写不明确，fs无法判断是"分数"还是"方式"
char UserName;         // 错误：首字母大写，不符合小驼峰规范
bool 1isValid;        // 错误：数字开头命名，不符合C++语法规则
int 学生年龄;          // 错误：中文命名，兼容性差，易出现编译问题
string @course;        // 错误：使用特殊符号@开头，禁止使用
int int;               // 错误：使用C++关键字命名，语法错误
  • 特殊场景说明：

  1. 临时变量：仅允许在循环、临时计算中使用单字母命名，如for循环中的i、j、k，函数内部临时存储的tmp（临时变量），但需确保同一作用域内不重复，且临时变量的生命周期尽量简短，避免跨作用域使用。
    示例：

    cpp 复制代码 
    // 临时变量tmp，用于临时存储计算结果
double tmp = studentAge * 0.8; 
// 循环临时变量i、j，无歧义
for (int i = 0; i < 5; i++) {

for (int j = 0; j < 3; j++) {

cout << i * j << endl;

}

}
2. 全局变量：全局变量需在小驼峰基础上，前缀加g_（区分局部变量），明确标识其作用域为全局，避免与局部变量重名，同时尽量减少全局变量的使用（避免内存泄漏、作用域混乱）。 示例： cpp

// 全局变量，前缀加g_，区分局部变量

int g_globalCount;

double g_averageScore;
3. 静态变量：静态变量（static修饰）需在小驼峰基础上，前缀加s_（区分普通变量、全局变量），明确其静态属性，避免与其他变量混淆。 示例： cpp

// 静态局部变量，前缀加s_

static int s_studentCount;

// 静态全局变量，前缀加s_，同时区分全局变量

static double s_totalIncome;

复制代码 
## 1.2 常量命名
常量（const修饰、#define定义）的命名需体现"不可修改"的属性，同时语义明确，便于开发者快速识别其为常量，避免与变量混淆。
- 基本原则：统一采用"全大写命名法"，单词之间用下划线分隔，语义上明确常量的用途、含义，禁止使用模糊命名，避免与变量、函数重名。
- 补充说明：
1.  const修饰的常量：遵循全大写+下划线分隔规则，若为类成员常量，可在前缀加k_（可选，区分类成员）；
2.  #define定义的宏常量：同样遵循全大写+下划线分隔，且宏常量的命名需更规范，避免缩写模糊，同时禁止定义无意义的宏常量；
3.  常量命名需尽量全面，体现常量的具体含义，避免使用"CONST1""NUM1"这类无意义的命名。
- 正确示例：
```cpp
// const修饰的普通常量，全大写+下划线分隔
const int MAX_STUDENT_NUM = 100;    // 最大学生数量，语义明确
const double PI = 3.1415926;        // 圆周率，通用常量命名
const string DEFAULT_USER_NAME = "guest"; // 默认用户名

// 类成员常量，前缀加k_（可选）
class Student {
public:
   const int k_MAX_SCORE = 100; // 类成员常量，前缀加k_
};

// #define定义的宏常量，全大写+下划线分隔
#define MIN_AGE 18                  // 最小年龄限制
#define MAX_MEMORY_SIZE 1024        // 最大内存大小（单位：MB）
#define COURSE_NAME "C++编程"
  • 错误示例：
cpp 复制代码 
const int maxStudentNum = 100;     // 错误：未采用全大写命名，与变量混淆
#define minAge 18                   // 错误：全小写，不符合常量命名规范
const double pi = 3.14;            // 错误：小写命名，无法快速识别为常量
#define NUM1 100                    // 错误：无意义命名，无法判断用途
const int 学生数量 = 50;           // 错误：中文命名，兼容性差
  • 特殊说明：
  1. 常量命名需避免与标准库常量重名，如不能定义"const int NULL = 0;"，避免覆盖标准库中的NULL宏；
  2. 宏常量的命名需更严谨，因为宏是预编译阶段替换，若命名模糊，容易导致替换错误，例如避免#define A 100这类无意义命名；
  3. 类成员常量若为静态常量（static const），可结合类命名规范，前缀加k_，同时保持全大写+下划线分隔。

1.3 函数命名

函数命名需体现"动作+用途"，语义明确，让开发者仅通过名称就能判断函数的功能的执行逻辑，同时遵循统一的命名风格，便于函数调用与维护。

  • 基本原则：采用"驼峰命名法"（大驼峰），即首字母大写，后续每个单词首字母大写，其余字母小写；命名格式优先为"动作动词+名词"，体现函数的执行动作与操作对象，避免模糊、无意义的命名。
  • 补充说明：
  1. 函数命名需简洁明了，避免过于冗长，同时覆盖函数的核心功能，例如"获取学生成绩"命名为getStudentScore，而非getTheScoreOfStudent；
  2. 函数名中避免使用缩写（除非是通用缩写，如getCPUUsage，CPU为通用缩写），禁止使用单字母、数字开头命名；
  3. 构造函数、析构函数遵循类命名规范（与类名一致），无需额外遵循"动作+名词"格式；
  4. 成员函数、全局函数、静态函数的命名风格统一，仅通过作用域区分，不改变命名格式。
  • 正确示例（含不同类型函数）：
cpp 复制代码 
// 全局函数，大驼峰，动作+名词
int GetStudentAge(int studentId) {
    return studentAgeMap[studentId];
}

// 类成员函数，大驼峰，体现功能
class Student {
public:
    // 构造函数，与类名一致
    Student(int age, string name) {
        this->studentAge = age;
        this->userName = name;
    }
    // 成员函数，动作+名词，语义明确
 void SetStudentScore(double score) {
        this->studentScore = score;
    }
    // 成员函数，获取功能
    double GetStudentScore() {
        return this->studentScore;
    }
};

// 静态函数，大驼峰命名
static bool CheckStudentValid(int studentId) {
    return studentId > 0 && studentId <= MAX_STUDENT_NUM;
}

// 通用缩写示例（允许）
double GetCPUUsage() {
    // 实现获取CPU使用率的逻辑
    return 0.0;
}
  • 错误示例：
cpp 复制代码 
// 错误：首字母小写，不符合大驼峰规范
int getStudentAge(int id) {
    return 0;
}

// 错误：命名模糊，无法判断函数功能
void Func1(int a) {
    // 无明确功能说明
}

// 错误：缩写不明确，fs无法判断是分数还是其他
double GetFs(int studentId) {
    return 0.0;
}

// 错误：数字开头命名，不符合语法规范
void 1CheckValid() {
}
  • 特殊场景说明：
  1. 析构函数：与类名一致，前缀加~，无需遵循"动作+名词"格式，例如class Student的析构函数为~Student()；
  2. 回调函数：命名可在末尾加Callback，明确其回调属性，例如void StudentScoreCallback(double score)；
  3. 工具函数：可在开头加Util，体现工具类功能，例如void UtilSortArray(int arr[], int length)。

1.4 类、结构体命名

类（class）、结构体（struct）是C++面向对象编程的核心载体，命名需体现其封装的内容、用途，遵循统一风格，便于开发者快速识别其作用。

  • 基本原则：采用"驼峰命名法"（大驼峰），首字母大写，后续每个单词首字母大写，其余字母小写；命名格式为"名词"或"名词短语"，体现封装的对象、功能，避免模糊、缩写不明确的命名。
  • 补充说明：
  1. 类命名需尽量体现其封装的实体，例如Student（学生）、Course（课程）、UserManager（用户管理），避免使用Class1、MyClass这类无意义命名；
  2. 结构体命名与类一致，因为结构体在C++中与类的语法差异不大，仅默认访问权限不同，命名风格保持统一；
  3. 若类、结构体为抽象类、基类，可在末尾加Base，明确其基类属性，例如BaseStudent、BaseCourse；
  4. 禁止使用关键字、标准库类名作为类、结构体名称，例如不能命名为class string、struct int。
  • 正确示例：
cpp 复制代码 
// 类命名，大驼峰，体现封装实体
class Student {
private:
    int studentAge;
    string userName;
public:
    void SetAge(int age) { studentAge = age; }
    int GetAge() { return studentAge; }
};

// 结构体命名，与类一致，大驼峰
struct Course {
    string courseName;
    double courseScore;
    int courseHour;
};

// 抽象基类，末尾加Base，明确属性
class BaseUser {
public:
    virtual void ShowInfo() = 0; // 纯虚函数，抽象类
};

// 派生类，命名体现继承关系（可选）
class StudentUser : public BaseUser {
public:
    void ShowInfo() override {
        // 实现逻辑
    }
};
  • 错误示例：
cpp 复制代码 
// 错误：首字母小写，不符合大驼峰规范
class student {
    // 实现代码
};

// 错误：命名模糊，无法判断封装内容
struct MyStruct {
    // 实现代码
};

// 错误：使用标准库类名作为结构体名称，冲突
struct string {
    // 实现代码
};

// 错误：缩写不明确，cls无法判断是类还是其他
class cls1 {
};

1.5 枚举命名

枚举（enum）命名分为枚举类型命名和枚举值命名，需区分二者的命名差异，避免混淆，同时体现枚举的用途、枚举值的含义。

  • 基本原则：
  1. 枚举类型命名：采用大驼峰命名法，首字母大写，后续单词首字母大写，命名格式为"枚举用途+Enum"（可选），体现枚举的类型；
  2. 枚举值命名：采用全大写命名法，单词之间用下划线分隔，语义明确，体现枚举值的具体含义，避免使用数字、单字母命名。
  • 补充说明：
  1. 枚举类型可加Enum后缀，便于快速识别为枚举，例如StudentStatusEnum；
  2. 枚举值命名需避免重复，同一枚举类型内的枚举值不能重名，不同枚举类型的枚举值尽量不重名（避免混淆）；
  3. 若枚举值为通用状态（如成功、失败），可在开头加枚举类型前缀，避免与其他枚举值混淆，例如STUDENT_STATUS_SUCCESS、STUDENT_STATUS_FAILED。
  • 正确示例：
cpp 复制代码 
// 枚举类型命名，大驼峰，加Enum后缀，体现用途
enum StudentStatusEnum {
    STUDENT_STATUS_ACTIVE,    // 学生状态：活跃，全大写+下划线
    STUDENT_STATUS_INACTIVE,  // 学生状态：不活跃
    STUDENT_STATUS_SUSPENDED, // 学生状态：暂停
    STUDENT_STATUS_GRADUATED  // 学生状态：毕业
};

// 枚举类型命名，不加Enum后缀（可选）
enum CourseType {
    COURSE_TYPE_MAJOR,        // 专业课程
    COURSE_TYPE_PUBLIC,       // 公共课程
    COURSE_TYPE_ELECTIVE      // 选修课程
};
  • 错误示例：
cpp 复制代码 
// 错误：枚举类型首字母小写，不符合大驼峰规范
enum studentStatus {
    active,          // 错误：枚举值未全大写，语义模糊
    1inactive,       // 错误：数字开头，语法错误
    suspended        // 错误：未全大写，不符合规范
};

// 错误：枚举值命名模糊，无法判断含义
enum Color {
    a, b, c          // 单字母命名，无意义
};

1.6 命名空间命名

命名空间（namespace）用于避免标识符冲突，尤其是在大型项目中，不同模块的标识符可能重名，通过命名空间可实现隔离。命名空间的命名需遵循简洁、明确的原则，体现模块功能。

  • 基本原则：采用大驼峰命名法，首字母大写，后续单词首字母大写，其余字母小写；命名需体现模块、项目或功能，避免模糊命名，禁止使用单字母、数字开头命名。
  • 补充说明：
  1. 命名空间可嵌套，嵌套命名空间的命名风格与顶层命名空间一致，体现层级关系，例如namespace School::Student；
  2. 避免使用与标准库命名空间重名（如std），禁止定义namespace std;（避免覆盖标准库）；
  3. 项目级命名空间可采用项目名称缩写（通用缩写），模块级命名空间采用模块名称，便于区分。
  • 正确示例：
cpp 复制代码 
// 项目级命名空间，大驼峰，体现项目名称
namespace CppCodeFormat {
    // 模块级命名空间，嵌套，体现层级
    namespace NamingSpecification {
        // 模块内的函数、变量
        void CheckVariableName() {
            // 实现逻辑
        }
    }
}

// 模块级命名空间，体现模块功能
namespace StudentManager {
 class Student {
        // 实现代码
    };
}
  • 错误示例：
cpp 复制代码 
// 错误：首字母小写，不符合大驼峰规范
namespace cppCodeFormat {
    // 实现代码
}

// 错误：命名模糊，无法判断模块功能
namespace MySpace {
    // 实现代码
}

// 错误：与标准库命名空间重名，冲突
namespace std {
    // 实现代码
}

1.7 其他标识符命名

除上述核心标识符外，C++中还有模板参数、宏函数、常量表达式等标识符，其命名也需遵循统一规范，避免混乱。

  1. 模板参数命名：采用大驼峰命名法，若为通用模板参数，可使用T、U、V等单字母（通用约定），若为具体模板参数，需体现其类型、用途，例如template ；
    示例：

    cpp 复制代码 
    // 通用模板参数，单字母约定
template <typename T>
T Max(T a, T b) {
    return a > b ? a : b;
}

// 具体模板参数，体现类型用途
template <typename StudentType>
class StudentList {
    // 实现代码
};

  2. 宏函数命名：与宏常量一致，采用全大写+下划线分隔，体现函数功能，避免模糊命名，例如#define GET_MAX(a, b) (a > b ? a : b)；
    示例：

    cpp 复制代码

#define GET_MIN(a, b) (a < b ? a : b) // 语义明确，符合规范

#define CALCULATE_SUM(a, b) (a + b) // 体现计算功能

复制代码 
3.  常量表达式（constexpr）：与const常量命名一致，全大写+下划线分隔，体现其不可修改的属性，例如constexpr int MAX_ARRAY_LENGTH = 100;
# 二、缩进与换行规范（提升可读性的关键）
缩进与换行是代码格式的"骨架"，规范的缩进能清晰体现代码的层级关系（如循环、条件、函数体、类体等），换行能避免代码过长导致的阅读不便，二者结合能让代码结构清晰、层次分明，减少阅读成本。
核心原则：统一缩进格式，避免混用不同缩进方式；合理换行，避免一行代码过长，确保每行代码逻辑单一、简洁。
## 2.1 缩进规范
- 基本原则：统一采用"4个空格缩进"（推荐），禁止使用制表符（Tab键）缩进，避免不同编辑器显示缩进不一致（制表符在不同编辑器中显示宽度不同，易导致格式混乱）；缩进仅用于体现代码层级，每增加一层层级，缩进一次（4个空格），层级减少时，减少相应缩进。
- 补充说明：
1.  缩进的层级场景：函数体内部、循环体（for、while、do-while）、条件语句（if、else if、else、switch）、类体内部、结构体内部、命名空间内部等，均需缩进；
2.  同一层级的代码，缩进一致，禁止出现缩进混乱（如有的缩进4个空格，有的缩进2个空格）；
3.  空行不缩进，注释的缩进与对应代码一致，避免注释缩进与代码脱节；
4.  若代码层级过深（超过5层），需考虑重构代码（如拆分函数），避免缩进过多导致的阅读不便。
- 正确示例：
```cpp
// 命名空间，无缩进（顶层标识符）
namespace StudentManager {
   // 类体，缩进4个空格（1层层级）
   class Student {
   private:
       // 类成员，缩进8个空格（2层层级）
       int studentAge;
       string userName;
public:
       // 构造函数，缩进8个空格
       Student(int age, string name) {
           // 函数体内部，缩进12个空格（3层层级）
           this->studentAge = age;
           this->userName = name;
       }
       // 成员函数，缩进8个空格
       void ShowInfo() {
           // 函数体内部，缩进12个空格
           cout << "姓名：" << this->userName << endl;
           cout << "年龄：" << this->studentAge << endl;
           // 条件语句，缩进12个空格
           if (this->studentAge >= 18) {
               // 条件语句内部，缩进16个空格（4层层级）
               cout << "已成年" << endl;
           } else {
               cout << "未成年" << endl;
           }
       }
   };
}

// 全局函数，无缩进
void PrintStudentInfo(Student student) {
   // 函数体内部，缩进4个空格
   cout << "学生信息：" << endl;
   // 循环语句，缩进4个空格
   for (int i = 0; i < 3; i++) {
       // 循环体内部，缩进8个空格
       cout << "第" << i + 1 << "条信息：" << endl;
   }
}
  • 错误示例：
cpp 复制代码 
// 错误：混用空格与制表符缩进，格式混乱
namespace StudentManager {
	// 制表符缩进，与空格缩进混用
    class Student {
    private:
      // 缩进2个空格，与其他成员缩进不一致
      int studentAge;
        string userName; // 缩进8个空格，混乱
    public:
        Student(int age, string name) {
        this->studentAge = age; // 无缩进，层级不清晰
            this->userName = name;
        }
    };
}

// 错误：缩进层级混乱
void PrintInfo() {
    cout << "信息" << endl;
    if (1) {
    cout << "条件成立" << endl; // 无缩进，层级不清晰
        for (int i = 0; i < 3; i++) {
    cout << i << endl; // 缩进不足，格式混乱
        }
}

2.2 换行规范

换行的核心目的是避免一行代码过长，确保阅读时无需横向滚动，同时让每行代码逻辑单一，便于理解和调试。换行需遵循"逻辑拆分、简洁清晰"的原则，禁止一行代码包含多个逻辑操作，禁止代码过长（建议每行不超过80-100个字符）。

  • 核心换行场景及要求：
  1. 关键字换行：if、else if、else、for、while、do、switch、case、default等关键字，后面需换行，关键字与括号之间留一个空格，括号内的表达式可根据长度换行；
  2. 函数换行：函数定义时，函数名与括号之间留一个空格，括号内的参数列表若过长，可换行，换行后与第一个参数对齐；函数体内部，每个逻辑操作换行，避免多个操作写在一行；
  3. 运算符换行：若表达式过长，可在运算符后换行，换行后与运算符前的变量对齐，避免在运算符前换行；
  4. 逗号分隔换行：参数列表、数组初始化等场景，若元素过多，可在逗号后换行，换行后与前一个元素对齐；
  5. 类、结构体、命名空间换行：类、结构体、命名空间的左括号后换行，右括号与左括号对齐（单独一行）；类成员、结构体成员之间，可根据逻辑换行分隔；
  6. 空行换行：不同逻辑块、不同函数、不同类之间，需用空行分隔，体现代码的逻辑划分，避免代码堆砌。
  • 正确示例（各场景）：
cpp 复制代码 
// 1. 关键字换行
if (studentAge >= 18
    && studentScore >= 60) { // 表达式过长，换行后与第一个条件对齐
    cout << "合格" << endl;
} else if (studentAge < 18
           && studentScore >= 60) {
    cout << "未成年合格" << endl;
} else {
 cout << "不合格" << endl;
}

// 2. 函数换行（参数过长）
void SetStudentInfo(int studentId,
                   string studentName,
                   double studentScore,
 bool isActive) { // 换行后与第一个参数对齐
    // 每个逻辑操作换行
    this->studentId = studentId;
    this->studentName = studentName;
    this->studentScore = studentScore;
    this->isActive = isActive;
}

// 3. 运算符换行
double total = studentScore1 + studentScore2
             + studentScore3 + studentScore4; // 运算符后换行，对齐

// 4. 逗号分隔换行
int studentIds[] = {
    1001,
    1002,
    1003,
    1004 // 最后一个元素可省略逗号
};

// 5. 类、结构体换行
class Course {
private:
    string courseName;
    double courseScore;
public:
    Course(string name, double score) {
        this->courseName = name;
        this->courseScore = score;
相关推荐
谢尔登2 小时前
【React】setState 触发渲染的流程
前端·react.js·前端框架
better_liang2 小时前
每日Java面试场景题知识点之-Redisson热门使用场景
java·redis·微服务·分布式锁·redisson·分布式系统
2301_792674862 小时前
java学习 day26
java
!停2 小时前
C++入门—初阶模板
开发语言·c++
so2F32hj22 小时前
拆解 OpenHands（14）--- Microagents
java·开发语言
明灯伴古佛2 小时前
面试：什么是可重入性？为什么 synchronized 是可重入锁？
java·jvm·面试
卓怡学长2 小时前
m307自习室预订座位管理分析与实现
java·spring boot·spring
Jp7gnUWcI2 小时前
C++ 内存避坑指南：如何用移动语义和智能指针解决“深拷贝”与“内存泄漏”
开发语言·c++
Arya_aa2 小时前
生猪养殖溯源系统前期准备与SpringBoot框架
java·spring boot
热门推荐
01GitHub 镜像站点02Qwen3.5-Omni与Qwen3.6模型全面解析（含测评/案例/使用教程）03OpenClaw 请求超时 llm request timed out 怎么解决？3 种方案实测，附完整排查流程04VMware Workstation Pro 17 虚拟机完整安装教程（2026最新）05【技术干货】Gemma 4 上手深度指南：本地多模态大模型的新基线06最新更新版本，OpenClaw v2026.4.2 深度解读剖析：Task Flow 重磅回归与安全架构的全面硬化07AI 编程效率翻倍：Superpowers Skills 上手清单 + 完整指南08纯 HTML/CSS/JS 实现的高颜值登录页，还会眨眼睛！少女心爆棚！092026年3月AI领域大事件：DeepSeek引领开源风暴10UV安装并设置国内源