Pynote

Python、機械学習、画像処理について

clang-format 9 の設定パラメータ まとめ

概要

複数の言語に対応した書式整形ツール clang-format 9 のパラメータについて紹介する。

No 名前
1 BasedOnStyle string
2 AccessModifierOffset int
3 AlignAfterOpenBracket enum
4 AlignConsecutiveAssignments bool
5 AlignConsecutiveDeclarations bool
6 AlignEscapedNewlines enum
7 AlignOperands bool
8 AlignTrailingComments bool
9 AllowAllArgumentsOnNextLine bool
10 AllowAllConstructorInitializersOnNextLine bool
11 AllowAllParametersOfDeclarationOnNextLine bool
12 AllowShortBlocksOnASingleLine bool
13 AllowShortCaseLabelsOnASingleLine bool
14 AllowShortFunctionsOnASingleLine enum
15 AllowShortIfStatementsOnASingleLine enum
16 AllowShortLambdasOnASingleLine enum
17 AllowShortLoopsOnASingleLine bool
18 AlwaysBreakAfterDefinitionReturnType enum
19 AlwaysBreakAfterReturnType enum
20 AlwaysBreakBeforeMultilineStrings bool
21 AlwaysBreakTemplateDeclarations enum
22 BinPackArguments bool
23 BinPackParameters bool
24 BraceWrapping enum
25 BreakBeforeBinaryOperators enum
26 BreakBeforeBraces enum
27 BreakBeforeTernaryOperators bool
28 BreakConstructorInitializers enum
29 BreakInheritanceList enum
30 BreakStringLiterals bool
31 ColumnLimit unsigned
32 CommentPragmas string
33 CompactNamespaces bool
34 ConstructorInitializerAllOnOneLineOrOnePerLine bool
35 ConstructorInitializerIndentWidth unsigned
36 ContinuationIndentWidth unsigned
37 Cpp11BracedListStyle bool
38 DerivePointerAlignment bool
39 DisableFormat bool
40 ExperimentalAutoDetectBinPacking bool
41 FixNamespaceComments bool
42 ForEachMacros string のリスト
43 TypenameMacros string のリスト
44 IncludeBlocks enum
45 IncludeCategories IncludeCategory のリスト
46 IncludeIsMainRegex string
47 IndentCaseLabels bool
48 IndentPPDirectives enum
49 IndentWidth unsigned
50 IndentWrappedFunctionNames bool
51 KeepEmptyLinesAtTheStartOfBlocks bool
52 Language enum
53 MacroBlockBegin string
54 MacroBlockEnd string
55 MaxEmptyLinesToKeep unsigned
56 NamespaceIndentation enum
57 NamespaceMacros string のリスト
66 PointerAlignment enum
68 ReflowComments bool
69 SortIncludes bool
70 SortUsingDeclarations bool
71 SpaceAfterCStyleCast bool
72 SpaceAfterLogicalNot bool
73 SpaceAfterTemplateKeyword bool
74 SpaceBeforeAssignmentOperators bool
75 SpaceBeforeCpp11BracedList bool
76 SpaceBeforeCtorInitializerColon bool
77 SpaceBeforeInheritanceColon bool
78 SpaceBeforeParens enum
79 SpaceBeforeRangeBasedForLoopColon bool
80 SpaceInEmptyParentheses bool
81 SpacesBeforeTrailingComments unsigned
82 SpacesInAngles bool
83 SpacesInCStyleCastParentheses bool
85 SpacesInParentheses bool
86 SpacesInSquareBrackets bool
87 Standard enum
88 StatementMacros string のリスト
89 TabWidth unsigned
90 UseTab enum

試した環境

  • clang-format 9
  • C++11

設定一覧

BasedOnStyle

型: string

デフォルトの書式を指定する。
個別の設定を記述した場合はそちらが優先される。

AccessModifierOffset

型: int

アクセス修飾子の追加のインデント幅を指定する。
最終的なアクセス修飾子のインデント幅は、IndentWidth + AccessModifierOffset で計算される。

IndentWidth: 4 の場合

// AccessModifierOffset: 0
// IndentWidth + AccessModifierOffset = 4 がインデント幅となる。
class MyClass {
    public:
    MyClass();
    ~MyClass();
}
// AccessModifierOffset: -2
// IndentWidth + AccessModifierOffset = 2 がインデント幅となる
class MyClass {
  public:
    MyClass();
    ~MyClass();
}
// AccessModifierOffset: -4
// IndentWidth + AccessModifierOffset = 0 がインデント幅となる
class MyClass {
public:
    MyClass();
    ~MyClass();
}

AlignAfterOpenBracket

型: enum (Align, DontAlign, AlwaysBreak)

括弧 (()、<>、[]) 内のパラメータが1行に収まらない場合、開始括弧の直後の整列方法を指定する。

  • Align: 整列する。
// AlignAfterOpenBracket: Align
void function(int parameter1,
              int parameter2,
              int parameter3);
  • DontAlign: 整列しない。
// AlignAfterOpenBracket: DontAlign
void function(int parameter1,
    int parameter2, int parameter3);
  • AlwaysBreak: 開始括弧の後で改行する。
// AlignAfterOpenBracket: AlwaysBreak
void function(
    int parameter1, int parameter2,
    int parameter3);

AlignConsecutiveAssignments

型: bool

複数行連続している代入で、代入演算子の位置の整列方法を指定する。

  • true: 整列する。
// AlignConsecutiveAssignments: true
int a   = 1;
int bb  = 2;
int ccc = 3;
  • false: 整列しない。
// AlignConsecutiveAssignments: false
int a = 1;
int bb = 2;
int ccc = 3;

AlignConsecutiveDeclarations

型: bool

複数行連続している宣言で、識別子の位置の整列方法を指定する。

  • true: 整列する。
// AlignConsecutiveDeclarations: true
int    a = 1;
long   b = 2;
double c = 3;
  • false: 整列しない。
// AlignConsecutiveDeclarations: false
int a = 1;
long b = 2;
double c = 3;

AlignEscapedNewlines

型: enum (DontAlign, Left, Right)

改行エスケープの整列方法を指定する。

  • DontAlign: 整列しない。
// AlignEscapedNewlines: DontAlign
#define DEFINE_ABC \
    int a; \
    int b; \
    int c;
  • Left: 整列可能な一番左側で整列する。
// AlignEscapedNewlines: Left
#define DEFINE_ABC \
    int a;         \
    int b;         \
    int c;
  • Right: 右端で整列する。
// AlignEscapedNewlines: Right
#define DEFINE_ABC                     \
  int a;                               \
  int b;                               \
  int c;

AlignOperands

型: bool

1行に収まらない場合、単項または2項演算子の整列方法を指定する。

  • true: 整列する。
// AlignOperands: true
int var = loooooooooongNameValue1 +
          loooooooooongNameValue2;
  • false: 整列しない。
// AlignOperands: false
int var = loooooooooongNameValue1 +
    loooooooooongNameValue2;

AlignTrailingComments

型: bool

複数行連続しているコメントを整列するかどうかを指定する。

  • true: 整列する。
// AlignTrailingComments: true
int var1 = 1;    // comment
double var2 = 2; // comment
  • false: 整列しない。
// AlignTrailingComments: false
int var1 = 1; // comment
double var2 = 2; // comment

AllowAllArgumentsOnNextLine

型: bool

関数の引数が1行に収まらない場合、BinPackArguments が false でも改行すれば1行に収まる場合は、次の行にすべての引数を置くかどうかを指定する。

  • true:
// BinPackArguments: false
// AllowAllArgumentsOnNextLine: true
callFunction(
    a, b, c, d);
  • false:
// BinPackArguments: false
// AllowAllArgumentsOnNextLine: false
callFunction(a,
             b,
             c,
             d);

AllowAllConstructorInitializersOnNextLine

型: bool

コンストラクタ初期化子が1行に収まらない場合、ConstructorInitializerAllOnOneLineOrOnePerLine が true でも改行すれば1行に収まる場合は、次の行にすべてのコンストラクタ初期化を置くかどうかを指定する。
ConstructorInitializerAllOnOneLineOrOnePerLine が false の場合は、この設定は何も効果がない。

  • true:
// ConstructorInitializerAllOnOneLineOrOnePerLine: true
// AllowAllConstructorInitializersOnNextLine: true
MyClass::MyClass()
    : member0(0), member1(2) {}
  • false:
// ConstructorInitializerAllOnOneLineOrOnePerLine: true
// AllowAllConstructorInitializersOnNextLine: false
MyClass::MyClass()
    : member0(0),
      member1(2) {}

AllowAllParametersOfDeclarationOnNextLine

型: bool

関数宣言のパラメータが1行に収まらない場合、BinPackParameters が false の場合でも括弧の後で改行した場合にすべてのパラメータが収まるならば、次の行にすべてのパラメータを置くかどうかを指定する。

  • true:
// BinPackParameters: false
// AllowAllParametersOfDeclarationOnNextLine: true
void function(
    int a, int b, int c, int d, int e);
  • false:
// BinPackParameters: false
// AllowAllParametersOfDeclarationOnNextLine: false
void function(int a,
              int b,
              int c,
              int d,
              int e);

AllowShortBlocksOnASingleLine

型: bool

短い文は1行に書くことを許可するかどうかを指定する。

  • true: 許可する。
// AllowShortBlocksOnASingleLine: true
if (a) { return; }
  • false: 許可する。
// AllowShortBlocksOnASingleLine: false
if (a) {
    return;
}

AllowShortCaseLabelsOnASingleLine

短い case ラベルを一行に書くことを許可するかどうかを指定する。

型: bool

  • true: 許可する。
// AllowShortCaseLabelsOnASingleLine: true
switch (var) {
case 1: break;
case 2: return;
}
  • false: 許可しない。
// AllowShortCaseLabelsOnASingleLine: false
switch (var) {
case 1:
    break;
case 2:
    return;
}

AllowShortFunctionsOnASingleLine

短い関数を一行に書くことを許可するかどうかを指定する。

型: enum (None, InlineOnly, Empty, Inline, All)

  • None: 許可しない。
// AllowShortFunctionsOnASingleLine: None
class MyClass {
    void function() {
        int a = 0;
    }
};
void function() {
    int a = 0;
}
void emptyFuction() {
}
  • InlineOnly: クラス内で定義されたインライン関数のみ許可する。
// AllowShortFunctionsOnASingleLine: Inline
class MyClass {
    void function() { int a = 0; }
};
void function() {
    int a = 0;
}
void emptyFuction() {}
  • Empty: 空の関数のみ許可する。
// AllowShortFunctionsOnASingleLine: Empty
class MyClass {
    void function() {
        int a = 0;
    }
};
void function() {
    int a = 0;
}
void emptyFuction() {}
  • Inline: クラス内で定義されたインライン関数及び空の関数のみ許可する。
// AllowShortFunctionsOnASingleLine: Inline
class MyClass {
    void function() { int a = 0; }
};
void function() {
    int a = 0;
}
void emptyFuction() {}
  • All: すべての関数で許可する。
// AllowShortFunctionsOnASingleLine: All
class MyClass {
    void function() { int a = 0; }
};
void function() { int a = 0; }
void emptyFuction() {}

AllowShortIfStatementsOnASingleLine

型: enum (Never, WithoutElse, Always)

短い if 文を一行に書くことを許可するかどうかを指定する。

  • Never: 許可しない。
// AllowShortIfStatementsOnASingleLine: Never
// if 文のみ
if (a)
    printf("if");

// else 付きの if 文
if (b)
    printf("if");
else
    printf("else");
  • WithoutElse: else がない場合は許可する。
// AllowShortIfStatementsOnASingleLine: WithoutElse
// if 文のみ
if (a) printf("if");

// else 付きの if 文
if (b)
    printf("if");
else
    printf("else");
  • Always: 常に許可する。
// AllowShortIfStatementsOnASingleLine: Always
// if 文のみ
if (a) printf("if");

// else 付きの if 文
if (b) printf("if");
else
    printf("else");

AllowShortLambdasOnASingleLine

型: enum (None, Empty, Inline, All)

短いラムダ関数を一行に書くことを許可するかどうかを指定する。

  • None: 許可しない。
// 空のラムダ関数
auto lambda1 = [](int a) {
};
// ラムダ関数
auto lambda2 = [](int a) {
    return a;
};
// インラインのラムダ関数
std::sort(a.begin(), a.end(), [](int x, int y) {
    return x < y;
});
  • Empty: 空の場合は許可する。
// 空のラムダ関数
auto lambda1 = [](int a) {};
// ラムダ関数
auto lambda2 = [](int a) {
    return a;
};
// インラインのラムダ関数
std::sort(a.begin(), a.end(), [](int x, int y) {
    return x < y;
});
  • Inline: インライン関数の場合は許可する。
// 空のラムダ関数
auto lambda1 = [](int a) {
};
// ラムダ関数
auto lambda2 = [](int a) {
    return a;
};
// インラインのラムダ関数
std::sort(a.begin(), a.end(),
          [](int x, int y) { return x < y; });
  • All: 常に許可する。
// 空のラムダ関数
auto lambda1 = [](int a) {};
// ラムダ関数
auto lambda2 = [](int a) { return a; };
// インラインのラムダ関数
std::sort(a.begin(), a.end(),
          [](int x, int y) { return x < y; });

AllowShortLoopsOnASingleLine

型: bool

短いループ文を一行に書くことを許可するかどうかを指定する。

  • true: 許可する。
// AllowShortLoopsOnASingleLine : true
for (;;) printf("loop");
while (true) printf("loop");
  • false: 許可しない。
// AllowShortLoopsOnASingleLine : false
for (;;)
    printf("loop");

while (true)
    printf("loop");

AlwaysBreakAfterDefinitionReturnType

型: enum (None, DAll, DTopLevel)

deprecated のため、省略

AlwaysBreakAfterReturnType

型: enum (None, All, TopLevel, AllDefinitions, TopLevelDefinitions)

関数宣言及び定義の戻り値の後の改行方法について指定する。

  • None: 改行しない。
// AlwaysBreakAfterDefinitionReturnType : None
class MyClass {
    // クラス内の関数定義
    int function() {}
};
// 関数宣言
int function();
// 関数定義
int function() {}
  • All: 常に改行する。
// AlwaysBreakAfterDefinitionReturnType : All
class MyClass {
    // クラス内の関数定義
    int
    function() {}
};
// 関数宣言
int
function();
// 関数定義
int
function() {}
  • TopLevel: トップレベルの関数宣言及び定義のみ改行する。
// AlwaysBreakAfterDefinitionReturnType : TopLevel
class MyClass {
    // クラス内の関数定義
    int function() {}
};
// 関数宣言
int
function();
// 関数定義
int
function() {}
  • AllDefinitions: 関数定義のみ改行する。
// AlwaysBreakAfterDefinitionReturnType : AllDefinitions
class MyClass {
    // クラス内の関数定義
    int
    function() {}
};
// 関数宣言
int function();
// 関数定義
int
function() {}
  • TopLevelDefinitions: トップレベルの関数定義のみ改行する。
// AlwaysBreakAfterDefinitionReturnType : TopLevelDefinitions
class MyClass {
    // クラス内の関数定義
    int function() {}
};
// 関数宣言
int function();
// 関数定義
int
function() {}

AlwaysBreakBeforeMultilineStrings

型: bool

複数行の文字リテラルの前で改行するかどうかを指定する。

  • true: 改行する。
// AlwaysBreakBeforeMultilineStrings: true
str =
    "Hello"
    "World";
  • false: 改行しない。
// AlwaysBreakBeforeMultilineStrings: false
str = "Hello"
      "World";

AlwaysBreakTemplateDeclarations

型: enum (No, MultiLine, Yes)

テンプレート宣言の後、改行するかどうかを指定する。

  • No: 改行しない。
// AlwaysBreakTemplateDeclarations: No
template <typename T> T foo() {}
template <typename T> T foo(int aaaaaaaaaaaaaaaaaaaaa,
                            int bbbbbbbbbbbbbbbbbbbbb) {}
  • MultiLine: 次の行が複数行に渡っている場合は、改行する。
// AlwaysBreakTemplateDeclarations: MultiLine
template <typename T> T foo() {}
template <typename T>
T foo(int aaaaaaaaaaaaaaaaaaaaa,
      int bbbbbbbbbbbbbbbbbbbbb) {}
  • Yes: 常に改行する。
// AlwaysBreakTemplateDeclarations: Yes
template <typename T>
T foo() {}
template <typename T>
T foo(int aaaaaaaaaaaaaaaaaaaaa,
      int bbbbbbbbbbbbbbbbbbbbb) {}

BinPackArguments

型: bool

関数呼び出しで改行する必要がある場合、引数は1行または各行に1つになるようにするかどうかを指定する。

  • true: 引数は1行または各行に1つになるようにしない。
// BinPackArguments: true
function(int arg1, int arg2,
         int arg3);
  • false: 引数は1行または各行に1つになるようにする。
// BinPackArguments: false
function(int parameter1,
         int parameter2,
         int parameter3);

BinPackParameters

型: bool

関数宣言及び定義で改行する必要がある場合、パラメータは1行または各行に1つになるようにするかどうかを指定する。

  • true: 引数は1行または各行に1つになるようにしない。
void function(parameter1, parameter2,
              parameter3);
  • false: 引数は1行または各行に1つになるようにする。
void function(parameter1,
              parameter2,
              parameter3);

BraceWrapping

BreakBeforeBraces を Custom とした場合、以下のように入れ子で改行の細かい設定が行える。

BreakBeforeBraces: Custom
BraceWrapping:
    AfterCaseLabel: true
AfterCaseLabel

ケースラベルの後の波括弧を改行するかどうかを指定する。

  • true: 改行する。
switch (var) {
case 1:
{
    break;
}
case 2:
{
    return;
}
}
  • false: 改行しない。
switch (var) {
case 1: {
    break;
}
case 2: {
    return;
}
}
AfterClass

クラス名の後の波括弧を改行するかどうかを指定する。

  • true: 改行する。
class foo
{
};
  • false: 改行しない。
class foo {};
AfterControlStatement

if/for/while/switch などの制御構文の波括弧を改行するかどうかを指定する。

  • true: 改行する。
if (foo())
{
} else
{}
for (int i = 0; i < 10; ++i)
{}
  • false: 改行しない。
if (foo()) {
} else {
}
for (int i = 0; i < 10; ++i) {
}
AfterEnum

列挙体名の後の波括弧を改行するかどうかを指定する。

  • true: 改行する。
enum X : int { A, B };
  • false: 改行しない。
enum X : int
{
    A,
    B
};
AfterFunction

関数定義の名前の後の波括弧を改行するかどうかを指定する。

  • true: 改行する。
void foo()
{
  bar();
  bar2();
}
  • false: 改行しない。
void foo() {
  bar();
  bar2();
}
AfterNamespace

namespace の後の波括弧は改行するかどうかを指定する。

  • true: 改行する。
namespace
{
int foo();
int bar();
}
  • false: 改行しない。
namespace {
int foo();
int bar();
}
AfterStruct

構造体名の後の波括弧は改行するかどうかを指定する。

  • true: 改行する。
namespace
struct foo
{
    int x;
};
  • false: 改行しない。
struct foo {
    int x;
};
AfterUnion

共用体名の後の波括弧は改行するかどうかを指定する。

  • true: 改行する。
union foo
{
  int x;
}
  • false: 改行しない。
union foo {
    int x;
}
  • AfterExternBlock

extern 名の後の波括弧は改行するかどうかを指定する。

  • true: 改行する。
extern "C"
{
    int foo();
}
  • false: 改行しない。
extern "C" {
int foo();
}
BeforeCatch:

catch の前で改行するかどうかを指定する。

  • true: 改行する。
try {
    foo();
}
catch () {
}
  • false: 改行しない。
try {
    foo();
} catch () {
}
BeforeElse

else の前で改行するかどうかを指定する。

  • true: 改行する。
if (foo()) {
}
else {
}
  • false: 改行しない。
if (foo()) {
} else {
}
IndentBraces

改行した波括弧はインデントするかどうかを指定する。

  • true: インデントする。
    if (foo()) {
    }
    else {
    }
  • false: 改行しない。
if (foo()) {
}
else {
}
SplitEmptyFunction

空の関数の波括弧を改行するかどうかを指定する。
この設定は、関数定義が1行に収まらない場合かつ AfterFunction: true を指定して、開始波括弧が改行されている場合のみ有効である。

  • true: 改行する。
void foo()
{
}
  • false: 改行しない。
void foo()
{}
SplitEmptyRecord

空の構造体、クラス、共用体の波括弧を改行するかどうかを指定する。
この設定は、AfterClass: true を指定して、開始波括弧が改行されている場合のみ有効である。

  • true: 改行する。
class Foo
{
}
  • false: 改行しない。
class Foo
{}
SplitEmptyNamespace

空の名前空間の波括弧を改行するかどうかを指定する。
この設定は、AfterNamespace: true を指定して、開始波括弧が改行されている場合のみ有効である。

  • true: 改行する。
namespace Foo
{
}
  • false: 改行しない。
namespace Foo {}

BreakBeforeBinaryOperators

型: enum (None, NonAssignment, All)

改行する必要がある場合、2項演算子の前で改行方法を指定する。

  • None: 2項演算子の前で改行しない。
// BreakBeforeBinaryOperators: None
int longNameVariable =
    longNameVariable1 +
    longNameVariable2 +
    longNameVariable3;
// BreakBeforeBinaryOperators: NonAssignment
int longNameVariable =
    longNameVariable1
    + longNameVariable2
    + longNameVariable3;
// BreakBeforeBinaryOperators: All
int longNameVariable
    = longNameVariable1
      + longNameVariable2
      + longNameVariable3;

BreakBeforeBraces

型: enum (Attach, Linux, Mozilla, Attach, Stroustrup, catch, Allman, GNU, WebKit, Attach, Custom)

  • Attach:
// BreakBeforeBraces: Attach
try {
  foo();
} catch () {
}
void foo() { bar(); }
class foo {};
if (foo()) {
} else {
}
enum X : int { A, B };
// BreakBeforeBraces: Linux
try {
  foo();
} catch () {
}
void foo() { bar(); }
class foo
{
};
if (foo()) {
} else {
}
enum X : int { A, B };
// BreakBeforeBraces: Mozilla
try {
  foo();
} catch () {
}
void foo() { bar(); }
class foo
{
};
if (foo()) {
} else {
}
enum X : int { A, B };
// BreakBeforeBraces: Stroustrup
try {
  foo();
} catch () {
}
void foo() { bar(); }
class foo
{
};
if (foo()) {
} else {
}
enum X : int
{
  A,
  B
};
  • Allman:
// BreakBeforeBraces: Allman
try {
  foo();
}
catch () {
}
void foo() { bar(); }
class foo {
};
if (foo()) {
}
else {
}
enum X : int { A, B };
// BreakBeforeBraces: GNU
try
  {
    foo();
  }
catch ()
  {
  }
void foo() { bar(); }
class foo
{
};
if (foo())
  {
  }
else
  {
  }
enum X : int
{
  A,
  B
};
// BreakBeforeBraces: WebKit
try {
  foo();
} catch () {
}
void foo() { bar(); }
class foo {
};
if (foo()) {
} else {
}
enum X : int { A, B };
  • Attach:

  • Custom:

BreakBeforeBraces を Custom とした場合、BraceWrapping に以下のように記述することで個々の構文に対して細かく改行方法を設定できる。

# Example of usage:
BreakBeforeBraces: Custom
BraceWrapping:
    AfterEnum: true
    AfterStruct: false
    SplitEmptyFunction: false

BreakBeforeTernaryOperators

型: bool

改行が必要な場合、3項間演算子の「?」「:」の前で改行するかどうかを指定する。

  • true: 改行する。
// BreakBeforeTernaryOperators: true
veryVeryLongVariableName
    ? firstVeryVeryLongVariableName1
    : firstVeryVeryLongVariableName2;
  • false: 改行しない。
// BreakBeforeTernaryOperators: false
veryVeryLongVariableName ?
    firstVeryVeryLongVariableName1 :
    firstVeryVeryLongVariableName2;

BreakConstructorInitializers

型: enum (BeforeColon, BeforeComma, AfterColon)

改行が必要な場合、コンストラクタ初期化の改行方法を指定する。

  • BeforeColon: コロンの前で改行する。
// BreakConstructorInitializers: BeforeColon
Constructor()
    : initializer1(),
      initializer2()
{}
  • BeforeComma: コロン及びカンマの前で改行する。
// BreakConstructorInitializers: BeforeComma
Constructor()
    : initializer1()
    , initializer2()
  • AfterColon: コロン及びカンマの後で改行する。
// BreakConstructorInitializers: AfterColon
Constructor() :
    initializer1(),
    initializer2()
{}

BreakInheritanceList

型: enum (BeforeColon, BeforeComma, AfterColon)

改行が必要な場合、継承リストの改行方法を指定する。

  • BeforeColon: コロンの前で改行する。
class MyClass : BaseClass1,
                BaseClass2,
                BaseClass3 {};
  • BeforeComma: コロン及びカンマの前で改行する。
class MyClass
    : BaseClass1
    , BaseClass2
    , BaseClass3 {};
  • AfterColon: コロン及びカンマの後で改行する。
class MyClass :
    BaseClass1,
    BaseClass2,
    BaseClass3 {};

BreakStringLiterals

型: bool

改行が必要な場合、文字リテラルを自動で改行するかどうかを指定する。

フォーマット前

str = "text text text text text text text text text";
  • true: 改行する。
// BreakStringLiterals: true
str = "text text text text text "
      "texttext text text";
  • false: 改行しない。
// BreakStringLiterals: false
str = "text text text text text text text text text";

ColumnLimit

型: unsigned

1行の最大文字数を指定する。0 を設定した場合は制限なしを意味する。

CommentPragmas

型: string

改行しないコメントを正規表現で指定する。

// CommentPragmas: "^ Dont break"

// Dont break text text text text text.text
int var1;

// text text text text text text text
// text.text
int var2;

CompactNamespaces

型: bool

連続した名前空間宣言を同じ行に置くかどうかを指定する。

  • true: 同じ行に置く。
namespace Foo { namespace Bar {
}}
  • false: 同じ行に置かない。
namespace Foo {
namespace Bar {
}
}

ConstructorInitializerAllOnOneLineOrOnePerLine

型: bool

改行する必要がある場合、コンストラクタ初期化子は1行または各行に1つになるようにするかどうかを指定する。

  • true: 1行または各行に1つになるようにする。
Constructor()
    : initializer1(),
      initializer2(),
      initializer3()
{
}
  • false: 1行または各行に1つになるようにしない。
Constructor()
    : initializer1(), initializer2(),
      initializer3()
{
}

ConstructorInitializerIndentWidth

型: unsigned

コンストラクタ初期化を改行する場合のインデントの幅を指定する。

// ConstructorInitializerIndentWidth: 2
Constructor()
  : initializer1(), initializer2()
{
}
// ConstructorInitializerIndentWidth: 4
Constructor()
    : initializer1(), initializer2()
{
}

ContinuationIndentWidth

型: unsigned

1つの文を改行する場合のインデントの幅を指定する。

// ContinuationIndentWidth: 2
int i =
  longFunction(arg);
// ContinuationIndentWidth: 4
int i =
    longFunction(arg);

Cpp11BracedListStyle

型: bool

一様初期化子で括弧の前後に空白を入れるかどうかを指定する。

  • true: 空白を入れない。
// Cpp11BracedListStyle: true
vector<int> x{1, 2, 3, 4};
  • false: 空白を入れる。
// Cpp11BracedListStyle: false
vector<int> x{ 1, 2, 3, 4 };

DerivePointerAlignment

型: bool

true の場合、PointerAlignment の設定に関わらず、参照やポインタの空白をどちらにするかはコードから自動的に判断する。

DisableFormat

型: bool

true の場合、フォーマットは行わない。

ExperimentalAutoDetectBinPacking

型: bool

true の場合、引数を伴う関数宣言、関数呼び出しで1行に1つの引数を配置するかどうかをコードから自動で判断する。

FixNamespaceComments

型: bool

名前空間の終了閉じ括弧後にコメントを追加するかどうか指定する。

フォーマット前

namespace a {
foo();
}
  • true: 名前空間の終了閉じ括弧後にコメントを追加する。
// FixNamespaceComments: true
namespace a {
foo();
} // namespace a;
  • false: 名前空間の終了閉じ括弧後にコメントを追加しない。
// FixNamespaceComments: false
namespace a {
foo();
}

ForEachMacros

型: string のリスト

foreach として扱うマクロの一覧を指定する。

フォーマット前

// ForEachMacros: ""
std::for_each(v.begin(), v.end(),
              mutate());

フォーマット後

// ForEachMacros: "for_each"
std::for_each(v.begin(), v.end(), mutate());
// ForEachMacros: ""
std::for_each(v.begin(), v.end(),
              mutate());

TypenameMacros

型: string のリスト

型として扱うマクロの一覧を指定する。

IncludeBlocks

型: enum (Preserve, IMerge, #include, Regroup, IncludeCategories)

include ディレクティブのソート方法を指定する。

フォーマット前

#include "b.h"

#include <lib/main.h>
#include "a.h"
  • Preserve: ブロックごとにソートする。
#include "b.h"

#include "a.h"
#include <lib/main.h>
  • Merge: 各ブロックはマージして、ソートする。
#include "a.h"
#include "b.h"
#include <lib/main.h>
  • Regroup: 各ブロックはマージして、ソートし、その後、自動でグループ分けしてブロックに分ける。
#include "a.h"
#include "b.h"

#include <lib/main.h>
  • IncludeCategories

型: IncludeCategory のリスト

include ディレクティブをグループ分けする際の設定を記述する。

IncludeIsMainRegex

型: string

include ディレクティブをグループ分けする際の設定を記述する。

IndentCaseLabels

型: bool

case ラベルをインデントするかどうかを指定する。

  • true: インデントする。
switch (flag) {
    case 1:
        foo();
        break;
    default:
        bar();
}
  • false: インデントしない。
switch (flag) {
case 1:
    foo();
    break;
default:
    bar();
}

IndentPPDirectives

型: enum (None, AfterHash, BeforeHash)

プリプロセッサディレクトリのインデント方法を指定する。

  • None: インデントしない。
// IndentPPDirectives: None
#if FOO
#if BAR
#include <foo>
#endif
#endif
  • AfterHash: # の前でインデントする。
// IndentPPDirectives: AfterHash
#if FOO
#  if BAR
#    include <foo>
#  endif
#endif
  • BeforeHash: # の前でインデントする。
// IndentPPDirectives: BeforeHash
#if FOO
    #if BAR
        #include <foo>
    #endif
#endif

IndentWidth

型: unsigned

インデントの幅を指定する。

IndentWrappedFunctionNames

型: bool

関数の宣言及び定義で改行が必要な場合、改行後にインデントを入れるかどうかを指定する。

  • true: インデントを入れる。
// IndentWrappedFunctionNames: true
LoooooooooooooooooooooooooooooooooooooooongReturnType
    LoooooooooooooooooooooooooooooooongFunctionDeclaration();
  • false: インデントを入れない。
// IndentWrappedFunctionNames: false
LoooooooooooooooooooooooooooooooooooooooongReturnType
LoooooooooooooooooooooooooooooooongFunctionDeclaration();

KeepEmptyLinesAtTheStartOfBlocks

型: bool

ブロック開始後の空行を許可するかどうかを指定する。

  • true: 許可する。
// KeepEmptyLinesAtTheStartOfBlocks: true
if (foo) {

    bar();
}
  • false: 許可しない。
// KeepEmptyLinesAtTheStartOfBlocks: false
if (foo) {
    bar();
}

Language

型: enum (None, Cpp, CSharp, Java, JavaScript, ObjC, Proto, TableGen, TextProto)

フォーマット対象の言語を指定する。

MacroBlockBegin

型: string

マクロブロックの開始を指定する。

// MacroBlockBegin: "^FOO_BEGIN|^BAR_BEGIN"
// MacroBlockEnd: "^FOO_END|^BAR_END"
FOO_BEGIN
    foo();
    BAR_BEGIN
        bar();
    BAR_END
FOO_END
// 設定なし
FOO_BEGIN
foo();
BAR_BEGIN
bar();
BAR_END
FOO_END

MacroBlockEnd

型: string

マクロブロックの終了を指定する。

// MacroBlockBegin: "^FOO_BEGIN|^BAR_BEGIN"
// MacroBlockEnd: "^FOO_END|^BAR_END"
FOO_BEGIN
    foo();
    BAR_BEGIN
        bar();
    BAR_END
FOO_END
// 設定なし
FOO_BEGIN
foo();
BAR_BEGIN
bar();
BAR_END
FOO_END

MaxEmptyLinesToKeep

型: unsigned

フォーマット時に連続した空行を何行許可するかどうかを指定する。

フォーマット前

if (foo) {




    bar();
}

フォーマット後

// MaxEmptyLinesToKeep: 0
if (foo) {
    bar();
}
// MaxEmptyLinesToKeep: 2
if (foo) {


    bar();
}

NamespaceIndentation

型: enum (None, Inner, All)

名前空間のインデント方法を指定する。

  • None: インデントしない。
// NamespaceIndentation: None
namespace out {
int i;
namespace in {
int i;
}
}
  • Inner: 内部の名前空間のみインデントする。
// NamespaceIndentation: Inner
namespace out {
int i;
namespace in {
    int i;
}
}
// NamespaceIndentation: All
namespace out {
    int i;
    namespace in {
        int i;
    }
}

NamespaceMacros

型: string のリスト

名前空間として扱うマクロの一覧を指定する。

PointerAlignment

型: enum (Left, Right, Middle)

ポインタ及び参照の前後の空白挿入方法を指定する。

  • Left: 左側に空白を入れる。
// PointerAlignment: Left
int* a;
  • Right: 右側に空白を入れる。
// PointerAlignment: Right
int *a;
  • Middle: 左側及び右側に空白を入れる。
// PointerAlignment: Middle
int * a;

ReflowComments

型: bool

コメントを最大カラム数に応じて、自動で改行するかどうか指定する。

フォーマット前

// comment comment comment comment comment comment
/* comment comment comment comment comment comment */
  • true: 自動で改行する。
// ReflowComments: true
// comment comment comment comment
// comment comment
/* comment comment comment comment
 * comment comment */
  • true: 自動で改行しない。
// ReflowComments: false
// comment comment comment comment comment comment
/* comment comment comment comment comment comment */

SortIncludes

型: bool

include ディレクティブをソートするかどうかを指定する。

フォーマット前

#include "b.h"
#include "a.h"
  • true: ソートする。
// SortIncludes: true
#include "a.h"
#include "b.h"
  • false: ソートしない。
// SortIncludes: false
#include "b.h"
#include "a.h"

SortUsingDeclarations

型: bool

using ディレクティブをソートするかどうかを指定する。

フォーマット前

using std::cout;
using std::cin;
  • true: ソートする。
// SortUsingDeclarations: true
using std::cin;
using std::cout;
  • false: ソートしない。
// SortUsingDeclarations: false
using std::cout;
using std::cin;

SpaceAfterCStyleCast

型: bool

C 言語形式のキャストの後に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpaceAfterCStyleCast: true
(int) i;
  • false: 空白を入れない。
// SpaceAfterCStyleCast: false
(int)i;

SpaceAfterLogicalNot

否定演算子の後に空白を入れるかどうかを指定する。

型: bool

  • true: 空白を入れる。
! flag;
  • false: 空白を入れない。
!flag;

SpaceAfterTemplateKeyword

型: bool

template キーワードの後に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpaceAfterTemplateKeyword: true
template <int> void foo();
  • false: 空白を入れない。
// SpaceAfterTemplateKeyword: false
template<int> void foo();

SpaceBeforeAssignmentOperators

型: bool

代入演算子の前に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpaceBeforeAssignmentOperators: true
int a = 5;
a += 42
  • false: 空白を入れない。
// SpaceBeforeAssignmentOperators: false
int a= 5;
a+= 42

SpaceBeforeCpp11BracedList

型: bool

初期化子リストの前に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
Foo foo {bar};
Foo {};
vector<int> {1, 2, 3};
new int[3] {1, 2, 3};
  • false: 空白を入れない。
Foo foo{bar};
Foo{};
vector<int>{1, 2, 3};
new int[3]{1, 2, 3};

SpaceBeforeCtorInitializerColon

型: bool

コンストラクタ初期化子のコロンの前に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
Foo::Foo() : a(a) {}
  • false: 空白を入れない。
Foo::Foo(): a(a) {}

SpaceBeforeInheritanceColon

継承リストのコロンの前に空白を入れるかどうかを指定する。

型: bool

  • true: 空白を入れる。
class Foo : Bar {}
  • false: 空白を入れない。
class Foo: Bar {}

SpaceBeforeParens

型: enum (Never, ControlStatements, NonEmptyParentheses, Always)

丸括弧の前に空白を入れるかどうかを指定する。

  • Never: 空白を入れない。
// SpaceBeforeParens: Never
void function();
if(flag) {
    return;
}
  • ControlStatements: if 及び for などの制御構文の場合のみ空白を入れる。
// SpaceBeforeParens: ControlStatements
void function();
if (flag) {
    return;
}
  • NonEmptyParentheses: 空の括弧でない場合は空白を入れる。
// SpaceBeforeParens: ControlStatements
void function (int a, int b, int c);
void function();
if (flag) {
    return;
}
  • Always: 空白を入れる。
// SpaceBeforeParens: Always
void function ();
if(flag) {
    return;
}

SpaceBeforeRangeBasedForLoopColon

型: bool

範囲 for のコロンの前に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
for (auto v : values) {}
  • false: 空白を入れない。
for(auto v: values) {}

SpaceInEmptyParentheses

型: bool

空の丸括弧に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpaceInEmptyParentheses: true
void f( );
  • false: 空白を入れない。
// SpaceInEmptyParentheses: false
void f();

SpacesBeforeTrailingComments

型: unsigned

コメント (//) の前の空白数を指定する。

// SpacesBeforeTrailingComments: 0
void f( );// comment
// SpacesBeforeTrailingComments: 4
void f( );    // comment

SpacesInAngles

型: bool

カギ括弧内の開始及び終了に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpacesInAngles: true
static_cast< int >(arg);
  • false: 空白を入れない。
// SpacesInAngles: false
static_cast<int>(arg);

SpacesInCStyleCastParentheses

型: bool

C言語形式のキャストの丸括弧内に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpacesInCStyleCastParentheses: true
x = ( int )y
  • false: 空白を入れない。
// SpacesInCStyleCastParentheses: false
x = (int)y

SpacesInParentheses

型: bool

丸括弧に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpacesInParentheses: true
void f( int arg1, int arg2 );
  • false: 空白を入れない。
// SpacesInParentheses: false
void f(int arg1, int arg2);

SpacesInSquareBrackets

型: bool

四角括弧の開始及び終了に空白を入れるかどうかを指定する。

  • true: 空白を入れる。
// SpacesInSquareBrackets: true
int array[ 5 ];
  • false: 空白を入れない。
// SpacesInSquareBrackets: false
int array[5];

Standard

型: enum (Cpp03, Cpp11, Auto)

C++03 では、テンプレート引数を入れ子にした場合、右シフト演算子や入力演算子と区別するために、閉じ括弧が連続する場合は空白が必要である。
C++11 からはその場合でも空白は不要になったので、どちらの形式に合わせるかをここで指定する。

  • Cpp03: C++03 に準拠する。
// Standard: Cpp03
std::vecotr<std::vector<int> > vec;
  • Cpp11: C++11 に準拠する。
// Standard: Cpp11
std::vecotr<std::vector<int>> vec;
  • Auto: C++03 か C++11 かを自動で判断する。

StatementMacros

型: string のリスト

完結した文を表すマクロの一覧を定義する。

TabWidth

タブ1つの幅を指定する。

型: unsigned

UseTab

型: enum (Never, ForIndentation, ForContinuationAndIndentation, Always)

タブを使用するかどうかを指定する。

  • Never: タブ文字を使用しない。
  • ForIndentation: インデントにのみ、タブ文字を使用する。
  • ForContinuationAndIndentation: インデント及び文の途中の改行 (関数名が長いので途中で改行した場合など) にのみ使用する。
  • Always: 常にタブ文字を使用する。