最近在研究代码格式的相关问题，之前在Linux平台有用过astyle命令，简单的运用。现在需要更加详细的应用，所以详细地学习一下。参考链接如下：
Artistic StyleArtistic Style is a source code indenter, source code formatter, and source code beautifier for the C, C++, C# and Java programming languages.https://astyle.sourceforge.net/astyle.html另外就是结合astyle -h来详细分析一下。
以上针对Linux平台，Windows平台是否适用没去研究，应该有一些共通的地方。安装的问题不具体讲了，apt-get install即可。下面直接开始！
我分享我总结使用的 cmd，具体含义可以在下面的文章里搜索到，基本也是来源于下面的表格：
astyle -A8 -t8 -p -H -U -k3 -xj -xB -xC80 -xL -n -r ".c" ".h"
表格中，我给出我觉得比较有用的几个option供大家参考！我觉得其实看这个表格就可以了，但是如果想要定制自己的 cmd，那就要看完下面的文章。
1 Usage
1.1 Command Line
命令行格式：
astyle [OPTIONS] SourceFilePath1 SourceFilePath2 SourceFilePath3 [ . . . ]
格式化单个文件的示例：
astyle --style=allman /home/project/foo.cpp
递归格式化C#文件的示例：
astyle --style=allman --recursive /home/project/*.cs
1.2 File Extensions
如果用逗号或分号（分号在某些版本可能不支援）分隔，则可以使用多个文件扩展，使用的扩展数量没有限制。
使用多个文件扩展名递归格式化 C++ 文件的示例：
astyle --style=allman --recursive /home/project/*.cpp,*.h
1.3 Redirection
< 和 > 字符可用于将文件重定向到标准输入 (stdin) 和标准输出 (stdout) - 不要忘记它们！使用此选项，一次只能格式化一个文件。无法识别通配符，没有控制台消息，并且不会创建备份。在 Windows 上，输出始终以 Windows 行结尾。 可以使用选项“stdin=”和“stdout=”来代替重定向。
用于格式化单个文件并更改名称的重定向选项示例：
astyle --style=allman < OriginalSourceFile > BeautifiedSourceFile
使用“stdin=”和“stdout=”格式化单个文件并更改名称的重定向示例：
astyle --style=allman --stdin=OriginalSourceFile --stdout=BeautifiedSourceFile
重定向选项可用于显示格式化文件而不更新：
astyle --style=allman < OriginalSourceFile | less
2 Options
长选项
这些选项以“--”开头，并且必须一次写入一个。
（示例：'--style=allman --indent=spaces=4'）
短选项
这些选项以单个“-”开头，并且可以连接在一起。
（例如：“-bps4”与“-b -p -s4”相同。）
PS：Option Files和Disable Formatting略
3 Basic Brace Styles
有三种基础大括号样式。
Attached：大括号附加到前一个块的最后一行的末尾。
Broken：大括号和前一个块分开。
Linux：除了函数、类或者namespace的左大括号外，其他的都采用attached。
4 Brace Style Options
大括号样式选项定义要使用的大括号样式。所有选项默认每个缩进 4 个空格，以空格缩进。默认情况下，没有任何样式缩进命名空间。 其他缩进在单独的样式描述中指出。 所有选项都将打破一行块的大括号并打破一行语句。要更改此设置，请使用格式选项部分中描述的选项 keep-one-line-blocks 和/或 keep-one-line-statements。下面会列举一些style，也会适当略去一些。
default brace style
如果没有请求大括号样式，则将使用默认的大括号样式。 左大括号不会改变，右大括号将从前一行断开。 但也有一些例外。
--style=allman / --style=bsd / --style=break / -A1
Allman style 使用 broken大括号.
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}
--style=java / --style=attach / -A2
Java style 使用 attached 大括号.
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
} else
return 0;
}
--style=kr / --style=k&r / --style=k/r / -A3
Kernighan & Ritchie 风格使用 Linux 大括号。 左大括号从命名空间、类和函数定义中断开。 大括号附加到其他所有内容，包括数组、结构、枚举和函数内的语句。
由于 &，使用 k&r 选项可能会导致问题。 这可以通过将 k&r 用引号括起来（例如 --style="k&r"）或使用替代方案之一 --style=kr 或 --style=k/r 来解决。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}
--style=stroustrup / -A4
Stroustrup 风格使用 Linux 大括号。 仅从函数定义中断开左大括号。 左大括号附加到其他所有内容，包括函数中的命名空间、类、数组、结构、枚举和语句。 结束标头从右大括号中断开（例如 --break-closing-headers）。 此样式经常与 attach-closing-while、制表符缩进和 5 个空格的缩进一起使用。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
}
else
return 0;
}
--style=linux / --style=knf / -A8
Linux 风格使用 linux 大括号。 左大括号从命名空间、类和函数定义中断开。 大括号附加到其他所有内容，包括数组、结构、枚举和函数内的语句。 最小条件缩进是二分之一缩进。 如果您想要不同的最小条件缩进，请改用 K&R 样式。 这种样式最适合大缩进。 它经常与 8 个空格的缩进一起使用。
也称为内核范式 (KNF) 样式，这是 Linux BSD 内核中使用的样式。
int Foo(bool isBar)
{
if (isFoo) {
bar();
return 1;
} else
return 0;
}
5 Tab Options
以下示例显示空白字符。 空格用 .（点）表示，制表符由 >（大于）表示。
default indent
如果未设置缩进选项，则将使用 4 个空格的默认选项（例如 -s4 --indent=spaces=4）。
with default values:
void Foo() {
....if (isBar1
............&& isBar2) // 该行的缩进可以使用 min-conditional-indent 进行更改
........bar();
}
--indent=spaces / --indent=spaces=# / -s#
每次缩进使用 # 个空格来缩进（例如 -s3 --indent=spaces=3）。 # 必须介于 2 和 20 之间。不指定 # 将导致每个缩进默认为 4 个空格。
with indent=spaces=3
void Foo() {
...if (isBar1
.........&& isBar2)
......bar();
}
--indent=tab / --indent=tab=# / -t / -t#
缩进使用 Tab 进行缩进，使用空格进行连续行对齐。 这可以确保无论查看者的选项卡大小如何，代码都能正确显示。 将每个缩进视为 # 空格（例如 -t6 / --indent=tab=6）。 # 必须介于 2 和 20 之间。如果未设置 #，则将缩进视为 4 个空格。
with indent=tab:
void Foo() {
> if (isBar1
> ........&& isBar2) // 该行的缩进可以使用 min-conditional-indent 进行更改
> > bar();
}
with style=linux, indent=tab=8:
void Foo()
{
> if (isBar1
> ....&& isBar2) // indent of this line can NOT be changed with style=linux
> > bar();
}
--indent=force-tab / --indent=force-tab=# / -T / -T#
如果可能的话，使用所有制表符缩进。 如果连续行不是偶数个制表符，则会在末尾添加空格。 将每个制表符视为 # 空格（例如 -T6 / --indent=force-tab=6）。 # 必须介于 2 和 20 之间。如果未设置 #，则将制表符视为 4 个空格。
with indent=force-tab:
void Foo() {
> if (isBar1
> > > && isBar2)
> > bar();
}
--indent=force-tab-x / --indent=force-tab-x=# / -xT / -xT#
此强制制表符选项允许将制表符长度设置为与缩进长度不同的长度。 这可能会导致缩进是制表符和空格的混合。 如果可能的话，制表符将用于缩进。 如果无法使用制表符缩进，则将使用空格代替。
该选项设置制表符长度。 将每个制表符视为 # 空格（例如 -xT6 / --indent=force-tab-x=6。# 必须介于 2 到 20 之间。如果未设置 #，则将制表符视为 8 个空格。要从 默认为 4 个空格，还必须使用选项“indent=force-tab”。
with indent=force-tab-x (default tab length of 8 and default indent length of 4):
void Foo() {
....if (isBar1
> ....&& isBar2)
> bar();
}
6 Brace Modify Options
--attach-namespaces / -xn
将大括号附加到命名空间语句。 无论使用何种大括号样式，都会执行此操作。 它还会将大括号附加到 CORBA IDL 模块语句。
大括号始终附加到名称空间语句：
namespace FooName {
...
}
--attach-classes / -xc
将大括号附加到类语句上。 无论使用何种大括号样式，都会执行此操作。
class FooClass {
...
};
--attach-inlines / -xl
将大括号附加到类和结构内联函数定义。 此选项优先于除 Horstmann 和 Pico（运行样式）之外的所有样式。 它仅对 C++ 文件有效。
class FooClass
{
void Foo() {
...
}
};
--attach-extern-c / -xk
将大括号附加到带大括号的 extern "C" 语句。 无论使用何种大括号样式，都会执行此操作。 此选项仅对 C++ 文件有效。
作为函数定义一部分的 extern“C”语句根据请求的大括号样式进行格式化。 带大括号的 extern "C" 语句不受大括号样式的影响，此选项是更改它们的唯一方法。
此选项将大括号附加到带大括号的 extern "C" 语句：
#ifdef __cplusplus
extern "C" {
#endif
但函数定义是根据请求的大括号样式进行格式化的：
extern "C" EXPORT void STDCALL Foo()
{}
--attach-closing-while / -xV
将“do-while”语句的结束“while”附加到右大括号。 这优先于大括号样式和断开右大括号选项。
do
{
bar();
++x;
}
while x == 1;
becomes:
do
{
bar();
++x;
} while x == 1;
7 Indentation Options
--indent-classes / -C
缩进“class”和“struct”块，以便缩进整个块。 仅当在结构中的某处声明了访问修饰符“public:”、“protected:”或“private:”时，结构块才会缩进。 此选项仅对 C++ 文件有效。（我感觉这个好象没什么必要= =）
class Foo
{
public:
Foo();
virtual ~Foo();
};
becomes:
class Foo
{
public:
Foo();
virtual ~Foo();
};
--indent-modifiers / -xG
缩进“class”和“struct”访问修饰符、“public:”、“protected:”和“private:”，缩进一半。 类的其余部分没有缩进。 此选项仅对 C++ 文件有效。 如果与缩进类一起使用，此选项将被忽略。
class Foo
{
public:
Foo();
virtual ~Foo();
};
becomes:
class Foo
{
public:
Foo();
virtual ~Foo();
};
--indent-switches / -S
缩进“switch”块，以便“case X:”语句在 switch 块中缩进。 整个 case 块都是缩进的。（不要缩进啊喂！）
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
becomes:
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
--indent-cases / -K
从“case X:”标题中缩进“case X:”块。 未包含在块中的 Case 语句不缩进。
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
becomes:
switch (foo)
{
case 1:
a += 1;
break;
case 2:
{
a += 2;
break;
}
}
--indent-namespaces / -N
向命名空间块添加额外的缩进。 该选项对 Java 文件没有影响。 它还将缩进 CORBA IDL 模块语句。（这个我觉得要的）
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
becomes:
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
--indent-after-parens / -xU
在包含左括号“(”或赋值“=”的行后面缩进，而不是对齐。这包括函数定义和声明以及返回语句。可以使用以下 indent-continuation 选项修改缩进。对于显示比例字体的编辑器来说，该选项可能是首选。
void Foo(bool bar1,
bool bar2)
{
isLongFunction(bar1,
bar2);
isLongVariable = foo1
|| foo2;
}
becomes:
void Foo(bool bar1,
bool bar2)
{
isLongFunction(bar1,
bar2);
isLongVariable = foo1
|| foo2;
}
--indent-continuation=# / -xt#
设置以左括号“(”或赋值“=”结尾的行的连续缩进。这包括函数定义和声明。它还将修改之前的 indent-after-paren 选项。# 的值表示缩进数。有效值为从 0 到 4 的整数值。如果未使用此选项，则使用默认值 1。
isLongVariable =
foo1 ||
foo2;
isLongFunction(
bar1,
bar2);
becomes (with indent-continuation=3):
isLongVariable =
foo1 ||
foo2;
isLongFunction(
bar1,
bar2);
--indent-labels / -L
向标签添加额外的缩进，使它们看起来比当前缩进少 1 个缩进，而不是左对齐（默认）。
void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}
becomes (with indented 'error:'):
void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}
--indent-preproc-block / -xW
在大括号级别零处缩进预处理器块并立即在命名空间内。 对缩进的内容有限制。 方法、类、数组等内的块不会缩进。 包含大括号或多行定义语句的块将不会缩进。 如果没有此选项，预处理器块不会缩进。
#ifdef _WIN32 #include <windows.h> #ifndef NO_EXPORT #define EXPORT #endif #endif
becomes:
#ifdef _WIN32
#include <windows.h>
#ifndef NO_EXPORT
#define EXPORT
#endif
#endif
--indent-preproc-define / -w
缩进以反斜杠结尾的多行预处理器定义。 应与 --convert-tabs 一起使用以获得正确的结果。 做得相当不错，但无法在混淆的预处理器定义中创造奇迹。 如果没有此选项，预处理器语句将保持不变。
#define Is_Bar(arg,a,b) \ (Is_Foo((arg), (a)) \ || Is_Foo((arg), (b)))
becomes:
#define Is_Bar(arg,a,b) \
(Is_Foo((arg), (a)) \
|| Is_Foo((arg), (b)))
--indent-preproc-cond / -xw
将预处理器条件语句缩进到与源代码相同的级别。（这个感觉不如不用）
isFoo = true;
#ifdef UNICODE
text = wideBuff;
#else
text = buff;
#endif
becomes:
isFoo = true;
#ifdef UNICODE
text = wideBuff;
#else
text = buff;
#endif
--indent-col1-comments / -Y
从第一列开始缩进 C++ 注释。 默认情况下，从第一列开始的 C++ 注释被假定为注释掉的代码并且不缩进。 此选项将允许注释与代码一起缩进。
void Foo()\n"
{
// comment
if (isFoo)
bar();
}
becomes:
void Foo()\n"
{
// comment
if (isFoo)
bar();
}
--min-conditional-indent=# / -m#
设置标题由多行组成时添加的最小缩进。 此缩进有助于轻松地将标题与后面的命令语句分开。 # 的值表示缩进数，并且是最小值。 缩进可能会更大，以便与上一行的数据对齐。
有效值为：
0 - 无最小缩进。 这些行将与前一行的括号对齐。
1 - 至少再缩进一个缩进。
2 - 至少缩进两个额外的缩进。
3 - 缩进至少二分之一的附加缩进。 这适用于大缩进（例如 8）。
默认值为 2，即两个附加缩进。
// default setting makes this non-braced code clear
if (a < b
|| c > d)
foo++;
// but creates an exaggerated indent in this braced code
if (a < b
|| c > d)
{
foo++;
}
becomes (when setting --min-conditional-indent=0):
// setting makes this non-braced code less clear
if (a < b
|| c > d)
foo++;
// but makes this braced code clearer
if (a < b
|| c > d)
{
foo++;
}
--max-continuation-indent=# / -M#
设置缩进连续行的最大 # 个空格。 # 表示列数，不得小于 40 或大于 120。如果未设置值，将使用默认值 40。 此选项将防止连续线向右延伸太远。 设置较大的值将允许代码进一步向右扩展。
fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);
becomes (with larger value):
fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);
8 Padding Options
--break-blocks / -f
在标题块周围填充空行（例如“if”、“for”、“while”...）。（这个是推荐的）
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
becomes:
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
--break-blocks=all / -F
在标题块周围填充空行（例如“if”、“for”、“while”...）。 将关闭标头块（例如“else”、“catch”）视为独立块。
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
becomes:
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
--pad-oper / -p
在运算符周围插入空格填充。 这也会在逗号后面填充空格。 如果可能的话，任何行尾注释都将保留在原始列中。 请注意，没有取消填充的选项。 一旦填充，它们就会保持填充状态。（这个我觉得很有用）
if (foo==2)
a=bar((b-c)*a,d--);
becomes:
if (foo == 2)
a = bar((b - c) * a, d--);
--pad-comma / -xg
在逗号后插入空格填充。 如果使用 pad-oper，则不需要此操作。 如果可能的话，任何行尾注释都将保留在原始列中。 请注意，没有取消填充的选项。 一旦填充，它们就会保持填充状态。
if (isFoo(a,b))
bar(a,b);
becomes:
if (isFoo(a, b))
bar(a, b);
--pad-paren / -P
在外部和内部的括号周围插入空格填充。 如果可能的话，任何行尾注释都将保留在原始列中。（这个不彳亍）
if (isFoo((a+2), b))
bar(a, b);
becomes:
if ( isFoo ( ( a+2 ), b ) )
bar ( a, b );
--pad-paren-out / -d
仅在外侧括号周围插入空格填充。 空的括号不会被填充。 如果可能的话，任何行尾注释都将保留在原始列中。 这可以与下面的 unpad-paren 一起使用来删除不需要的空格。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if (isFoo ( (a+2), b) )
bar (a, b);
--pad-first-paren-out / -xd
仅在外侧的第一个括号周围插入空格填充。 空的括号不会被填充。 如果可能的话，任何行尾注释都将保留在原始列中。 这可以与下面的 unpad-paren 一起使用来删除不需要的空格。 如果与 pad-paren 或 pad-paren-out 一起使用，此选项将被忽略。 如果与 pad-paren-in 一起使用，结果将是 pad-paren。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if (isFoo ((a+2), b))
bar (a, b);
--pad-paren-in / -D
仅在内部括号周围插入空格填充。 如果可能的话，任何行尾注释都将保留在原始列中。 这可以与下面的 unpad-paren 一起使用来删除不需要的空格。
if (isFoo((a+2), b))
bar(a, b);
becomes:
if ( isFoo( ( a+2 ), b ) )
bar( a, b );
--pad-header / -H
在标头（例如“if”、“for”、“while”...）和后面的括号之间插入空格填充。 如果可能的话，任何行尾注释都将保留在原始列中。 这可以与 unpad-paren 一起使用来删除不需要的空格。
if(isFoo((a+2), b))
bar(a, b);
becomes:
if (isFoo((a+2), b))
bar(a, b);
--unpad-paren / -U
删除内部和外部括号周围的多余空间填充。 如果可能的话，任何行尾注释都将保留在原始列中。 此选项可以与上面的 paren 填充选项 pad-paren、pad-paren-out、pad-paren-in 和 pad-header 结合使用。 仅删除其他选项未请求的填充。
例如，如果源在内部和外部都填充了括号，而您只需要内部。 您需要使用 unpad-paren 删除外部填充，并使用 pad-paren-in 保留内部填充。 仅使用 pad-paren-in> 不会删除外部填充。
if ( isFoo( ( a+2 ), b ) )
bar ( a, b );
becomes (with no padding option requested):
if(isFoo((a+2), b))
bar(a, b);
--pad-brackets
在外侧和内侧的方括号周围插入空格填充。
a = b[a[1]];
becomes:
a = b [ a [ 1 ] ];
--unpad-brackets
删除外侧和内侧方括号周围的填充空格。
a = b [ a [ 1 ] ];
becomes:
a = b[a[1]];
--delete-empty-lines / -xe
删除函数或方法中的空行。 函数或方法之外的空行不会被删除。 如果与break-blocks或break-blocks=all一起使用，它将删除除由break-blocks选项添加的行之外的所有行。
void Foo()
{
foo1 = 1;
foo2 = 2;
}
becomes:
void Foo()
{
foo1 = 1;
foo2 = 2;
}
--fill-empty-lines / -E
用前一行的空白填充空行。
--squeeze-lines=#
删除超过给定数量的多余空行。
void Foo()
{
foo1 = 1;
}
void Foo2()
{
foo1 = 1;
}
becomes:
void Foo()
{
foo1 = 1;
}
void Foo2()
{
foo1 = 1;
}
--squeeze-ws
删除多余的空白
void Foo ()
{
foo1 = 1;
}
becomes:
void Foo ()
{
foo1 = 1;
}
--align-pointer=type / -k1
--align-pointer=middle / -k2
--align-pointer=name / -k3
将指针或引用运算符（*、& 或 ^）附加到变量类型（左）或变量名称（右），或将其放置在类型和名称之间（中）。 如果可能的话，类型和名称之间的间距将被保留。 此选项适用于 C/C++、C++/CLI 和 C# 文件。 要单独格式化引用，请使用以下对齐引用选项。
char* foo1; char & foo2; string ^s1;
becomes (with align-pointer=type):
char* foo1; char& foo2; string^ s1;
---------------------------------------------------------------------------------------------------------------------------------
char* foo1; char & foo2; string ^s1;
becomes (with align-pointer=middle):
char * foo1; char & foo2; string ^ s1;
---------------------------------------------------------------------------------------------------------------------------------
char* foo1; char & foo2; string ^s1;
becomes (with align-pointer=name):
char *foo1; char &foo2; string ^s1;
--align-reference=none / -W0
--align-reference=type / -W1
--align-reference=middle / -W2
--align-reference=name / -W3
此选项将对齐与指针分开的引用。 此选项不会更改指针。 如果指针和引用要对齐相同，请使用前面的对齐指针选项。 选项align-reference=none不会改变参考对齐方式。 其他选项与对齐指针相同。 此选项适用于 C/C++、C++/CLI 和 C# 文件。
char &foo1;
becomes (with align-reference=type):
char& foo1;
---------------------------------------------------------------------------------------------------------------------------------
char& foo2;
becomes (with align-reference=middle):
char & foo2;
---------------------------------------------------------------------------------------------------------------------------------
char& foo3;
becomes (with align-reference=name):
char &foo3;
9 Formatting Options
--break-closing-braces / -y
当与 --style=java、--style=kr、--style=stroustrup、--style=linux 或 --style=ltbs 一起使用时，这会破坏关闭标头（例如 'else'、'catch'、.. .) 来自紧接其前面的右大括号。 结束标题大括号总是与其他样式分开。
void Foo(bool isFoo) {
if (isFoo) {
bar();
} else {
anotherBar();
}
}
becomes (a broken 'else'):
void Foo(bool isFoo) {
if (isFoo) {
bar();
}
else {
anotherBar();
}
}
--break-elseifs / -e
将“else if”标题组合分成单独的行。 如果使用 keep-one-line-statements，此选项无效，“else if”语句将保持原样。
如果不使用此选项，“else if”标题组合将放置在一行上。
if (isFoo) {
bar();
}
else if (isFoo1()) {
bar1();
}
else if (isFoo2()) {
bar2();
}
becomes:
if (isFoo) {
bar();
}
else
if (isFoo1()) {
bar1();
}
else
if (isFoo2()) {
bar2();
}
--break-one-line-headers / -xb
从驻留在同一行的语句中断开行标题（例如“if”、“while”、“else”等）。 如果语句用大括号括起来，则大括号将根据请求的大括号样式进行格式化。
如果请求保留一行语句，则多语句行不会被破坏。 如果请求 keep-one-line-blocks 并且标头包含在块中，则一行块不会被破坏。
void Foo(bool isFoo)
{
if (isFoo1) bar1();
if (isFoo2) { bar2(); }
}
becomes:
void Foo(bool isFoo)
{
if (isFoo1)
bar1();
if (isFoo2) {
bar2();
}
}
--add-braces / -j
将大括号添加到无大括号的单行条件语句（例如“if”、“for”、“while”...）。 该语句必须在单独一行上。 将根据要求的大括号样式添加大括号。 如果没有要求样式，将附加大括号。
如果请求保留一行语句，则不会将大括号添加到多语句行。 如果请求保留一行块，则不会将大括号添加到一行块中。 如果与 --add-one-line-braces 一起使用，结果将是一行大括号。
if (isFoo)
isFoo = false;
becomes:
if (isFoo) {
isFoo = false;
}
--add-one-line-braces / -J
将一行大括号添加到无括号的一行条件语句（例如“if”、“for”、“while”...）。 该语句必须在单独一行上。 该选项意味着 --keep-one-line-blocks 并且不会破坏单行块。
if (isFoo)
isFoo = false;
becomes:
if (isFoo)
{ isFoo = false; }
--remove-braces / -xj
从条件语句中删除大括号（例如“if”、“for”、“while”...）。 该语句必须是单行上的单个语句。 如果还使用 --add-braces 或 --add-one-line-braces，结果将是添加大括号。 大括号不会从“One True Brace Style”中删除，--style=1tbs。
if (isFoo)
{
isFoo = false;
}
becomes:
if (isFoo)
isFoo = false;
--break-return-type / -xB
--break-return-type-decl / -xD
将返回类型与函数名称分开。 这两个选项用于函数定义 (-xB) 和函数声明或签名 (-xD)。 如果与 --attach-return-type 一起使用，结果将破坏返回类型。 该选项对 Objective-C 函数没有影响。
void Foo(bool isFoo);
becomes:
void Foo(bool isFoo);
--attach-return-type / -xf
--attach-return-type-decl / -xh
将返回类型附加到函数名称。 这两个选项用于函数定义 (-xf) 和函数声明或签名 (-xh)。 它们的目的是撤消 --break-return-type 选项。 如果与 --break-return-type 一起使用，结果将破坏返回类型。 该选项对 Objective-C 函数没有影响。
void Foo(bool isFoo);
becomes:
void Foo(bool isFoo);
--keep-one-line-blocks / -O
不要破坏单行块。
if (isFoo)
{ isFoo = false; cout << isFoo << endl; }
remains unchanged.
--keep-one-line-statements / -o
不要破坏复杂的语句和位于一行的多个语句。
if (isFoo)
{
isFoo = false; cout << isFoo << endl;
}
remains unchanged.
--convert-tabs / -c
将行中非缩进部分的制表符转换为空格。 插入的空格数将保持制表符的间距。 使用每个选项卡空格的当前设置。 如果在更改每个制表符的空格时使用convert-tabs，它可能不会产生预期的结果。 引号内的制表符不会被替换。
--close-templates / -xy
关闭模板定义的结束尖括号之间的空白。 C++11 标准现在允许结束尖括号。 在进行更改之前，请确保您的编译器支持这一点。
Stack< int, List< int > > stack1;
becomes:
Stack< int, List< int >> stack1;
--remove-comment-prefix / -xp
删除以一行开头的多行注释中前面的“*”。 尾随“*”（如果存在）也会被删除。 少于 1 个缩进的文本将缩进 1 个缩进。 大于 1 缩进的文本不会更改。 为了保持一致性，以一行开头但前面没有“*”的多行注释将缩进为一个缩进。 这可以稍微修改注释掉的代码块的缩进。 包含所有“*”的行保持不变。 注释结尾“*/”中的额外空格已被删除。
/* * comment line 1 * comment line 2 */
becomes:
/*
comment line 1
comment line 2
*/
--max-code-length=# / -xC#
--break-after-logical / -xL
如果代码超过 # 个字符，选项 max-code-length 将换行。 有效值为 50 到 200。没有逻辑条件的行将在逻辑条件（||、&&、...）、逗号、括号、分号或空格处中断。
有些代码不会被破坏，例如注释、引号和数组。 如果与 keep-one-line-blocks 或 add-one-line-braces 一起使用，这些块将不会被破坏。 如果与 keep-one-line-statements 一起使用，则当该行超过最大长度时，该语句将在分号处断开。 如果在最大代码长度内没有可用的断点，则该行将在最大代码长度之后的第一个可用断点处断线。
默认情况下，逻辑条件将放在新行的第一位。 选项“break-after-logic”将导致逻辑条件放在上一行的最后。 如果没有 max-code-length，此选项不起作用。
if (thisVariable1 == thatVariable1 || thisVariable2 == thatVariable2 || thisVariable3 == thatVariable3)
bar();
becomes:
if (thisVariable1 == thatVariable1
|| thisVariable2 == thatVariable2
|| thisVariable3 == thatVariable3)
bar();
becomes (with break-after-logical):
if (thisVariable1 == thatVariable1 ||
thisVariable2 == thatVariable2 ||
thisVariable3 == thatVariable3)
bar();
--mode=c
--mode=cs
--mode=js
--mode=java
--mode=objc
缩进 C 类型、C#、Javascript、Java 或 Objective-C 文件。 C 类型文件有 C、C++、C++/CLI。 该选项通常是根据每个文件的文件扩展名设置的。 您可以使用此条目覆盖该设置。 它将用于所有文件，无论文件扩展名如何。 它允许格式化程序识别特定于语言的语法，例如 C++ 类、模板和关键字。
Objective-C Options略
10 Other Options
这些是可用于命令行的非格式化选项。 它们也可以包含在选项文件中。
--suffix=####
将后缀 #### 而不是“.orig”附加到原始文件名（例如 --suffix=.bak。如果这是文件扩展名，则必须包含点“.”。否则将附加后缀 到当前文件扩展名。
--suffix=none / -n
不要保留原始文件的备份。 格式化后原始文件将被清除。
其他的略。
Command Line Only略
以上就是全部内容了，谢谢大家！
如果觉得这篇文章有用的话，可以点赞、评论或者收藏，万分感谢，goodbye~
2862
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
