本软件适用于C, C++, C++/CLI, Objective‑C, C#, and Java
一、使用流程
1.安装软件
linux：apt install astyle，重启vscode
windows：下载最新版本，并将exe路径添加至PATH,重启vscode
2.安装vscode插件Astyle
3.配置
使用：设置->拓展->Astyle->在settings.json中编辑（后附具体配置）
配置示意图
"astyle.additional_languages": [
"c",
"cpp",
],
"astyle.cmd_options": [
"--style=allman",
"--indent=spaces=4",
"--indent-modifiers",
"--indent-switches",
"--indent-cases",
"--indent-namespaces",
"--indent-preproc-block",
"--min-conditional-indent=2",
"--pad-oper",
"--pad-header",
"--unpad-paren",
"--delete-empty-lines",
"--align-pointer=name",
"--align-reference=name",
"--keep-one-line-statements",
"--convert-tabs",
"--close-templates",
/*"--max-code-length=#", 单行code最大长度
"--break-after-logical",*/
"--suffix=none",
"--lineend=linux",
"--verbose",
],
"[c]": {
"editor.defaultFormatter": "chiehyu.vscode-astyle"
},
"[cpp]": {
"editor.defaultFormatter": "chiehyu.vscode-astyle"
},（配置参考：RT-thread）
具体配置：
1.大括号选项
--style=allman / --style=bsd / --style=break / -A1 ：分离大括号风格
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}--style=java / --style=attach / -A2 ：JAVA风格 ——附加大括号
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
} else
return 0;
}--style=kr / --style=k/r / -A3：Linux风格 —— 开始的大括号与名称空间、类和函数定义分开。其余大括号附加到函数内的所有其他内容，包括数组、结构体、枚举和语句。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}--style=stroustrup / -A4：Stroustrup风格 —— 使用了linux大括号，并将大括号的结束头与结束头分开(例如:break - closing - headers)。开始的大括号只从函数定义中断开。开始的大括号附加到函数中的所有其他内容，包括名称空间、类、数组、结构、枚举和语句。这种样式经常与“attach - closing - while”、tab缩进和5个空格缩进一起使用。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
}
else
return 0;
}--style=whitesmith / -A5：白铁匠风格 —— 使用破碎的，缩进的括号。Switch块和类块缩进以防止以下case语句和c++类修饰符(public, private, protected)的“挂缩进”。
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}--style=ratliff / --style=banner / -A6：Ratliff风格 —— 使用附加的，缩进的括号。Switch块和类块缩进是为了防止下面的case语句和c++类修饰符(public, private, protected)出现“挂缩进”。
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
}
else
return 0;
}--style=gnu / -A7：GNU风格 —— 使用断括号。额外的缩进只被添加到函数内的块中。整个块都是缩进的，而不仅仅是大括号。这种样式经常用于缩进2个空格。
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;
}--style=horstmann / --style=run-in / -A9：Horstmann风格 —— 使用破括号和插入语句。switch是缩进的，以允许在打开开关块上磨合。这种样式经常使用缩进3个空格。
int Foo(bool isBar)
{ if (isBar)
{ bar();
return 1;
}
else
return 0;
}--style=1tbs / --style=otbs / -A10：One True Brace 风格 —— 使用linux大括号，并将大括号添加到未加大括号的条件语句中。开始的大括号与名称空间、类和函数定义分开。大括号附加到函数内的所有其他内容，包括数组、结构体、枚举和语句。
int Foo(bool isBar)
{
if (isFoo) {
bar();
return 1;
} else {
return 0;
}
}--style=pico / -A11：Pico风格 —— 使用断开的大括号和带有附加的闭大括号的run-in语句。右大括号附加到代码块的最后一行。开关是缩进的，以允许在打开开关块上磨合。这种风格意味着保持一行块和保持一行语句。如果使用了add-大括号，它们将被添加为一行大括号。这种样式经常用于缩进2个空格。
int Foo(bool isBar)
{ if (isBar)
{ bar();
return 1; }
else
return 0; }--style=lisp / --style=python / -A12：Lisp风格 —— 使用附加的开括号和闭括号。右大括号附加到代码块的最后一行。这种风格意味着保持一行语句，而不是保持一行块。此样式不支持单行大括号。如果使用了add-one-line-大括号，它们将被添加为多行大括号。
int Foo(bool isBar) {
if (isBar) {
bar()
return 1; }
else
return 0; }--style=google / -A14： 谷歌风格 —— 使用附加的花括号和缩进的类访问修饰符。有关缩进修饰符格式的示例，请参阅缩进修饰符选项。这实际上不是唯一的大括号风格，而是带有非大括号变体的Java风格。这种样式经常用于缩进2个空格。
int Foo(bool isBar) {
if (isBar) {
bar();
return 1;
} else
return 0;
}--style=vtk / -A15：VTK(可视化工具包)风格 —— 使用破碎、缩进的大括号，除了类、数组、结构、枚举和函数定义的左大括号。Switch块缩进是为了防止下面的case语句出现“挂缩进”。
int Foo(bool isBar)
{
if (isBar)
{
bar();
return 1;
}
else
return 0;
}--style=mozilla / -A16：Mozilla风格 —— 使用linux大括号。开始的大括号与类、结构体、枚举和函数定义分开。大括号附加到函数中的所有其他内容，包括名称空间、数组和语句。这种样式经常与缩进2个空格和——break-return-type一起使用。
int Foo(bool isBar)
{
if (isBar) {
bar();
return 1;
} else
return 0;
}
2.Tab选项
default indent（如果没有设置缩进选项，将使用默认选项4个空格(eg：:-s4/--indent=spaces=4)。）
void Foo() {
....if (isBar1
............&& isBar2) // indent of this line can be changed with min-conditional-indent
........bar();
}--indent=spaces / --indent=spaces=# / -s#：每缩进使用#空格(eg：:-s3/--indent=spaces=3)。#必须在2到20之间。不指定同default indent
void Foo() {
...if (isBar1
.........&& isBar2) // indent of this line can be changed with min-conditional-indent
......bar();
}--indent=tab / --indent=tab=# / -t / -t#：使用制表符进行缩进，使用空格进行继续行对齐。这可以确保无论查看器的选项卡大小如何，代码都能正确显示。将每个缩进当作#空格(例如-t6 /——indent=tab=6)。#必须在2到20之间。如果没有设置#，将缩进处理为4个空格。
with indent=tab:
void Foo() {
> if (isBar1
> ........&& isBar2) // indent of this line can be changed with 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) // indent of this line can be changed with min-conditional-indent
> > bar();
}--indent=force-tab-x / --indent=force-tab-x=# / -xT / -xT#：这个force-tab选项允许将制表符长度设置为与缩进长度不同的长度。这可能会导致缩进同时包含制表符和空格。如果可能的话，制表符将用于缩进。如果不能使用制表符缩进，将使用空格代替。此选项设置制表符长度。将每个制表符视为#空格(例如-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) // indent of this line can be changed with min-conditional-indent
> bar();
}
3.大括号修饰选项
--attach-namespaces / -xn：大括号总是附加在命名空间语句上。
namespace FooName {
...
}--attach-classes / -xc： 大括号总是附加在类语句上。
class FooClass {
...
};--attach-inlines / -xl：所有大括号都附加到类和结构的内联方法定义(仅c++)
class FooClass
{
void Foo() {
...
}
};--attach-extern-c / -xk：将大括号附加到带大括号的extern "C"语句(仅c++)
#ifdef __cplusplus
extern "C" {
#endif
但是函数定义是按照要求的大括号样式进行格式化的:
extern "C" EXPORT void STDCALL Foo()
{}--attach-closing-while / -xV：将'do-while'语句的'while'附加到右括号。这优先于大括号样式和break关闭大括号选项。
do
{
bar();
++x;
}
while x == 1;
becomes:
do
{
bar();
++x;
} while x == 1;
4.缩进选项
--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：向名称空间块添加额外的缩进
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
becomes:
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}--indent-after-parens / -xU：在包含开头圆括号'('或赋值'='的行后面缩进，包括函数定义、声明和返回语句。
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#：设置以开始的圆括号'('或赋值'='结尾的行的延续缩进，包括函数定义和声明。它还将修改前面的缩进后括号选项。#的值表示大量的缩进。有效值是从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：缩进预处理器块在大括号级别0，并立即在名称空间内。对缩进的内容有限制。方法、类、数组等中的块不会缩进。包含大括号或多行定义语句的块将不会缩进。没有此选项，预处理器块不会缩进。
#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#：
设置header由多行组成时添加的最小缩进。这种缩进有助于轻松地将header与后面的命令语句分开。#的值表示缩进的数量，并且是最小值。缩进可能更大，以与前一行的数据对齐。有效值为:
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);4.填充选项
--break-blocks / -f：在标题块周围填充空行(e.g. '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：在标题块周围填充空行(e.g. 'if', 'for', 'while'...).处理关闭头文件块(e.g. '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一起使用，该选项将被忽略。
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：在标题之间插入空格(e.g. '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：在内外两边去掉多余的填充空间。行尾注释将保留在原始列中。
if ( isFoo( ( a+2 ), b ) )
bar ( a, b );
becomes (with no padding option requested):
if(isFoo((a+2), b))
bar(a, b);--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：用前一行的空白填充空行。
--align-pointer=type / -k1
--align-pointer=middle / -k2
--align-pointer=name / -k3
将指针或引用操作符(*、&或^)附加到变量类型(左)或变量名称(右)，或将其放在类型和名称(中间)之间。如果可能的话，将保留类型和名称之间的空格。这个选项适用于C/ c++、c++ /CLI和c#文件。要单独格式化引用，请使用以下align-reference选项。
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;
5.格式化选项
--break-closing-braces / -y：当与 --style=java, --style=kr, --style=stroustrup, --style=linux, 或者--style=1tbs同时使用，会打破关闭头文件 (e.g. '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语句，则此选项无效，“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：从位于同一行的语句中断开一行标题(e.g. 'if', 'while', 'else', ...)如果语句用大括号括起来，大括号将根据要求的大括号样式进行格式化。如果使用keep-one-line-statements，则多语句行不会被断开。如果使用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：向不带大括号的单行条件语句添加大括号(例如:“如果”,“对”,“而”……)。大括号将根据要求的大括号样式添加。如果没有要求样式，将附加大括号。如果使用keep-one-line-statements，则不会将大括号添加到多语句行中。如果使用keep-one-line-blocks，则不会将大括号添加到一行块中。如果与--add-one-line-braces一起使用，结果将是一行大括号。
if (isFoo)
isFoo = false;
becomes:
if (isFoo) {
isFoo = false;
}--add-one-line-braces / -J：添加一行大括号到不加大括号的一行条件语句 (e.g. 'if', 'for', 'while'...)。该选项意味--keep-one-line-blocks，并且不会打破一行块。
if (isFoo)
isFoo = false;
becomes:
if (isFoo)
{ isFoo = false; }--remove-braces / -xj：从条件语句中删除括号(例如:“如果”,“对”,“而”……)。语句必须是单行上的单个语句。如果还使用--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一起使用，结果将破坏返回类型。
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一起使用，结果将打破返回类型。
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：将Tab转换为行非缩进部分中的空格。插入的空格数将保持制表符的间距。使用每个选项卡的空格的当前设置。如果在更改每个选项卡的空格时使用convert-tabs，可能不会产生预期的结果。制表符不会在引号内替换。
--close-templates / -xy：关闭模板定义结束尖括号之间的空白。
Stack< int, List< int > > stack1;
becomes:
Stack< int, List< int >> stack1;--remove-comment-prefix / -xp：在以一行开头的多行注释中删除前面的'*'。如果末尾有'*'，也会被删除。小于一个缩进的文本缩进为一个缩进。不改变大于一个缩进的文本。一行开头没有'*'的多行注释被缩进为一个缩进，以保持一致性。这可以略微修改注释掉代码块的缩进。包含所有'*'的行保持不变。注释关闭符'*/'将删除额外的空格。
/*
* 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一起使用，block不会被破坏。如果与keep‑one‑line‑statements一起使用，当行超过最大长度时，语句将以分号分隔。如果在最大代码长度内没有可用的断点，则该行将在最大代码长度之后的第一个可用断点处被中断。默认情况下，逻辑条件将放在新行的第一个位置。选项break‑after‑logical将导致逻辑条件被放在前一行的最后。如果没有最大代码长度，这个选项就不起作用。
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=java
缩进一个C类型、c#或Java文件。C类型文件有C、c++、c++ /CLI和Objective-C。该选项通常从每个文件的文件扩展名设置。您可以使用此条目覆盖该设置。它将用于所有文件，而不管文件扩展名是什么。它允许格式化程序识别特定于语言的语法，如c++类、模板和关键字。