Artistic Style 1.24
A Free, Fast and Small Automatic Formatter
for C, C++, C#, and Java Source Code
项目网址：http://astyle.sourceforge.net/astyle.html
Astyle可以从命令行运行，由于它用C++编写，也可以作为C++类用在C++程序中。
概述
1． 行尾结束符
格式化后的行尾结束符和格式化之前的是一样的，如果原文件中有多种行尾结束符，则采用最常用的那种。Astyle可以对此进行设置。
2． 文件类型
Java .java
C# .cs
其他的作为C或者C++处理
可以通过 –mode= 来进行设置
3． 通配符和递归处理
Astyle可以递归地处理目录，以及类似于*.cpp,*.c??的文件，对于linux要用引号包含含有通配符的文件，对windows如果文件或路径中有空格，也要用引号包含起来
4． 文件名
处理source.cpp后，生成了格式化后的文件source.cpp和保存的格式化之前的文件source.cpp.orig。这个orig的后缀可以通过 –suffix=进行设置，或者用 –n 或者 –suffix=none 来表示不保存格式化之前的文件
5． 其他注意事项
Astyle可以格式化标准的类库描述，例如Open GL,wxWidgets,QT,MFC等
可以格式化嵌入式SQL语句
不能格式化UTF16或者UTF32编码的文件
那些多行的，而且像Python那样不是类似于C语言格式的嵌入式语句往往会被格式化地不怎么样，定义函数的宏定义也会使得下面的代码格式不好，如果有这样的情况，可以用 –exclude=选项
使用方法
Astyle是一个命令行工具，使用方法
astyle [options] SourceFile1 SourceFile2 SourceFile3 […]
example:
格式一个文件
astyle --style=allman /home/user/project/foo.cpp
递归地格式cpp和h文件
astyle --style=allman --recursive /home/user/project/*.cpp /home/user/project/*.h
或者将原文件格式化后起一个不同的名字
astyle [options] < OriginalSourceFile > BeautifiedSourceFile
< 和 > 是重定向符号，这种方法一次只能处理一个文件，不支持通配符，也不生成备份文件
命令行选项
如果不指定任何选项，则只产生4个空格的缩进
选项有两种书写方式：
长形式：
以 -- 注意是两个 – 开头，一次写一个
Example: '--brackets=attach --indent=spaces=4'
短形式
以一个 – 开头，能头将好几个选项合在一起写
-b -p -s4，可以简写为 –bps4
选项文件
一个可选的默认的选项文件能够补充或者替代命令行选项，需注意以下几点：
1． 命令行选项优先，级别高，发生冲突优先用命令行选项
2． Astyle通过以下方式找选项文件
命令行选项 –options=
环境变量ARTISTIC_STYLE_OPTIONS指定的文件和目录
环境变量HOME指向的目录下名为 .astylerc(注意前面有个点)的文件，例如Linux下$HOME/.astylerc
环境变量USERPROFILE指向的目录下名为astylerc的文件，例如windows下%USERPROFILE%\astylerc
3． 命令行用 –options=none 来关闭寻找选项文件的功能
4． 选项文件中的选项可以用新行 ， tab键，逗号，空格等区分
5． 在选项文件中，很长的选项可以不用写前面的 –符号
6． 以#开头的行做注释
示例：
# this line is a comment
--brackets=attach # this is a line-end comment
# long options can be written without the preceding '--'
indent-switches # cannot do this on the command line
# short options must have the preceding '-'
-t -p
# short options can be concatenated together
-M65Ucv
预定义的格式化选项
预定义的类型通过定义其它的选项来定义!预定义的类型优先级要比其它单独的选项定义要高。每种类型对一个缩进多少个空格定义是不同的。可以在每种类型中通过 indent=选项来定义缩进。设置了indent=spaces=#, indent=tab=#, or indent=forcetab=# 后就不使用默认的缩进形式了。默认情况下，这些预定义的格式类型都不会缩进名称空间，这可以通过 indent-namespace 选项来改变。
对我们而言，常使用的预定义类型有：
--style=allman / --style=ansi / --style=bsd / -A1
Allman style formatting/indenting uses broken brackets.
int Foo(bool isBar)
{
if (isBar)
{
bar();
;
}
else
;
}
--style=k&r / --style=k/r / -A3
Kernighan & Ritchie style formatting/indenting uses linux brackets. Brackets are broken from namespaces, classes, and function definitions. Brackets are attached to statements within a function.
Using the k&r option may cause problems because of the &. This can be resolved by enclosing the k&r in quotes (e.g. style="k&r") or by using the alternate style=k/r.
int Foo(bool isBar)
{
if (isBar) {
bar();
;
} else
;
}
--style=gnu / -A7
GNU style formatting/indenting uses broken brackets and indented blocks. Indentation is 2 spaces.
Extra indentation is added to blocks within a function. The opening bracket for namespaces, classes, and functions is not indented.
int Foo(bool isBar)
{
if (isBar)
{
bar();
;
}
else
;
}
--style=linux / -A8
Linux style formatting/indenting uses linux style brackets. Brackets are broken from namespace, class, and function definitions. Brackets are attached to statements within a function. Indentation is 8 spaces. Minimum conditional indent is 4 spaces, or one-half the spaces per indent if a different setting is used. If you want to change the spaces per indent for this style it will be easier to use the K&R style instead.
Also known as Kernel Normal Form (KNF) style, this is the style used in the Linux kernel.
int Foo(bool isBar)
{
if (isFoo) {
bar();
;
} else
;
}
Tab键选项
在不同的系统或者编辑器下，TAB键所转换成的空格数是不同的，因此最好使用空格来对齐而不是TAB键。当看到别人比较乱的代码时，就需要有一个代码格式化的工具了。
如果没有明确指定缩进选项，则默认的是缩进4个空格：-s4 --indent=spaces=4
--indent=spaces / --indent=spaces=# / -s#
Indent using # spaces per indent (e.g. -s6 --indent=spaces=6). # must be between 2 and 20. Not specifying # will result in a default of 4 spaces per indent.
--indent=tab / --indent=tab=# / -t / -t#
Indent using tab characters. Treat each tab as # spaces (e.g. -t6 / --indent=tab=6). # must be between 2 and 20. If no # is set, treats tabs as 4 spaces.
--indent=force-tab / --indent=force-tab=# / -T / -T#
Indent using tab characters. Treat each tab as # spaces (e.g. -T6 / --indent=force-tab=6). Uses tabs as indents where indent=tab prefers to use spaces, such as inside multi-line statements. # must be between 2 and 20. If no # is set, treats tabs as 4 spaces.
默认的括号选项
如果没有明确指定关于括号的选项，则原文件的括号不做改变。
--brackets=break / -b
Break brackets from their pre-block statements ( e.g. Allman / ANSI style ).
void Foo(bool isFoo)
{
if (isFoo)
{
bar();
}
else
{
anotherBar();
}
}
--brackets=attach / -a
Attach brackets to their pre-block statements ( e.g. Java style ).
void Foo(bool isFoo) {
if (isFoo) {
bar();
} else {
anotherBar();
}
}
--brackets=linux / -l
这种括号的特点是括号从名称空间，类，函数定义处断开，但是在函数定义的内部，把括号加在语句的后面
Break brackets from namespace, class, and function definitions, but attach brackets to statements within a function ( e.g. K&R / Linux style ).
With C++ files brackets are attached for function definitions within a class (inline class functions). The brackets are also attached for arrays, structs, enums, and other top level objects that are not classes or functions. This option is effective for C/C++ files only.
void Foo(bool isFoo)
{
if (isFoo) {
bar();
} else {
anotherBar;
}
}
关于缩进的选项
--indent-classes / -C
Indent 'class' and 'struct' blocks so that the blocks 'public:', 'protected:' and 'private:' are indented. The struct blocks are indented only if an access modifier is declared somewhere in the struct. The entire block is indented. This option is effective for C++ files only.
class Foo
{
public:
Foo();
virtual ~Foo();
};
becomes:
class Foo
{
public:
Foo();
virtual ~Foo();
};
--indent-switches / -S
Indent 'switch' blocks so that the 'case X:' statements are indented in the switch block. The entire case block is indented.
switch (foo)
{
:
a += ;
break;
:
{
a += ;
break;
}
}
becomes:
switch (foo)
{
:
a += ;
break;
:
{
a += ;
break;
}
}
--indent-cases / -K
只对那些有语句块的case才起作用
Indent 'case X:' blocks from the 'case X:' headers. Case statements not enclosed in blocks are NOT indented.
switch (foo)
{
:
a += ;
break;
:
{
a += ;
break;
}
}
becomes:
switch (foo)
{
:
a += ;
break;
:
{
a += ;
break;
}
}
这个我们应该不会这么格式化吧？
--indent-brackets / -B
Add extra indentation to brackets. This is the option used for Whitesmith and Banner style formatting/indenting. If both indentbrackets and indentblocks are used the result will be indentblocks. This option will be ignored if used with a predefined style.
if (isFoo)
{
bar();
}
else
anotherBar();
becomes:
if (isFoo)
{
bar();
}
else
anotherBar();
这个也是，原格式挺好看的了
--indent-blocks / -G
Add extra indentation to blocks within a function. The opening bracket for namespaces, classes, and functions is not indented. This is the option used for GNU style formatting/indenting. This option will be ignored if used with a predefined style.
if (isFoo)
{
bar();
}
else
anotherBar();
becomes:
if (isFoo)
{
bar();
}
else
anotherBar();
下面这个主要对名称空间起作用
--indent-namespaces / -N
Add extra indentation to namespace blocks. This option has no effect on Java files.
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
becomes:
namespace foospace
{
class Foo
{
public:
Foo();
virtual ~Foo();
};
}
下面这个主要是对标记进行缩进，例如goto，error等
--indent-labels / -L
Add extra indentation to labels so they appear 1 indent less than the current indentation, rather than being flushed to the left (the default).
void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}
becomes (with indented 'error:'):
void Foo() {
while (isFoo) {
if (isFoo)
goto error;
...
error:
...
}
}
对宏进行缩进处理，但这个似乎不能保证效果
--indent-preprocessor / -w
Indent multi-line preprocessor definitions ending with a backslash. Should be used with --convert-tabs for proper results. Does a pretty good job, but can not perform miracles in obfuscated preprocessor definitions. Without this option the preprocessor statements remain unchanged.
#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-col1-comments / -Y
Indent C++ comments beginning in column one. By default C++ comments beginning in column one are not indented. This option will allow the comments to be indented with the code.
void Foo()\n"
{
// comment
if (isFoo)
bar();
}
becomes:
void Foo()\n"
{
// comment
if (isFoo)
bar();
}
连续语句的对齐
对于那些长的语句，往往需要分行写，这个选项即是对这种情况进行缩进对齐的。
--max-instatement-indent=# / -M#
Indent a maximum of # spaces in a continuous statement, relative to the previous line (e.g. maxinstatementindent=40). # must be less than 80. If no # is set, the default value of 40 will be used. A maximum of less than two indent lengths will be ignored.
fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);
becomes (with larger value):
fooArray[] = { red,
green,
blue };
fooFunction(barArg1,
barArg2,
barArg3);
下面是对一个多行的if条件语句进行对齐，最小值必须为小于等于40，默认是当前缩进数的2倍
Set the minimal indent that is added when a header is built of multiple-lines. This indent makes helps to easily separate the header from the command statements that follow. The value for # must be less than 40. The default setting for this option is twice the current indent (e.g. --min-conditional-indent=8).
// default setting makes this non-bracketed code clear
if (a < b
|| c > d)
foo++;
// but creates an exaggerated indent in this bracketed code
if (a < b
|| c > d)
{
foo++;
}
becomes (when setting --min-conditional-indent=0):
// setting makes this non-bracketed code less clear
if (a < b
|| c > d)
foo++;
// but makes this bracketed code clearer
if (a < b
|| c > d)
{
foo++;
}
填补选项(Padding Options)
主要是加一些空行，前后空格等内容
--break-blocks / -f
Pad empty lines around header blocks (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
Pad empty lines around header blocks (e.g. 'if', 'for', 'while'...). Treat closing header blocks (e.g. 'else', 'catch') as stand-alone blocks.
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
becomes:
isFoo = true;
if (isFoo) {
bar();
} else {
anotherBar();
}
isBar = false;
对运算符前后填加空格：注意不可逆！[]不填加
--pad-oper / -p
Insert space padding around operators. Operators inside block parens [] are not padded. Any end of line comments will remain in the original column, if possible. Note that there is no option to unpad. Once padded, they stay padded.
)
a=bar((b-c)*a,*d--);
becomes:
)
a = bar((b - c) * a, * d--);
对内外圆括号进行添加
--pad-paren / -P
Insert space padding around parenthesis on both the outside and the inside. Any end of line comments will remain in the original column, if possible.
if (isFoo(a, b))
bar(a, b);
becomes:
if ( isFoo ( a, b ) )
bar ( a, b );
仅对外圆括号进行添加
--pad-paren-out / -d
Insert space padding around parenthesis on the outside only. Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren below to remove unwanted spaces.
if (isFoo(a, b))
bar(a, b);
becomes:
if (isFoo (a, b) )
bar (a, b);
仅对内圆括号进行添加
--pad-paren-in / -D
Insert space padding around parenthesis on the inside only. Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren below to remove unwanted spaces.
if (isFoo(a, b))
bar(a, b);
becomes:
if ( isFoo( a, b ) )
bar( a, b );
仅仅对语句的头，例如if,while,for等进行填充空格
--pad-header / -H
Insert space padding after paren headers only (e.g. 'if', 'for', 'while'...). Any end of line comments will remain in the original column, if possible. This can be used with unpad-paren to remove unwanted spaces.
if(isFoo(a, b))
bar(a, b);
becomes: 注意if后有空格
if (isFoo(a, b))
bar(a, b);
下面是对圆括号操作的逆操作
--unpad-paren / -U
Remove extra space padding around parenthesis on the inside and outside. Any end of line comments will remain in the original column, if possible. This option can be used in combination with the paren padding options padparen, padparenout, padparenin, and padheader above. Only padding that has not been requested by other options will be removed.
For example, if a source has parens padded on both the inside and outside, and you want inside only. You need to use unpad-paren to remove the outside padding, and padparenin to retain the inside padding. Using only padparenin would not remove the outside padding.
if ( isFoo( a, b ) )
bar ( a, b );
becomes (with no padding option requested):
if (isFoo(a, b))
bar(a, b);
删除多余的空行，注意函数或者方法外的空行不删除！
--delete-empty-lines / -x
Delete empty lines within a function or method. Empty lines outside of functions or methods are NOT deleted. If used with break-blocks or break-blocks=all it will delete all lines EXCEPT the lines added by the break-blocks options.
void Foo()
{
foo1 = ;
foo2 = ;
}
becomes:
void Foo()
{
foo1 = ;
foo2 = ;
}
--fill-empty-lines / -E
Fill empty lines with the white space of the previous line
格式化选项
--break-closing-brackets / -y
When used with --brackets=attach, --brackets=linux, or --brackets=stroustrup, this breaks closing headers (e.g. 'else', 'catch', ...) from their immediately preceding closing brackets. Closing header brackets are always broken with broken brackets, horstmann brackets, indented blocks, and indented brackets.
void Foo(bool isFoo) {
if (isFoo) {
bar();
} else {
anotherBar();
}
}
becomes (with a broken 'else'):
void Foo(bool isFoo) {
if (isFoo) {
bar();
}
else {
anotherBar();
}
}
把 else if 这样的语句在else后断开
--break-elseifs / -e
Break "else if" header combinations into separate lines. This option has no effect if keep-one-line-statements is used, the "else if" statements will remain as they are.
If this option is NOT used, "else if" header combinations will be placed on a single line.
if (isFoo) {
bar();
}
else if (isFoo1()) {
bar1();
}
else if (isFoo2()) }
bar2;
}
becomes:
if (isFoo) {
bar();
}
else
if (isFoo1()) {
bar1();
}
else
if (isFoo2()) {
bar2();
}
对没有括号地单个if,for,while等语句填加括号，以下的四个设置都是对写在一行上的语句进行设置
--add-brackets / -j
Add brackets to unbracketed one line conditional statements (e.g. 'if', 'for', 'while'...). The statement must be on a single line. The brackets will be added according to the currently requested predefined style or bracket type. If no style or bracket type is requested the brackets will be attached. If --add-one-line-brackets is also used the result will be one line brackets.
if (isFoo)
isFoo = false;
becomes:
if (isFoo) {
isFoo = false;
}
--add-one-line-brackets / -J
Add one line brackets to unbracketed one line conditional statements (e.g. 'if', 'for', 'while'...). The statement must be on a single line. The option implies --keep-one-line-blocks and will not break the one line blocks.
if (isFoo)
isFoo = false;
becomes:
if (isFoo)
{ isFoo = false; }
--keep-one-line-blocks / -O
Don't break one-line blocks.
if (isFoo)
{ isFoo = false; cout << isFoo << endl; }
remains unchanged.
--keep-one-line-statements / -o
Don't break complex statements and multiple statements residing on a single line.
if (isFoo)
{
isFoo = false; cout << isFoo << endl;
}
remains unchanged.
if (isFoo) DoBar();
remains unchanged.
对行中没有缩进的部分，把那些tab键转化为空格键
--convert-tabs / -c
Converts tabs into spaces in the non-indentation part of the line. The number of spaces inserted will maintain the spacing of the tab. The current setting for spaces per tab is used. It may not produce the expected results if convert-tabs is used when changing spaces per tab. Tabs are not replaced in quotes.
关于指针和取地址符号，*,&是放在类型，中间，还是变量名侧的选项
--align-pointer=type / -k1
--align-pointer=middle / -k2
--align-pointer=name / -k3
Attach a pointer or reference operator (* or &) to either the variable type (left) or variable name (right), or place it between the type and name. The spacing between the type and name will be preserved, if possible. This option is effective for C/C++ files only.
char *foo1;
becomes (with align-pointer=type):
char* foo1; char* foo2;
becomes (with align-pointer=middle):
char * foo2; char& foo3;
becomes (with align-pointer=name):
char &foo3;
关于原文件的类型的设置
--mode=c
--mode=cs
--mode=java
Indent a C/C++, C#, or Java file. The option is usually set from the file extension for each file. You can override the setting with this entry. It will be used for all files regardless of the file extension. It allows the formatter to identify language specific syntax such as C++ classes, templates, and keywords.
其它选项
指定格式化后以何种后缀保存原文件
--suffix=####
Append the suffix #### instead of '.orig' to original filename (e.g. --suffix=.bak). If this is to be a file extension, the dot '.' must be included. Otherwise the suffix will be appended to the current file extension.
--suffix=none / -n
Do not retain a backup of the original file. The original file is purged after it is formatted.
指定是否需要一个选项文件来定义格式化的选项
--options=####
Specify an options file #### to read and use.
--options=none
Disable the default options file. Only the command-line parameters will be used.
递归处理的设置，注意对通配符的处理
--recursive / -r / -R
For each directory in the command line, process all subdirectories recursively. When using the recursive option the file name statement should contain a wildcard. Linux users should place the filepath and name in double quotes so the shell will not resolve the wildcards (e.g. "$HOME/src/*.cpp"). Windows users should place the filepath and name in double quotes if the path or name contains spaces.
exclude不支持通配符，可以在引号内设置多个排除文件
--exclude=####
Specify a file or sub directory #### to be excluded from processing.
Excludes are matched from the end of the filepath. An exclude option of "templates" will exclude ALL directories named "templates". An exclude option of "cpp/templates" will exclude ALL "cpp/templates" directories. You may proceed backwards in the directory tree to exclude only the required directories.
Specific files may be excluded in the same manner. An exclude option of "default.cpp" will exclude ALL files named "default.cpp". An exclude option of "python/default.cpp" will exclude ALL files named "default.cpp" contained in a "python" subdirectory. You may proceed backwards in the directory tree to exclude only the required files.
Wildcards are NOT allowed. There may be more than one exclude statement. The filepath and name may be placed in double quotes (e.g. exclude="foo bar.cpp").
--errors-to-stdout / -X
Print errors to standard-output rather than to standard-error.
This option should be helpful for systems/shells that do not have this option, such as in Windows95.
是否保留原文件的创建和修改日期
--preserve-date / -Z
Preserve the original file's date and time modified. The date and time modified will not be changed in the formatted file. This option is not effective if redirection is used to rename the input file.
以下三个是关于格式化过程中，相关信息的显示的设置
--verbose / -v
Verbose display mode. Display optional information, such as release number and statistical data.
--formatted / -Q
Formatted files display mode. Display only the files that have been formatted. Do not display files that are unchanged.
--quiet / -q
Quiet display mode. Suppress all output except error messages.
如果没有这几个选项，则文件的行结束符与原文件相同
--lineend=windows / -z1
--lineend=linux / -z2
--lineend=macold / -z3
Force use of the specified line end style. Valid options are windows (CRLF), linux (LF), and macold (CR). MacOld style is the format for OS 9 and earlier. Mac OS X uses the Linux style. If one of these options is not used the line ends will be determined automatically from the input file.
注意以下两个选项不能与其它选项简写在一起
--version / -V
Print version number and quit. The short option must be by itself, it cannot be concatenated with other options.
--help / -h / -?
Print a help message and quit. The short option must be by itself, it cannot be concatenated with other options.
使用方法：
可以直接对一个目录进行程序整理。例如要对D:\cldll进行整理。AStyle程序目录是C:\astyle\bin\astyle,我整理的选项文件放在C:\astyle\astyleOptions.txt，在选项文件中可以设置不需要代码整理的目录
例如：
--exclude=D:\cldll\obj
则可以对cldll进行如下的代码整理：
C:\astyle\bin>astyle --options=C:\astyle\astyleOptions.txt --recursive D:\cldll\*.cxx D:\cldll\*.h
Artistic Style 1.24
Using default options file C:\astyle\astyleOptions.txt
--------------------------------------------------
directory D:\cldll\*.cxx
--------------------------------------------------
formatted Cmplx.cxx
formatted flow.cxx
formatted flowwg.cxx
formatted flow_opl.cxx
formatted flow_sub.cxx
formatted pas_freq.cxx
formatted pas_nr.cxx
formatted pas_pq.cxx
formatted ringcl.cxx
formatted ringmain.cxx
--------------------------------------------------
directory D:\cldll\*.h
--------------------------------------------------
formatted Cmplx.h
formatted flow_opl.h
formatted flow_sub.h
formatted pas_freq.h
formatted pas_nr.h
formatted pas_pq.h
formatted rinlocal.h
--------------------------------------------------
17 formatted, 0 unchanged, 1 seconds, 24242 lines
AStyle与UltraEdit的集成
见到网上有，但不知道具体哪个版本。
AStyle与VC6.0的集成
配置VC，添加astyle代码整理功能。
1） 在VC中新建菜单项”AStyle”。在工具栏上点击右键打开Customize窗口，在Tools标签页新建一个菜单项：“AStyle”，并在Command中输入菜单项对应外挂工具程序当前所在路径：例如C:\astyle\bin\AStyle.exe
2） 在Arguments中输入外挂工具程序配置参数
--options=C:\astyle\astyleOptions.txt $(FileName)$(FileExt)
$(FileName)$(FileExt)表示当前编辑的文件名和扩展名
在Initial directory中输入$(FileDir)参数：表示初始运行路径。设置该项值后，astyle启动的初始路径为当前文件路径。
3） 为使在astyle.exe整理代码时不弹出Dos框并将运行结果直接显示到VC中，需选中”Use Output Window”选项。
4) 为方便astyle工具的使用，还可以将该菜单项添加到便捷工具栏中。同样也是在Tools下面的Customize中进行设置，设置时注意工具图标编号，如图所示：
5）至此设置工作基本完成，还有一点注意事项需要说明。因为astyle对代码进行整理时整理的对象是硬盘中的源文件，如果未对源文件进行保存就直接进行代码整理的话，VC会弹出源文件重新载入提示框，如果选择是，则会丢掉刚刚开发的代码；选择否又会使整理操作白费了。所以为保证开发代码及时得到保存，需在整理前保存修改源文件。要实现该功能，只需在Tools中的option设置中，将Save options设为：”Save before running tools”
效果：注意在visual assistant旁的那个tool即是AStyle的快捷方式
1、整理前代码行：
2、整理后的代码行：