# AlignAfterOpenBracket

当在括号后面换行时，后续行的缩进方式。

- **`Align`**: 这会将所有的后续行与打开括号对齐。例如：

  ```c++
  void function(int x, int y,
                int z);
  ```

- **`DontAlign`**: 这会使用标准的缩进（通常是缩进一级）来对齐后续行。例如：

  ```c++
  void function(int x, int y,
      int z);
  ```

- **`AlwaysBreak`**: 这会强制在括号后面换行，然后使用标准的缩进。例如：

  ```c++
  void function(
      int x, int y,
      int z);
  ```

- **`BlockIndent`**: 这会将括号后面的内容缩进一级，但不对齐到括号。例如：

  ```c++
  void function(int x, int y,
      int z);
  ```

- **`ContinuationIndent`**: 这会使用连续行的缩进。例如：

  ```c++
  void function(int x, int y,
          int z);
  ```

# AccessModifierOffset

控制 C++ 类中访问修饰符（如 `public`、`protected` 和 `private`）的缩进偏移量。

# AlignArrayOfStructures

控制数组中结构体的对齐方式。

这个选项有以下几个可能的值：

- **`None`**：不进行任何特殊对齐。结构体元素按照默认格式处理。例如：

  ```c++
  struct Point {
      int x;
      int y;
  };
  Point points[] = { {1, 2}, {3, 4}, {5, 6} };
  ```

- **`Left`**：将结构体数组中的元素向左对齐。例如：

  ```c++
  struct Point {
      int x;
      int y;
  };
  Point points[] = {
      { 1, 2 },
      { 3, 4 },
      { 5, 6 }
  };
  ```

- **`Right`**：将结构体数组中的元素向右对齐。例如：

  ```c++
  struct Point {
      int x;
      int y;
  };
  Point points[] = {
                    { 1, 2 },
                    { 3, 4 },
                    { 5, 6 }
  };
  ```

### AlignConsecutiveAssignments

控制连续赋值语句的对齐方式和相关行为。

- **`Enabled`**: 决定是否启用连续赋值对齐功能。
  - `true`: 启用连续赋值对齐。
  - `false`: 禁用连续赋值对齐。
- **`AcrossEmptyLines`**: 决定是否在跨越空行时也进行对齐。
  - `true`: 即使有空行，也对齐赋值语句。
  - `false`: 遇到空行时不对齐。
- **`AcrossComments`**: 决定是否在跨越注释行时也进行对齐。
  - `true`: 即使有注释行，也对齐赋值语句。
  - `false`: 遇到注释行时不对齐。
- **`AlignCompound`**: 决定是否对齐复合赋值运算符（如 `+=`、`-=` 等）。
  - `true`: 对齐复合赋值运算符。
  - `false`: 不对齐复合赋值运算符。
- **`PadOperators`**: 决定是否在赋值运算符两侧添加空格。
  - `true`: 在赋值运算符两侧添加空格。
  - `false`: 不在赋值运算符两侧添加空格。

# AlignConsecutiveBitFields

控制连续位域的对齐方式和相关行为。

- **`Enabled`**: 决定是否启用连续位域对齐功能。
  - `true`: 启用连续位域对齐。
  - `false`: 禁用连续位域对齐。
- **`AcrossEmptyLines`**: 决定是否在跨越空行时也进行对齐。
  - `true`: 即使有空行，也对齐位域。
  - `false`: 遇到空行时不对齐。
- **`AcrossComments`**: 决定是否在跨越注释行时也进行对齐。
  - `true`: 即使有注释行，也对齐位域。
  - `false`: 遇到注释行时不对齐。
- **`AlignCompound`**: 决定是否对齐复合位域（对于位域来说，这个选项通常没有意义）。
  - `true`: 对齐复合位域。
  - `false`: 不对齐复合位域。
- **`PadOperators`**: 决定是否在位域运算符两侧添加空格（对于位域来说，这个选项通常没有意义）。
  - `true`: 在位域运算符两侧添加空格。
  - `false`: 不在位域运算符两侧添加空格。

# AlignConsecutiveDeclarations

控制连续变量声明的对齐方式和相关行为。

- **`Enabled`**: 决定是否启用连续声明对齐功能。
  - `true`: 启用连续声明对齐。
  - `false`: 禁用连续声明对齐。
- **`AcrossEmptyLines`**: 决定是否在跨越空行时也进行对齐。
  - `true`: 即使有空行，也对齐声明。
  - `false`: 遇到空行时不对齐。
- **`AcrossComments`**: 决定是否在跨越注释行时也进行对齐。
  - `true`: 即使有注释行，也对齐声明。
  - `false`: 遇到注释行时不对齐。
- **`AlignCompound`**: 决定是否对齐复合声明（如指针、引用等）。
  - `true`: 对齐复合声明。
  - `false`: 不对齐复合声明。
- **`PadOperators`**: 决定是否在声明中的运算符（如 `*`、`&` 等）两侧添加空格。
  - `true`: 在运算符两侧添加空格。
  - `false`: 不在运算符两侧添加空格。

# AlignConsecutiveMacros

控制连续宏定义的对齐方式和相关行为。

- **`Enabled`**: 决定是否启用连续宏定义对齐功能。
  - `true`: 启用连续宏定义对齐。
  - `false`: 禁用连续宏定义对齐。
- **`AcrossEmptyLines`**: 决定是否在跨越空行时也进行对齐。
  - `true`: 即使有空行，也对齐宏定义。
  - `false`: 遇到空行时不对齐。
- **`AcrossComments`**: 决定是否在跨越注释行时也进行对齐。
  - `true`: 即使有注释行，也对齐宏定义。
  - `false`: 遇到注释行时不对齐。
- **`AlignCompound`**: 决定是否对齐复合宏定义（这个选项通常对宏定义没有明显效果）。
  - `true`: 对齐复合宏定义。
  - `false`: 不对齐复合宏定义。
- **`PadOperators`**: 决定是否在宏定义中的运算符两侧添加空格（这个选项通常对宏定义没有明显效果）。
  - `true`: 在运算符两侧添加空格。
  - `false`: 不在运算符两侧添加空格。

# AlignConsecutiveShortCaseStatements

控制连续的短 `case` 语句的对齐方式和相关行为。

- **`Enabled`**: 决定是否启用连续短 `case` 语句对齐功能。
  - `true`: 启用连续短 `case` 语句对齐。
  - `false`: 禁用连续短 `case` 语句对齐。
- **`AcrossEmptyLines`**: 决定是否在跨越空行时也进行对齐。
  - `true`: 即使有空行，也对齐短 `case` 语句。
  - `false`: 遇到空行时不对齐。
- **`AcrossComments`**: 决定是否在跨越注释行时也进行对齐。
  - `true`: 即使有注释行，也对齐短 `case` 语句。
  - `false`: 遇到注释行时不对齐。
- **`AlignCaseColons`**: 决定是否对齐 `case` 语句中的冒号。
  - `true`: 对齐 `case` 语句中的冒号。
  - `false`: 不对齐 `case` 语句中的冒号。

# AlignEscapedNewlines

控制在字符串和宏定义中的换行符（由反斜杠 `\` 表示）的对齐方式。

`AlignEscapedNewlines` 选项的值通常为布尔型：

- **`true`**: 启用换行符对齐，所有的换行符将会对齐在相同的列。
- **`false`**: 禁用换行符对齐，换行符的位置将保持原样，不进行对齐。

以下是一些示例，说明启用和禁用 `AlignEscapedNewlines` 选项时的效果：

### 示例代码

```c++
#define LONG_MACRO_DEFINITION part1 + \
                              part2 + \
                              part3

std::string longString = "This is a very long string that needs to be \
                          broken into multiple lines for better readability";
```

### 配置示例

#### 启用对齐

```yaml
#复制代码
AlignEscapedNewlines: true
```

启用后，反斜杠后的内容会对齐：

```cpp
#define LONG_MACRO_DEFINITION part1 + \
                              part2 + \
                              part3

std::string longString = "This is a very long string that needs to be \
                          broken into multiple lines for better readability";
```

#### 禁用对齐

```yaml
#复制代码
AlignEscapedNewlines: false
```

禁用后，反斜杠后的内容将不会对齐，保持原样：

```cpp
#define LONG_MACRO_DEFINITION part1 + \
    part2 + \
    part3

std::string longString = "This is a very long string that needs to be \
broken into multiple lines for better readability";
```

# AlignOperands

控制运算符对齐的方式。具体来说，它决定了当表达式跨多行时，运算符是否以及如何对齐，以提高代码的可读性。这个选项可以接受以下几个值：

- **`DontAlign`**: 不对齐运算符。每行根据自身的缩进规则进行缩进，不考虑对齐运算符。例如：

  ```cpp
  int result = a + b +
               c + d;
  ```

- **`Align`**: 对齐运算符。在每一行中，运算符将对齐到相同的列。例如：

  ```cpp
  int result = a + b
               + c + d;
  ```

- **`AlignAfterOperator`**: 运算符之后对齐。将每一行的操作数与前一行的运算符之后的位置对齐。例如：

  ```cpp
  int result = a + b
               + c + d;
  ```

### AlignTrailingComments

控制行尾注释的对齐方式。

### 选项说明

- **`Kind`**: 决定注释对齐的策略。
  - **`None`**: 不对齐行尾注释。
  - **`Align`**: 对齐所有的行尾注释到同一列。
  - **`Always`**: 总是对齐行尾注释，无论是否有其他配置。
- **`OverEmptyLines`**: 决定行尾注释是否在跨越空行时仍然对齐。
  - **`0`**: 不考虑空行，行尾注释对齐仅限于非空行。
  - **`1`**: 跨越一个空行后继续对齐。
  - **`2`**: 跨越两个空行后继续对齐。
  - **`n`**: 跨越 `n` 个空行后继续对齐。

# AllowAllArgumentsOnNextLine

控制是否允许在函数调用或函数声明中，将所有参数放在下一行。

### 选项说明

- `AllowAllArgumentsOnNextLine`
  - **`true`**: 允许将函数调用或函数声明中的所有参数放在下一行。这意味着如果参数太多，可以将所有参数移到下一行，以避免长行并提高代码的可读性。
  - **`false`**: 不允许将所有参数放在下一行。参数将保持在当前行或根据其他配置分布在多行中。

# AllowAllParametersOfDeclarationOnNextLine

控制是否允许在函数声明或定义中将所有参数放在下一行。

### 选项说明

- `AllowAllParametersOfDeclarationOnNextLine`
  - **`true`**: 允许将函数声明或定义中的所有参数放在下一行。这意味着如果参数列表太长，所有参数可以被移到下一行，以避免行过长并提高代码的可读性。
  - **`false`**: 不允许将所有参数放在下一行。参数将保持在当前行或根据其他格式化规则分布在多行中。

### AllowShortBlocksOnASingleLine

控制短块（例如，代码块、条件块等）是否可以放在单行上。

### 选项说明

- `AllowShortBlocksOnASingleLine`：
  - **`Always`**: 始终允许将短块（如 `if`、`for`、`while`、`switch` 语句的代码块）放在单行上。如果块的内容非常短，则可以不换行。
  - **`Never`**: 从不允许将短块放在单行上。即使块很短，也会强制换行，以提高代码的可读性。
  - **`InlineOnly`**: 仅在块内只有一行代码时允许将其放在单行上。对于包含多行的块，即使短，也会强制换行。

# AllowShortCaseLabelsOnASingleLine

控制 `switch` 语句中的 `case` 标签是否可以放在单行上。

### 选项说明

- `AllowShortCaseLabelsOnASingleLine`：
  - **`Always`**: 始终允许将短 `case` 标签放在单行上。如果 `case` 标签和对应的代码很短，它们可以放在同一行上。
  - **`Never`**: 从不允许将 `case` 标签放在单行上。即使 `case` 标签很短，也会强制换行，以提高代码的可读性。
  - **`InlineOnly`**: 仅当 `case` 标签和代码都非常短时允许将它们放在单行上。例如，当 `case` 标签内只有一条语句时，可以放在同一行上。

# AllowShortEnumsOnASingleLine

控制是否允许将短枚举（`enum`）定义放在单行上。

### 选项说明

- `AllowShortEnumsOnASingleLine`:
  - **`Always`**: 始终允许将短枚举定义放在单行上。如果枚举定义很短，它可以放在同一行上。
  - **`Never`**: 从不允许将枚举定义放在单行上。即使枚举定义很短，也会强制换行，以提高代码的可读性。
  - **`InlineOnly`**: 仅当枚举定义非常短时允许将它放在单行上。例如，当枚举只有一两个常量时，可以放在同一行上。

# AllowShortFunctionsOnASingleLine

控制短函数是否可以放在单行上。

### 选项说明

- `AllowShortFunctionsOnASingleLine`:
  - **`Empty`**: 仅当函数体为空时，允许函数定义在单行上。即使函数体为空，它也可以保持在同一行。
  - **`InlineOnly`**: 仅当函数体包含一条语句时，允许函数定义在单行上。例如，如果函数体仅包含一条简单语句（如 `return`），则可以将其放在单行上。
  - **`All`**: 始终允许将短函数体放在单行上。不管函数体的内容多短，函数定义都可以在单行上。
  - **`Never`**: 从不允许将短函数体放在单行上。即使函数体很短，也会强制换行，以提高代码的可读性。

# AllowShortIfStatementsOnASingleLine

控制是否允许短的 `if` 语句放在单行上。

### 选项说明

- `AllowShortIfStatementsOnASingleLine`:
  - **`Empty`**: 仅当 `if` 语句的代码块为空时，允许将其放在单行上。即使 `if` 语句体为空，也可以保持在同一行。
  - **`InlineOnly`**: 仅当 `if` 语句的代码块包含一条语句时，允许将其放在单行上。例如，如果 `if` 语句体仅包含一个简单的语句（如 `return`），则可以将其放在同一行上。
  - **`All`**: 始终允许将短的 `if` 语句放在单行上。不管 `if` 语句体的长度如何，都可以在单行上定义。
  - **`Never`**: 从不允许将 `if` 语句放在单行上。即使 `if` 语句很短，也会强制换行，以提高代码的可读性。

# AllowShortLambdasOnASingleLine

控制短 Lambda 表达式是否可以放在单行上。

### 选项说明

- `AllowShortLambdasOnASingleLine`:
  - **`Empty`**: 仅当 Lambda 表达式的代码体为空时，允许将其放在单行上。即使 Lambda 表达式体为空，也可以保持在同一行。
  - **`InlineOnly`**: 仅当 Lambda 表达式的代码体包含一条语句时，允许将其放在单行上。例如，如果 Lambda 表达式体仅包含一个简单的语句（如 `return`），则可以将其放在同一行上。
  - **`All`**: 始终允许将短 Lambda 表达式放在单行上。不管 Lambda 表达式体的长度如何，都可以在单行上定义。
  - **`Never`**: 从不允许将 Lambda 表达式放在单行上。即使 Lambda 表达式很短，也会强制换行，以提高代码的可读性。

# AllowShortLoopsOnASingleLine

控制短的循环语句是否可以放在单行上。

### 选项说明

- `AllowShortLoopsOnASingleLine`:
  - **`Empty`**: 仅当循环体为空时，允许将其放在单行上。即使循环体为空，也可以保持在同一行。
  - **`InlineOnly`**: 仅当循环体包含一条语句时，允许将其放在单行上。例如，如果循环体仅包含一个简单的语句（如 `continue` 或 `break`），则可以将其放在单行上。
  - **`All`**: 始终允许将短循环体放在单行上。不管循环体的内容多短，都可以在单行上定义。
  - **`Never`**: 从不允许将短循环体放在单行上。即使循环体很短，也会强制换行，以提高代码的可读性。

# AlwaysBreakAfterDefinitionReturnType

控制在函数定义时，返回类型与函数名之间是否始终强制换行。

### 选项说明

- `AlwaysBreakAfterDefinitionReturnType`:
  - **`true`**: 总是强制在函数返回类型和函数名称之间换行。这意味着返回类型将与函数名分开到不同的行上，以提高代码的可读性。
  - **`false`**: 不强制在函数返回类型和函数名称之间换行。返回类型和函数名可以在同一行上，这样代码将更紧凑。

# AlwaysBreakAfterReturnType

控制是否在函数返回类型与函数名之间始终强制换行。

### 选项说明

- `AlwaysBreakAfterReturnType`:
  - **`true`**: 总是强制在函数的返回类型和函数名之间换行。这意味着返回类型将与函数名分开到不同的行上，以提高代码的可读性。
  - **`false`**: 不强制在返回类型和函数名之间换行。返回类型和函数名可以在同一行上，这样代码将更紧凑。

# AlwaysBreakBeforeMultilineStrings

控制是否在多行字符串之前强制换行。

### 选项说明

- `AlwaysBreakBeforeMultilineStrings`:
  - **`true`**: 总是在多行字符串（`"""` 或 `R"("...")"`）之前强制换行。这意味着在多行字符串开始之前会添加一个换行符，以提高代码的可读性。
  - **`false`**: 不强制在多行字符串之前换行。多行字符串可以紧跟在前面的代码行上，使代码更加紧凑。

# AlwaysBreakTemplateDeclarations

控制是否在模板声明之前始终强制换行。这主要影响模板声明的格式，使其布局更符合特定的风格或可读性要求。

### 选项说明

- `AlwaysBreakTemplateDeclarations`:
  - **`true`**: 总是强制在模板声明之前换行。这意味着在模板声明的开头会有一个换行符，以提高代码的可读性。
  - **`false`**: 不强制在模板声明之前换行。模板声明可以紧跟在前面的代码行上，使代码更加紧凑。

# AttributeMacros

允许你指定一组宏名称，这些宏被视为属性宏，用于调整格式化行为。属性宏通常用来指定函数或变量的特性或属性，它们的格式化可以影响到代码的布局和风格。

### 选项说明

- `AttributeMacros`:
  - **类型**: 列表 (List)
  - **用途**: 允许你指定一个宏的列表，这些宏会被 ClangFormat 识别为属性宏，并在格式化时处理这些宏的格式。属性宏通常用于装饰函数或变量，或在代码中添加特定的属性标记。

### 配置示例

在你的 `.clang-format` 文件中，配置 `AttributeMacros` 选项如下：

```yaml
AttributeMacros:
  - __capability
```

### 解释

- `AttributeMacros`:
  - **`- __capability`**: 这个配置表明 `__capability` 是一个属性宏。在格式化过程中，ClangFormat 会识别这个宏并相应地处理它的格式化。

### 代码示例

假设你在代码中使用了 `__capability` 作为属性宏，如下所示：

```cpp
__capability int* ptr;
```

使用 `AttributeMacros` 配置后，`ClangFormat` 将会正确处理这个宏，并确保它按照指定的格式进行格式化。

### 配置的影响

指定属性宏可以帮助 `ClangFormat` 在格式化代码时正确处理这些宏，并保持代码的一致性。属性宏通常在代码中用于标记特定的特性或属性，确保它们的格式与其他代码部分保持一致。

### 总结

`AttributeMacros` 选项允许你指定宏列表，这些宏会被 ClangFormat 识别为属性宏，并按照配置进行格式化。通过设置这个选项，你可以确保代码中的属性宏按一致的风格进行处理。

# BinPackArguments

控制函数参数或函数调用中的参数是否应当进行打包到单行上。

### 选项说明

- `BinPackArguments`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否允许将函数调用或函数定义中的所有参数打包到单行上。这可以减少代码的行数，使代码更加紧凑。

# BinPackParameters

控制函数定义和函数声明中的参数是否应当进行打包到单行上。这主要影响函数参数的布局，使代码更紧凑或更具可读性。

### 选项说明

- `BinPackParameters`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否允许将函数参数打包到单行上。如果启用，将所有参数尽可能放在同一行，以减少代码的行数。如果禁用，参数将被分散到多行上，以提高可读性。

### BitFieldColonSpacing

控制位字段（bit field）声明中的冒号（`:`）两侧的空格。位字段用于定义结构体中的小整数位字段，这个选项有助于确保这些字段的格式一致。

### 选项说明

- `BitFieldColonSpacing`:
  - **类型**: 字符串 (String)
  - 可选值:
    - **`None`**: 不在冒号两侧添加任何空格。
    - **`Before`**: 在冒号之前添加一个空格，但冒号之后没有空格。
    - **`After`**: 在冒号之后添加一个空格，但冒号之前没有空格。
    - **`Both`**: 在冒号的两侧都添加空格。

# BraceWrapping

控制花括号（`{` 和 `}`）的换行和缩进方式。这个选项涉及到代码中各类结构（如类、函数、条件语句等）周围的花括号如何被格式化。以下是对你提供的配置的解释：

### `BraceWrapping` 配置详解

- **`AfterCaseLabel`**:

  - `true`: 在 

    ```
    case
    ```

     标签后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    switch (x) {
        case 1: {
            // code
            break;
        }
    }
    ```

- **`AfterClass`**:

  - `true`: 在类声明后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    class MyClass {
        // class members
    };
    ```

- **`AfterControlStatement`**:

  - `Always`: 在控制语句（如 if, for, while）后总是放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    if (condition) {
        // code
    }
  
- **`AfterEnum`**:

  - `true`: 在枚举声明后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    enum MyEnum {
        Value1,
        Value2
    };
    ```
  
- **`AfterExternBlock`**:

  - `true`: 在 

    ```cpp
    extern
    ```
    
     块后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    extern {
        // code
    }
    ```
  
- **`AfterFunction`**:

  - `true`: 在函数声明后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    void myFunction() {
        // function body
    }
    ```
  
- **`AfterNamespace`**:

  - `true`: 在命名空间声明后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    namespace MyNamespace {
        // code
    }
    ```
  
- **`AfterObjCDeclaration`**:

  - `true`: 在 Objective-C 声明（如类接口）后放置花括号时，花括号会放在新的行上。例如：

    ```objc
    @interface MyClass : NSObject {
        // instance variables
    }
    @end
    ```
  
- **`AfterStruct`**:

  - `true`: 在结构体声明后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    struct MyStruct {
        int a;
        int b;
    };
    ```
  
- **`AfterUnion`**:

  - `true`: 在联合体声明后放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    union MyUnion {
        int a;
        float b;
    };
    ```
  
- **`BeforeCatch`**:

  - `true`: 在 

    ```cpp
    catch
    ```
    
     语句之前放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    try {
        // code
    } catch (const std::exception& e) {
        // handle exception
    }
    ```
  
- **`BeforeElse`**:

  - `true`: 在 

    ```
    else
    ```
    
     语句之前放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    if (condition) {
        // code
    } else {
        // code
    }
    ```
  
- **`BeforeLambdaBody`**:

  - `false`

    : 在 Lambda 表达式的主体之前，花括号不会放在新的行上。例如：

    ```cpp
    auto lambda = []() { /* code */ };
    ```
  
- **`BeforeWhile`**:

  - `true`: 在 

    ```
    while
    ```
    
     语句之前放置花括号时，花括号会放在新的行上。例如：

    ```cpp
    while (condition) {
        // code
    }
    ```
  
- **`IndentBraces`**:

  - `true`: 花括号会根据其所属的结构进行缩进。例如：

    ```cpp
    void myFunction() {
        if (condition) {
            // code
        }
    }
    ```
  
- **`SplitEmptyFunction`**:

  - `true`: 空函数体会被分隔到不同的行上。例如：

    ```cpp
    void myFunction()
    {
    }
    ```
  
- **`SplitEmptyRecord`**:

  - `true`: 空记录（如类、结构体、枚举）的花括号会被分隔到不同的行上。例如：

    ```cpp
    struct MyStruct
    {
    };
    ```
  
- **`SplitEmptyNamespace`**:

  - `true`: 空命名空间的花括号会被分隔到不同的行上。例如：

    ```cpp
    namespace MyNamespace
    {
    }
    ```

### 总结

- `BraceWrapping` 选项用于控制各种代码结构后（如函数、类、条件语句等）的花括号换行方式。
- 启用的配置通常会在结构声明后强制花括号换行，以提高代码的可读性。
- 禁用的配置（如 `BeforeLambdaBody: false`）则保持紧凑的代码格式，适用于较短的结构体和函数体。

# BreakAfterAttributes

控制是否在属性（attributes）之后强制换行。属性通常用于为代码元素（如函数、类、变量等）添加元数据或修饰符，例如编译器指示符。

### 选项说明

- `BreakAfterAttributes`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否在属性之后强制换行。

# BreakArrays

控制数组初始化时的换行行为。

### 选项说明

- `BreakArrays`:
  - **类型**: 枚举值 (Enum)
  - 可选值:
    - **`False`**: 不换行，保持数组元素在一行上。
    - **`True`**: 每个数组元素换行。
    - **`Leave`**: 保持原始格式，不做更改。

# BreakBeforeBinaryOperators

控制二元运算符（如 `+`、`-`、`*`、`/` 等）在换行时的位置。具体来说，这个选项决定了在多行表达式中，二元运算符是放在行末还是行首。

### 选项说明

- `BreakBeforeBinaryOperators`:
  - **类型**: 枚举值 (Enum)
  - 可选值:
    - **`None`**: 不在二元运算符之前换行，而是在运算符之后换行。这意味着运算符将位于行末。
    - **`NonAssignment`**: 在非赋值运算符之前换行。
    - **`All`**: 在所有二元运算符之前换行，包括赋值运算符。

# BreakBeforeConceptDeclarations

用于控制 C++20 概念（concepts）声明时的换行行为。

### 选项说明

- `BreakBeforeConceptDeclarations`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定在 C++20 概念声明之前是否强制换行。

# BreakBeforeBraces

控制花括号 `{` 在各种结构（如函数、类、控制语句等）前的换行方式。这有助于规范代码风格，使其在项目中保持一致。

### 选项说明

- `BreakBeforeBraces`:
  - **类型**: 枚举值 (Enum)
  - 可选值:
    - **`Attach`**: 将花括号 `{` 与控制结构放在同一行。
    - **`Linux`**: 将花括号 `{` 放在控制结构的下一行，并符合 Linux 内核编码风格。
    - **`Mozilla`**: 将花括号 `{` 放在控制结构的下一行，并符合 Mozilla 风格指南。
    - **`Stroustrup`**: 将花括号 `{` 放在控制结构的下一行，并符合 Stroustrup 风格。
    - **`Allman`**: 将花括号 `{` 放在控制结构的下一行，并符合 Allman 风格。
    - **`Whitesmiths`**: 将花括号 `{` 放在控制结构的下一行，并缩进。
    - **`GNU`**: 将花括号 `{` 放在控制结构的下一行，并符合 GNU 风格。
    - **`WebKit`**: 将花括号 `{` 放在控制结构的下一行，并符合 WebKit 风格。

# BreakBeforeInlineASMColon

控制内联汇编代码中的冒号（`: `）之前是否应该换行。这对于编写内联汇编的代码时尤其重要，因为它影响了汇编指令和约束列表的可读性和格式化风格。

### 选项说明

- `BreakBeforeInlineASMColon`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定在内联汇编代码的冒号之前是否换行。

# BreakBeforeTernaryOperators

控制三元运算符（`?:`）在换行时的位置。三元运算符用于条件表达式，并且这种格式化选项可以显著影响代码的可读性和风格。

### 选项说明

- `BreakBeforeTernaryOperators`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定在三元运算符之前是否换行。

# BreakConstructorInitializers

构造函数初始化列表中的换行行为。这个选项决定了在构造函数的初始化列表中，是否在每个初始化项之前换行，从而影响代码的布局和可读性。

### 选项说明

- `BreakConstructorInitializers`:
  - **类型**: 枚举值 (Enum)
  - 可选值:
    - **`None`**: 不在构造函数初始化列表中的初始化项之前换行，保持在同一行上。
    - **`BeforeComma`**: 在初始化项之前换行，但在逗号前不换行。
    - **`AfterComma`**: 在初始化项之后换行。
    - **`Always`**: 在每个初始化项之前都换行。

# BreakInheritanceList

控制继承列表（即类继承列表）在换行时的行为。这决定了在类定义中继承基类的列表是保持在同一行上还是分行显示。

### 选项说明

- `BreakInheritanceList`:
  - **类型**: 枚举值 (Enum)
  - 可选值:
    - **`None`**: 不换行，所有继承基类保持在同一行上。
    - **`BeforeComma`**: 在继承列表中的每个基类之前换行，但在逗号前不换行。
    - **`AfterComma`**: 在继承列表中的每个基类之后换行。
    - **`Always`**: 在每个继承基类之前都换行。

# BreakStringLiterals

控制字符串字面量（string literals）在换行时的行为。

### 选项说明

- `BreakStringLiterals`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否允许在字符串字面量的内部进行换行。

# ColumnLimit

用于设置每行的最大列数限制。这项设置控制了代码的换行行为，确保代码不会超过指定的列数，从而提高代码的可读性和一致性。

### 选项说明

- `ColumnLimit`:
  - **类型**: 整数 (`0` 或正整数)
  - **用途**: 指定每行代码的最大列数限制。

# CommentPragmas

- 用于指定特定类型的注释（pragmas）应该如何格式化。这个选项主要用于处理代码中的特殊注释，特别是那些以 `#pragma` 开头的注释。通过配置 `CommentPragmas`，你可以控制这些特殊注释的格式化行为，确保它们与代码风格一致。

  ### 选项说明

  - `CommentPragmas`

    :

    - **类型**: 字符串列表 (Array of Strings)
    - **用途**: 指定在代码中遇到特定 `#pragma` 注释时的格式化行为。

  ### 配置示例

  #### 设置 `CommentPragmas` 以识别 `#pragma` 注释

  ```yaml
  CommentPragmas:
    - "clang format off"
    - "clang format on"
  ```

  在这种配置下，`clang-format` 会识别并处理这些特定的 `#pragma` 注释：

  - **`"clang format off"`**: 当遇到 `#pragma clang format off` 注释时，`clang-format` 将停止对接下来的代码行进行格式化，直到遇到 `#pragma clang format on` 注释。
  - **`"clang format on"`**: 当遇到 `#pragma clang format on` 注释时，`clang-format` 将恢复对代码行的格式化。

  ### 配置的影响

  - **`CommentPragmas` 配置项**: 允许配置特定的 `#pragma` 注释，以定义在这些注释前后的格式化行为。这对于在特定区域内禁用或启用格式化非常有用。
  - **格式化行为**: 根据 `CommentPragmas` 的设置，`clang-format` 会在遇到指定的 `#pragma` 注释时调整其格式化策略，确保特定注释区域可以保持原样格式化或按照设定规则进行格式化。

  ### 总结

  `CommentPragmas` 选项用于指定代码中遇到的特定 `#pragma` 注释的格式化行为。通过配置这一选项，可以控制在遇到特定注释时，`clang-format` 如何处理代码的格式化。这对于处理需要特别格式化处理的代码区域非常有用，例如禁用特定代码段的自动格式化。选择适当的 `CommentPragmas` 配置可以帮助保持代码的一致性，同时允许在特定情况下进行灵活的格式化处理。

# CompactNamespaces

用于控制命名空间（namespace）的格式化行为，特别是如何处理多层嵌套的命名空间。这个选项决定了命名空间的写法是紧凑还是分开显示。

### 选项说明

- `CompactNamespaces`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否将多层命名空间合并到一行，还是将每个命名空间分开显示。

# ConstructorInitializerIndentWidth

用于设置构造函数初始化列表的缩进宽度。这项设置影响构造函数初始化列表中的每个初始化项的缩进程度，从而提高代码的可读性和一致性。

### 选项说明

- `ConstructorInitializerIndentWidth`:
  - **类型**: 整数
  - **用途**: 设置构造函数初始化列表的缩进宽度（以空格为单位）。

# ContinuationIndentWidth

用于设置代码换行后续行的缩进宽度。这项设置控制了代码在换行后的缩进量，从而影响代码的对齐和可读性。

### 选项说明

- `ContinuationIndentWidth`:
  - **类型**: 整数
  - **用途**: 设置代码行换行后的缩进宽度（以空格为单位）。

# Cpp11BracedListStyle

用于控制 C++11 及更高版本的列表初始化的格式。这个选项影响使用大括号 `{}` 进行初始化时，列表项的布局和对齐方式。C++11 引入了列表初始化，允许使用大括号进行初始化，例如数组或类的成员初始化。

### 选项说明

- `Cpp11BracedListStyle`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制是否采用 C++11 列表初始化的特定格式。

# DerivePointerAlignment

用于控制指针和引用对齐的方式。这个选项决定了指针和引用操作符（`*` 和 `&`）的对齐规则，是否将它们与变量名对齐或与类型对齐。

### 选项说明

- `DerivePointerAlignment`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制是否根据指针或引用的类型和变量名的对齐方式自动推导对齐风格。

# DisableFormat

用于控制是否禁用 `clang-format` 对特定文件的格式化。这对于那些不希望自动格式化的文件非常有用。

### 选项说明

- `DisableFormat`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制是否禁用对特定文件的格式化。

# EmptyLineAfterAccessModifier

用于控制在访问修饰符（如 `public`、`protected` 和 `private`）之后是否强制插入一个空行。这项设置影响类成员的布局，特别是如何在访问修饰符之后组织代码，以提高代码的可读性。

### 选项说明

- `EmptyLineAfterAccessModifier`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制在访问修饰符之后是否插入一个空行。

# EmptyLineBeforeAccessModifier

用于控制在访问修饰符（如 `public`、`protected` 和 `private`）之前是否强制插入一个空行。这项设置影响类成员的布局，特别是如何在访问修饰符之前组织代码，以提高代码的可读性。

### 选项说明

- `EmptyLineBeforeAccessModifier`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制在访问修饰符之前是否插入一个空行。

# EmptyLineBeforeAccessModifier

用于控制在访问修饰符（如 `public`、`protected` 和 `private`）之前是否插入一个空行。这项设置用于优化代码布局，使得不同访问级别的成员之间更加分明，提高代码的可读性。

### 选项说明

- `EmptyLineBeforeAccessModifier`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制在访问修饰符之前是否插入一个空行。

# ExperimentalAutoDetectBinPacking

用于控制是否启用实验性的自动检测二进制打包（Bin Packing）功能。这个选项影响 `clang-format` 如何自动处理复杂表达式中的参数对齐，尤其是在长参数列表或初始化列表的情况下。

### 选项说明

- `ExperimentalAutoDetectBinPacking`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制是否启用实验性的自动检测二进制打包功能，以优化复杂表达式中的对齐方式。

# FixNamespaceComments

用于控制是否自动修复 C++ 代码中的命名空间注释。这项设置影响 `clang-format` 如何处理与命名空间相关的注释，以确保代码的注释风格一致且符合预期。

### 选项说明

- `FixNamespaceComments`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制是否自动修复命名空间相关的注释，使其符合格式化规范。

# ForEachMacros

用于指定需要特殊处理的宏，以确保在格式化时正确处理这些宏的语法。这个选项特别适用于处理 `foreach` 类的宏，这些宏通常用于迭代集合。

### 选项说明

- `ForEachMacros`:
  - **类型**: 列表（数组）格式
  - **用途**: 列出需要特别处理的 `foreach` 类型宏，以便 `clang-format` 能够正确格式化这些宏的用法。

# IfMacros

用于指定需要特殊处理的 `if` 类型宏。这些宏通常用于条件编译或控制流，并且可能需要特别处理以确保代码在格式化时符合预期。

### 选项说明

- `IfMacros`:
  - **类型**: 列表（数组）格式
  - **用途**: 列出需要特别处理的 `if` 类型宏，以便 `clang-format` 能够正确格式化这些宏的语法。

# IncludeBlocks

用于控制如何格式化包含文件（`#include`）的分组。这项设置影响 `clang-format` 如何组织和排列 `#include` 指令，以提高代码的可读性和一致性。

### 选项说明

- `IncludeBlocks`:
  - **类型**: 枚举类型
  - **可选值**: `None`, `Preserve`, `Merge`
  - **用途**: 控制 `#include` 指令的分组方式。

# IncludeCategories

用于定义和组织 `#include` 指令的分类规则。这些规则帮助 `clang-format` 确定如何对包含文件进行分组和排序。通过使用正则表达式，可以自定义包含文件的排序优先级和分类方式，以提高代码的整洁性和一致性。

### 选项说明

- `IncludeCategories`:
  - **类型**: 列表（数组）格式
  - **用途**: 定义 `#include` 指令的分类规则，以控制它们的排序和分组。

### 配置项详细说明

每个条目包含以下字段：

- **`Regex`**: 用于匹配 `#include` 指令的正则表达式。
- **`Priority`**: 分类的优先级，较低的值表示较高的优先级。
- **`SortPriority`**: 排序优先级，通常用于指定排序顺序。
- **`CaseSensitive`**: 是否区分大小写，`true` 表示区分，`false` 表示不区分。

# IncludeIsMainRegex

用于指定一个正则表达式，用于匹配 `#include` 语句中的文件名。如果文件名匹配这个正则表达式，ClangFormat 会将该 `#include` 语句视为“主”包含（main include），通常意味着在排序时会优先处理这些包含语句。

### 选项说明

- `IncludeIsMainRegex`:
  - **类型**: 字符串 (String)
  - **用途**: 指定一个正则表达式，用于匹配 `#include` 语句中的文件名。匹配这个正则表达式的 `#include` 语句将被视为主包含文件，这些文件通常会被优先排序或处理。

用于控制如何识别“主”源文件的选项，而不是处理 `#include` 语句的。以下是对 `IncludeIsMainSourceRegex` 的详细解释：

### `IncludeIsMainSourceRegex` 选项

- **用途**: 这个选项指定一个正则表达式，用于匹配源文件的名称。如果源文件的名称匹配这个正则表达式，该源文件会被视为“主”源文件。这通常用于格式化时的特定处理或排序，尽管 ClangFormat 本身并不直接使用这个选项来改变格式化结果。
- **类型**: 字符串 (String)

### 配置示例

假设你希望将 `main.cpp` 文件视为主源文件，可以这样配置：

```yaml
IncludeIsMainSourceRegex: "main\\.cpp"
```

在这种配置下，`main.cpp` 会被识别为主源文件。虽然 ClangFormat 本身可能不会直接在格式化过程中利用这个选项，但其他工具或脚本可能会基于这个配置进行特定的处理。

#### 另一个示例

如果你希望将所有以 `.test.cpp` 结尾的源文件视为主源文件，可以使用以下配置：

```yaml
IncludeIsMainSourceRegex: "\\.test\\.cpp$"
```

### 正则表达式语法

- **`\\.cpp$`**: 匹配所有以 `.cpp` 结尾的文件名。
- **`main\\.cpp`**: 精确匹配文件名为 `main.cpp` 的源文件。
- **`^.\*[Mm]ain\\.cpp$`**: 匹配以 `main.cpp` 结尾的文件名，允许文件名前有其他内容，并且 `main` 可以是 `main` 或 `Main`。

### 使用场景

`IncludeIsMainSourceRegex` 主要用于自定义工具链的处理，例如：

- **自定义工具**: 你可能会有自定义的工具或脚本来处理项目中的主源文件。
- **构建系统**: 你的构建系统可能会根据这个正则表达式决定如何处理或优先处理源文件。

### 总结

`IncludeIsMainSourceRegex` 选项允许你指定一个正则表达式来匹配主源文件。虽然 ClangFormat 自身可能不直接利用这个选项来改变格式化行为，但它可以用于其他工具或脚本来识别并处理主源文件。

# IndentAccessModifiers

用于控制类中访问修饰符（如 `public`, `protected`, `private`）的缩进方式。这有助于保持代码的清晰和一致性，特别是在有多个访问修饰符的类中。

### 选项说明

- `IndentAccessModifiers`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否缩进访问修饰符。如果设置为 `true`，则访问修饰符会按照指定的缩进级别进行缩进；如果设置为 `false`，则访问修饰符会与类的其他内容对齐，不进行额外的缩进。

# IndentCaseBlocks

用于控制 `switch` 语句中 `case` 和 `default` 标签的块（block）的缩进方式。这有助于保持代码的清晰和一致性，特别是在处理复杂的 `switch` 语句时。

### 选项说明

- `IndentCaseBlocks`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定 `case` 和 `default` 标签后面的代码块是否需要缩进。如果设置为 `true`，`case` 和 `default` 标签后面的块会进行缩进；如果设置为 `false`，这些块不会进行额外的缩进，而是与 `switch` 语句体对齐。

# IndentCaseLabels

控制 `switch` 语句中 `case` 和 `default` 标签的缩进方式。这有助于保持代码的清晰性和一致性，特别是在处理复杂的 `switch` 语句时。

### 选项说明

- `IndentCaseLabels`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定 `case` 和 `default` 标签的缩进方式。如果设置为 `true`，这些标签会按照指定的缩进级别进行缩进；如果设置为 `false`，这些标签不会进行额外的缩进，而是与 `switch` 语句对齐。

# IndentExternBlock

控制 `extern` 块的缩进方式。`extern` 块是指使用 `extern` 关键字定义的代码块，通常用于声明在其他文件中定义的变量或函数。

### 选项说明

- `IndentExternBlock`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否缩进 `extern` 块中的内容。如果设置为 `true`，`extern` 块中的内容会根据指定的缩进级别进行缩进；如果设置为 `false`，`extern` 块中的内容不会进行额外的缩进，而是与外部代码对齐。

# IndentGotoLabels

用于控制 `goto` 标签的缩进风格。`goto` 标签在 C++ 和 C 语言中用于直接跳转到代码的其他位置，通常在使用 `goto` 语句时会有标签的定义。

### 选项说明

- `IndentGotoLabels`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制 `goto` 标签的缩进方式。如果启用，该选项会影响标签的缩进风格。

# IndentPPDirectives

控制预处理指令的缩进风格。预处理指令（如 `#include`、`#define`、`#ifdef` 等）是在编译过程开始之前由预处理器处理的指令。配置 `IndentPPDirectives` 选项可以帮助您调整这些指令的缩进方式，从而提高代码的可读性和一致性。

### 选项说明

- `IndentPPDirectives`:
  - **类型**: 枚举类型
  - **可选值**: `None`, `AfterHash`, `BeforeHash`
  - **用途**: 定义如何缩进预处理指令。

# IndentRequiresClause

控制 C++20 中的 `requires` 子句的缩进方式。`requires` 子句用于指定模板的约束条件，这些条件用于控制模板实例化的有效性。

### 选项说明

- `IndentRequiresClause`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制 `requires` 子句的缩进风格。启用此选项将影响 `requires` 子句在模板中的排版方式。

# IndentWidth

控制代码缩进的宽度。缩进宽度决定了每级缩进的空格数，这有助于确保代码的一致性和可读性。`IndentWidth` 的设置影响整个代码的缩进，包括代码块、控制语句、函数定义等。

### 选项说明

- `IndentWidth`:
  - **类型**: 整数
  - **用途**: 指定每一级缩进所使用的空格数。通常用于设置代码的缩进宽度，以保持代码的一致格式。

# IndentWrappedFunctionNames

控制对换行函数名称的缩进风格。这个选项主要在函数名称很长，导致函数声明或定义需要换行时使用。它可以确保换行后的函数名称对齐一致，提高代码的可读性。

### 选项说明

- `IndentWrappedFunctionNames`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 控制换行后的函数名称的缩进方式。如果启用，它将影响函数名称换行后的对齐方式。

# InsertBraces

控制是否在特定的代码结构中插入大括号 `{}`。这个选项帮助管理代码风格，特别是对于单行代码块的处理。

### 选项说明

- `InsertBraces`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否在特定的代码结构中强制插入大括号 `{}`，即使代码块只有一行。这有助于增加代码的可读性和一致性，避免因缺少大括号而导致的潜在错误。

# InsertNewlineAtEOF

控制在文件末尾是否插入一个换行符。这有助于保持代码的规范性，并遵循某些编码标准或约定。

### 选项说明

- `InsertNewlineAtEOF`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否在文件的最后插入一个换行符。如果设置为 `true`，则 ClangFormat 会在文件末尾自动添加一个换行符；如果设置为 `false`，则不会添加额外的换行符。

# InsertTrailingCommas

控制是否在特定的代码结构中插入尾随逗号。尾随逗号是指在列表、数组或其他集合类型的最后一个元素后面加一个逗号。此选项有助于维护一致的代码格式，并在某些情况下简化代码的修改和版本控制。

### 选项说明

- `InsertTrailingCommas`:

  - **类型**: 字符串 (String)

  - 用途

    : 指定在哪些代码结构中插入尾随逗号。这个选项的值可以是以下之一：

    - `None`: 不在任何地方插入尾随逗号。
    - `Always`: 在所有适用的地方插入尾随逗号。
    - `AfterEach`: 在每个元素后面插入尾随逗号（即在数组和对象的最后一个元素之后也插入逗号）。
    - `AfterLast`: 仅在最后一个元素之后插入尾随逗号。
    - `AfterMultiline`: 在多行列表和数组的最后一个元素之后插入尾随逗号。
    - `BeforeFirst`: 在第一个元素之前插入尾随逗号（在大多数情况下不使用）。

# IntegerLiteralSeparator

用于控制整数字面量（integer literals）的分隔符和最小位数的配置。这个选项主要用于格式化整数字面量，使其更易读，尤其是对于较大的数字。它允许你为不同进制的整数字面量指定分隔符和最小位数要求。

### 选项说明

- `IntegerLiteralSeparator`:
  - **类型**: 对象 (Object)，包含多个子选项
  - **用途**: 控制如何为二进制、十进制和十六进制整数字面量插入分隔符，以及这些字面量的最小位数。

### 子选项说明

- **`Binary`**: 指定二进制整数字面量中的分隔符的位数。
- **`BinaryMinDigits`**: 指定二进制整数字面量中的最小位数。如果位数不足，会在前面填充零。
- **`Decimal`**: 指定十进制整数字面量中的分隔符的位数。
- **`DecimalMinDigits`**: 指定十进制整数字面量中的最小位数。如果位数不足，会在前面填充零。
- **`Hex`**: 指定十六进制整数字面量中的分隔符的位数。
- **`HexMinDigits`**: 指定十六进制整数字面量中的最小位数。如果位数不足，会在前面填充零。

# KeepEmptyLinesAtTheStartOfBlocks

用于控制在代码块（如函数体、类体、命名空间等）开始时是否保持空行。这个选项有助于管理代码的可读性和布局，特别是当你希望在代码块的开始部分保留一定的空行时。

### 选项说明

- `KeepEmptyLinesAtTheStartOfBlocks`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否在代码块的开始位置保留空行。如果设置为 `true`，则会保留空行；如果设置为 `false`，则会移除这些空行。

# KeepEmptyLinesAtEOF

控制是否在文件的末尾保留空行。这个选项有助于管理代码文件的末尾布局，特别是当你希望在文件末尾保留空行时。

### 选项说明

- `KeepEmptyLinesAtEOF`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否在文件的末尾保留空行。如果设置为 `true`，ClangFormat 会在文件末尾保留空行；如果设置为 `false`，则会移除这些空行。

# LambdaBodyIndentation

用于控制 Lambda 表达式体的缩进方式。Lambda 表达式是 C++11 引入的一种功能强大的特性，它允许在函数体内定义匿名函数。适当的缩进可以提高代码的可读性和一致性。

### 选项说明

- `LambdaBodyIndentation`:

  - **类型**: 字符串 (String)

  - 用途

    : 指定 Lambda 表达式体的缩进方式。选项的值可以是以下之一：

    - `None`: 不对 Lambda 表达式体进行额外的缩进。
    - `IndentBody`: 对 Lambda 表达式体进行额外的缩进。
    - `Block`: 将 Lambda 表达式体视为一个代码块，并按块缩进。

# LineEnding

用于指定源代码文件中使用的行结束符类型。这对于确保跨平台开发中的代码一致性和正确性非常重要，因为不同的操作系统使用不同的行结束符：

- **Windows** 使用回车加换行符（`\r\n`）
- **Unix/Linux** 使用换行符（`\n`）
- **Mac OS**（旧版本）使用回车符（`\r`）

### 选项说明

- `LineEnding`:

  - **类型**: 字符串 (String)

  - 用途

    : 指定源代码文件使用的行结束符类型。选项的值可以是以下之一：

    - `Unix`: 使用 Unix 风格的换行符（`\n`）。
    - `Windows`: 使用 Windows 风格的回车加换行符（`\r\n`）。
    - `Keep`: 保持文件中的现有行结束符，不进行更改。

# MacroBlockBegin

用于控制宏定义的开始块的格式化。宏定义在 C++ 代码中通常用于定义常量、宏函数或条件编译指令。在代码格式化时，正确地处理这些宏定义可以提高代码的可读性和一致性。

### 选项说明

- `MacroBlockBegin`:
  - **类型**: 字符串 (String)
  - **用途**: 指定如何格式化宏定义的开始块，特别是如何在宏的开始部分处理块的左大括号。

# MacroBlockEnd

用于控制宏定义的结束块的格式化。宏定义在 C++ 中用于定义常量、宏函数或条件编译指令，正确处理宏定义的结束部分有助于提高代码的可读性和一致性。

### 选项说明

- `MacroBlockEnd`:
  - **类型**: 字符串 (String)
  - **用途**: 指定如何格式化宏定义的结束块，特别是如何在宏的结束部分处理块的右大括号。

# MaxEmptyLinesToKeep

用于控制在代码块中最多保留的连续空行数。这有助于确保代码在保持一定可读性的同时不会出现过多的空行，从而保持代码的整洁和一致性。

### 选项说明

- `MaxEmptyLinesToKeep`:
  - **类型**: 整数 (`int`)
  - **用途**: 指定在代码块中连续空行的最大数量。ClangFormat 将会保留最多指定数量的空行，并移除多余的空行。

# NamespaceIndentation

用于控制命名空间的缩进方式。命名空间是 C++ 中用于组织代码的机制，适当的缩进有助于提高代码的可读性和结构清晰性。

### 选项说明

- `NamespaceIndentation`:

  - **类型**: 字符串 (String)

  - 用途

    : 指定命名空间的缩进方式。选项的值可以是以下之一：

    - `None`: 不对命名空间进行额外的缩进，保持与文件的其他部分对齐。
    - `Inner`: 对命名空间进行额外的缩进，使其内部内容缩进。
    - `All`: 对命名空间及其内部内容都进行额外的缩进，使其在整个文件中保持一致的缩进风格。

# SortIncludes

控制是否对包含的头文件进行排序。这个选项可以帮助保持代码的整洁和一致性，特别是在大型项目中，正确排序的包含文件有助于提高代码的可读性和可维护性。

### 选项说明

- `SortIncludes`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否对包含的头文件进行排序。如果设置为 `true`，ClangFormat 会自动对包含的头文件进行排序；如果设置为 `false`，则保持包含文件的原始顺序。

# StatementMacros

用于指定是否将宏定义视为语句。宏定义在 C++ 中通常用于定义常量、宏函数或条件编译指令。这个选项影响 ClangFormat 如何处理宏定义，使其在代码格式化时更具一致性和可读性。

### 选项说明

- `StatementMacros`:
  - **类型**: 布尔值 (`true` 或 `false`)
  - **用途**: 指定是否将宏定义视为语句。启用时，ClangFormat 会将宏定义的内容格式化为语句形式，考虑到宏定义的结构和缩进。禁用时，宏定义将按其原始形式进行格式化。

# WhitespaceSensitiveMacros

用于控制宏定义中空白字符的处理，特别是那些在宏中可能对格式化有影响的空白字符。这对于确保宏在格式化时保持一致性和可读性非常重要。

### 选项说明

- `WhitespaceSensitiveMacros`:
  - **类型**: 字符串数组 (Array of Strings)
  - **用途**: 指定哪些宏是空白字符敏感的。这些宏在格式化时会考虑其空白字符，以保持宏的可读性和一致性。可以通过指定宏的名称来影响 ClangFormat 如何处理这些宏。

# TabWidth

# UseTab

用于控制代码中是否使用制表符（Tab）来进行缩进，而不是使用空格。这个选项影响代码的格式化风格，特别是对代码缩进的处理。

### 选项说明

- `UseTab`:

  - **类型**: 字符串 (String)

  - 用途

    : 指定代码缩进时使用制表符还是空格。可以设置为以下值之一：

    - `Never`: 从不使用制表符，始终使用空格进行缩进。
    - `ForIndentation`: 使用制表符进行缩进，但其他位置的空白（如对齐操作）仍然使用空格。
    - `Always`: 始终使用制表符，包括缩进和对齐操作。