ClangFormatでC/C++コードを整形する

---
# アクセス修飾子のインデント
AccessModifierOffset: -2

# 引数は左揃え
AlignAfterOpenBracket: Align

# 初期化子リストを左揃え
AlignArrayOfStructures: Left

# 連続する行の位置を揃える
AlignConsecutiveAssignments: true   # "="
AlignConsecutiveDeclarations: true  # 宣言
AlignConsecutiveMacros: true        # マクロ
AlignTrailingComments: true         # コメント

# enum定数を項目毎に改行する
AllowShortEnumsOnASingleLine: false

# 短い関数を単一行にしない
AllowShortFunctionsOnASingleLine: None

# "{ }"を独立行に配置する
# "BreakBeforeBraces: Custom" の場合に有効
BraceWrapping:
  AfterClass: true              # classの後
  AfterControlStatement: false  # 制御文の後
  AfterEnum: true               # enumの後
  AfterFunction: true           # 関数の後
  AfterStruct: true             # structの後
  AfterUnion: true              # unionの後
  AfterExternBlock: false       # externの後
  BeforeCatch: false            # catchの前
  BeforeElse: false             # elseの前

# "{ }"の位置をカスタム設定する
BreakBeforeBraces: Custom

# 1行の文字数を制限する (0で無制限)
ColumnLimit: 120

# includeを名前順にソートする
IncludeBlocks: Preserve

# swicth分のcaseにインデントを設定する
IndentCaseLabels: false

# インデント
IndentWidth: 2

# ポインターの"*"、"&"は変数宣言の左に記述する
PointerAlignment: Right

# コメントは改行しない
ReflowComments: false

# キャストの後ろにスペースを入れない
SpaceAfterCStyleCast: false

# 制御文の"("の前にスペースを入れる
SpaceBeforeParens: ControlStatements

# コメントの前にスペース入れる
SpacesBeforeTrailingComments: 2

// AccessModifierOffset: -2
// IndentWidth: 2
class Sample {
private:
  int func1(void);

public:
  int func2(void);
}

// AlignAfterOpenBracket: Align
someLongFunction(argument1,
                 argument2);

// AlignAfterOpenBracket: DontAlign
someLongFunction(argument1,
  argument2);

// AlignAfterOpenBracket: AlwaysBreak
someLongFunction(
  argument1, argument2);

// AlignAfterOpenBracket: BlockIndent
someLongFunction(
  argument1, argument2
);

// AlignArrayOfStructures: None
// 整列しない

// AlignArrayOfStructures: Left
struct test demo[] =
{
  {56, 23, "hello"},
  {7,  5,  "abc"  }
}; 

// AlignArrayOfStructures: Right
struct test demo[] =
{
  {56, 23, "hello"},
  { 7,  5,   "abc"}
};

// AlignConsecutiveAssignments: true
aaa  = 0;
bb   = 1;
cccc = 2;

// AlignConsecutiveDeclarations: true
char   sc;
int    si;
double d;

// AlignConsecutiveMacros: true
#define SHORT_NAME       42
#define EVEN_LONGER_NAME (2)
#define foo(x)           (x * x)

// AlignEscapedNewlines: true  (左寄せで揃える)
#define TEST       \
  "long long test" \
  "string"

// AlignEscapedNewlines: false  (ColumnLimit位置で揃える)
#define TEST                 \
  "long long test"           \
  "string"

// AlignOperands: true
int aaa = bbbbbbbbbbbbbbb +
          ccccccccccccccc;

// AlignTrailingComments: true
int a;      // comment a
int b = 2;  // comment b

// AllowShortEnumsOnASingleLine: true
enum { A, B } myEnum;

// AllowShortEnumsOnASingleLine: false
enum
{
  A,
  B
} myEnum;

// AllowShortFunctionsOnASingleLine: None
// (単一行にしない)

// AllowShortFunctionsOnASingleLine: InlineOnly
// (class内で定義された関数だけ単一行にする)
class Foo {
  void f() { foo(); }
};
void f() {
  foo();
}
void f() {
}

// AllowShortFunctionsOnASingleLine: Inline
// (class内で定義された関数と空の関数だけ単一行にする)
class Foo {
  void f() { foo(); }
};
void f() {
  foo();
}
void f() {}

// AllowShortFunctionsOnASingleLine: Empty
// (空の関数だけ単一行にする)
void f() {}
void f2() {
  bar2();
}

// AllowShortFunctionsOnASingleLine: All
// (すべて単一行にする)
class Foo {
  void f() { foo(); }
};
void f() { bar(); }

// インデントはスペースで入れること
BraceWrapping:
  AfterClass: true             // classの後
  AfterControlStatement: true  // 制御文の後
  AfterEnum: true              // enumの後
  AfterFunction: true          // 関数の後
  AfterNamespace: true         // namespaceの後
  AfterStruct: true            // structの後
  AfterUnion: true             // unionの後
  AfterExternBlock: true       // externの後
  BeforeCatch: true            // catchの前
  BeforeElse: true             // elseの前

// BreakBeforeBraces: Attach  (常にコンテキストに付ける)
void function(int val) {
  if (val > MAX) {
    ...
  }
  ...
}

// BreakBeforeBraces: Allman  (常に独立した行に付ける)
void function(int val)
{
  if (val > MAX)
  {
    ...
  }
  ...
}

// BreakBeforeBraces: Custom  (BraceWrappingで個々に設定する)

ColumnLimit: 120

// IncludeBlocks: Preserve  (連続する行を整列する)
#include <stdio.h>
#include <stdint.h>

#include "b.h"
#include "a.h"
↓
#include <stdint.h>
#include <stdio.h>

#include "a.h"
#include "b.h"

// IncludeBlocks: Merge  (離れた行も引っ付けて整列する)
#include <stdio.h>
#include <stdint.h>

#include "b.h"
#include "a.h"
↓
#include "a.h"
#include "b.h"
#include <stdint.h>
#include <stdio.h>

// IncludeBlocks: Regroup  (IncludeCategoriesの順に整列する)

IncludeCategories:
  - Regex:           '^<.*\.h>'
    Priority:        1
  - Regex:           '^<.*'
    Priority:        2
  - Regex:           '.*'
    Priority:        3

// IndentCaseLabels: true
switch (val) {
  case 1:
    ...
    break;
  case 2:
    ...
    break;
  default:
    ...
}

// IndentCaseLabels: false
switch (val) {
case 1:
  ...
  break;
case 2:
  ...
  break;
default:
  ...
}

IndentWidth: 2

// PointerAlignment: Left
int* p;

// PointerAlignment: Middle
int * p;

// PointerAlignment: Right
int *p;

// ReflowComments: true  (試みる)

// ReflowComments: false  (試みない)

// SpaceAfterCStyleCast: true
(int) i;

// SpaceAfterCStyleCast: false
(int)i;

// SpaceBeforeAssignmentOperators: true
i = i + 1;

// SpaceBeforeAssignmentOperators: false
i= i + 1;

// SpaceBeforeParens: Never  (スペースを入れない)
void function(int val) {
  if(val > MAX) {
    ...
  }
}

// SpaceBeforeParens: ControlStatements  (制御文の前にはスペースを入れる)
void function(int val) {
  if (val > MAX) {
    ...
  }
}

// SpaceBeforeParens: Always  (すべてにスペースを入れる)
void function (int val) {
  if (val > MAX) {
    ...
  }
}

// SpaceInEmptyParentheses: true
func( );

// SpaceInEmptyParentheses: false
func();

// SpacesBeforeTrailingComments: 2
int name;  // 2スペース

// SpacesInAngles: true
static_cast< int >(arg);

// SpacesInAngles: false
static_cast<int>(arg);

// SpacesInCStyleCastParentheses: true
( int )i;

// SpacesInCStyleCastParentheses: false
(int)i;

// SpacesInParentheses: true
void function( int val ) {
  if ( val > MAX ) {
    ...
  }
  ...
}

// SpacesInParentheses: false
void function(int val) {
  if (val > MAX) {
    ...
  }
  ...
}

// SpacesInSquareBrackets: true
int a[ 5 ];

// SpacesInSquareBrackets: false
int a[5];

// clang-format off
...
// clang-format on