My artistic style config (All-man breckints style, keep empty lines, add space between operators, etc.)

.astylerc

# ~/.astylerc
#
# Courtesy of HN's super_mario: http://news.ycombinator.com/item?id=5348401
#
# Use allman formatting style
--style=allman

--indent=spaces=4
--align-pointer=type
--align-reference=name
--remove-brackets
--convert-tabs
--break-after-logical
#--pad-paren-in
unpad-paren

# Indent class and struct blocks so that the blocks 'public', 'private' and
# 'protected' are indented. This option is effective in C++ files only
#indent-classes

# Indent 'switch' blocks so that the 'case X:' statements are indented with
# the switch block. The entire case block is indented.
#
# For example:
# 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-switches

# Indent C++ namespaces (this option has no effect on other file types)
# Add extra indentation to namespace blocks.
# For example:
# namespace foospace
# {
# class Foo
# {
#     public:
#         Foo();
#         virtual ~Foo();
# };
# }
#
# becomes
#
# namespace foospace
# {
#     class Foo
#     {
#         public:
#             Foo();
#             virtual ~Foo();
#     };
# }
indent-namespaces

# Indent multi line preprocessor definitions ending with a backslash
# For example:
#
# #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-preprocessor



#         isFoo = true;
# #ifdef UNICODE
#         text = wideBuff;
# #else
#         text = buff;
# #endif
#
# becomes:
#
#        isFoo = true;
#        #ifdef UNICODE
#        text = wideBuff;
#        #else
#        text = buff;
#        #endif
--indent-preproc-cond



#    #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-define

# Indent C++ comments beginning in column one.
# For example
#
# void Foo()\n"
# {
# // comment
#     if (isFoo)
#         bar();
# }
#
# becomes:
#
# void Foo()\n"
# {
#     // comment
#     if (isFoo)
#         bar();
# }
#
indent-col1-comments

# 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

# Insert space padding around operators. 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.
#
# if (foo==2)
#     a=bar((b-c)*a,d--);
#
# becomes:
#
# if (foo == 2)
#      a = bar((b - c) * a, d--);
#
pad-oper


# 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 (isFoo(a, b))
#     bar(a, b);
#
#pad-header

# 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 pad‑paren,
# pad‑paren‑out, pad‑paren‑in, and pad‑header 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 pad‑paren‑in to retain the inside padding. Using only
# pad‑paren‑in 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);
#
#unpad-paren

# 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 = 1;
#
#     foo2 = 2;
#
# }
#
# becomes:
#
# void Foo()
# {
#     foo1 = 1;
#     foo2 = 2;
# }
#
#delete-empty-lines

# 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
# (middle). The spacing between the type and name will be preserved, if
# possible. To format references separately use the following align-reference
# option.
#
# char *foo1;
# char &foo2;
#
# becomes (with align-pointer=type):
#
# char* foo1;
# char& foo2;
#
# char* foo1;
# char& foo2;
#
# becomes (with align-pointer=middle):
#
# char * foo1;
# char & foo2;
#
# char* foo1;
# char& foo2;
#
# becomes (with align-pointer=name):
#
# char *foo1;
# char &foo2;
#
align-pointer=name

# Set the minimal indent that is added when a header is built of multiple
# lines. This indent helps to easily separate the header from the command
# statements that follow. The value for # indicates a number of indents and is
# a minimum value. The indent may be greater to align with the data on the
# previous line.
# The valid values are:
# 0 - no minimal indent. The lines will be aligned with the paren on the
# 	preceding line.
# 1 - indent at least one additional indent.
# 2 - indent at least two additional indents.
# 3 - indent at least one-half an additional indent. This is intended for large
# 	indents (e.g. 8).
#
# The default value is 2, two additional indents.
#
# // 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++;
# }
#
min-conditional-indent=0

# Set the  maximum of # spaces to indent a continuation line. The  # indicates
# a number of columns and must not be greater than 120. If no # is set, the
# default value of 40 will be used. A maximum of less than two indent lengths
# will be ignored. This option will prevent continuation lines from extending
# too far to the right. Setting a larger value will allow the code to be
# extended further to the right.
#
# fooArray[] = { red,
#          green,
#          blue };
#
# fooFunction(barArg1,
#          barArg2,
#          barArg3);
#
# becomes (with larger value):
#
# fooArray[] = { red,
#                green,
#                blue };
#
# fooFunction(barArg1,
#             barArg2,
#             barArg3);
#
#--max-instatement-indent=9