C++ Core Guidelines タイトル日本語訳

[C++ Core Guidelines](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)の各ルールのタイトルの日本語訳です。

* 間違いを見つけた場合は編集してもらえると助かります
* Core Guidelinesがそれなりに高頻度で更新されているので、以下のルールのリストや原文は古い可能性があります
    * ただし、Core Guidelinesは機械的にチェックして警告を出すことも行われているので、ルールが消滅することは稀だと思われます

# [Abstact](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#abstract)

* [和訳](https://qiita.com/shohirose/items/bea42ec65b8aae871018#c-core-guidelines-abstract%E5%92%8C%E8%A8%B3)

# [In: Introduction](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#in-introduction) / 導入

(略)

# [P: Philosophy](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p-philosophy) / 指針

* [P.1: Express ideas directly in code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p1-express-ideas-directly-in-code)  
  (アイデアをコードで直接表現する)
* [P.2: Write in ISO Standard C++](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p2-write-in-iso-standard-c)  
  (ISO標準C++で書く)
* [P.3: Express intent](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p3-express-intent)  
  (意図を表現する)
* [P.4: Ideally, a program should be statically type safe](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p4-ideally-a-program-should-be-statically-type-safe)  
  (理想的には、プログラムは静的に型安全であるべきである)
* [P.5: Prefer compile-time checking to run-time checking](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p5-prefer-compile-time-checking-to-run-time-checking)  
  (実行時よりコンパイル時にチェックする)
* [P.6: What cannot be checked at compile time should be checkable at run time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p6-what-cannot-be-checked-at-compile-time-should-be-checkable-at-run-time)  
  (コンパイル時にチェックできないものは、実行時にチェックできなければならない)
* [P.7: Catch run-time errors early](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p7-catch-run-time-errors-early)  
  (実行時エラーを早めにキャッチする)
* [P.8: Don't leak any resources](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p8-dont-leak-any-resources)  
  (リソースを漏らさない)
* [P.9: Don’t waste time or space](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p9-dont-waste-time-or-space)  
  (時間とメモリーを無駄にしない)
* [P.10: Prefer immutable data to mutable data](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p10-prefer-immutable-data-to-mutable-data)  
  (不変なデータを優先する)
* [P.11: Encapsulate messy constructs, rather than spreading through the code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p11-encapsulate-messy-constructs-rather-than-spreading-through-the-code)  
  (ごちゃごちゃしたオブジェクトの構築をコード中に散らかすのではなくカプセル化する)
* [P.12: Use supporting tools as appropriate](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p12-use-supporting-tools-as-appropriate)  
  (支援ツールを適切に使う)
* [P.13: Use support libraries as appropriate](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#p13-use-support-libraries-as-appropriate)  
  (支援ライブラリを適切に使う)

# [I: Interfaces](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i-interfaces) / インターフェース

* [I.1: Make interfaces explicit](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i1-make-interfaces-explicit)  
  (インターフェースは明示的にする)
* [I.2: Avoid non-const global variables](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i2-avoid-non-const-global-variables)  
  (非constグローバル変数を避ける)
* [I.3: Avoid singletons](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i3-avoid-singletons)  
  (シングルトンを避ける)
* [I.4: Make interfaces precisely and strongly typed](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i4-make-interfaces-precisely-and-strongly-typed)  
  (インターフェースに詳細かつ強い型付けを与える)
* [I.5: State preconditions (if any)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i5-state-preconditions-if-any)  
  (事前条件があれば明示する)
* [I.6: Prefer Expects() for expressing preconditions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i6-prefer-expects-for-expressing-preconditions)  
  (事前条件を記述するのに`Expects()`を使う)
* [I.7: State postconditions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i7-state-postconditions)  
  (事後条件を明示する)
* [I.8: Prefer Ensures() for expressing postconditions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i8-prefer-ensures-for-expressing-postconditions)  
  (事後条件を明示するのに`Ensures()`を使う)
* [I.9: If an interface is a template, document its parameters using concepts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i9-if-an-interface-is-a-template-document-its-parameters-using-concepts)  
  (インターフェースがテンプレートの場合、引数にコンセプトで注釈をつける)
* [I.10: Use exceptions to signal a failure to perform a required task](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i10-use-exceptions-to-signal-a-failure-to-perform-a-required-task)  
  (必要な措置を講じるために失敗の通知には例外を使う)
* [I.11: Never transfer ownership by a raw pointer (T*) or reference (T&)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i11-never-transfer-ownership-by-a-raw-pointer-t-or-reference-t)  
  (決して生ポインタで所有権を渡さない)
* [I.12: Declare a pointer that must not be null as not_null](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i12-declare-a-pointer-that-must-not-be-null-as-not_null)  
  (nullになってはいけないポインターは、(GSLの)not_nullとして宣言する)
* [I.13: Do not pass an array as a single pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i13-do-not-pass-an-array-as-a-single-pointer)  
  (配列をポインター1つだけで渡さない)
* [I.22: Avoid complex initialization of global objects](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i22-avoid-complex-initialization-of-global-objects)  
  (グローバルオブジェクトの複雑な初期化は避ける)
* [I.23: Keep the number of function arguments low](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i23-keep-the-number-of-function-arguments-low)  
  (できるだけ引数の数は少なくする)
* [I.24: Avoid adjacent unrelated parameters of the same type](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i24-avoid-adjacent-parameters-of-the-same-type-when-changing-the-argument-order-would-change-meaning)  
  (同じ型の無関係な引数が隣接しないようにする)
* [I.25: Prefer abstract classes as interfaces to class hierarchies](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i25-prefer-abstract-classes-as-interfaces-to-class-hierarchies)  
  (クラス階層よりもインターフェースとしての抽象クラスを使う)
* [I.26: If you want a cross-compiler ABI, use a C-style subset](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i26-if-you-want-a-cross-compiler-abi-use-a-c-style-subset)  
  (コンパイラを跨ぐABIが必要なら、C言語の機能に絞ったサブセットを使う)
* [I.27: For stable library ABI, consider the Pimpl idiom](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i27-for-stable-library-abi-consider-the-pimpl-idiom)  
  (安定したライブラリのABIのためにPimplパターンの使用を検討する)
* [I.30: Encapsulate rule violations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#i30-encapsulate-rule-violations)  
  (ルール違反をカプセル化する)

# [F: Functions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f-functions) / 関数

## [F.def: Function definitions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#fdef-function-definitions) / 関数定義

* [F.1: "Package" meaningful operations as carefully named functions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f1-package-meaningful-operations-as-carefully-named-functions)  
  (意味のある一連の処理を関数に注意深く命名して、「まとめる」)
* [F.2: A function should perform a single logical operation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f2-a-function-should-perform-a-single-logical-operation)  
  (関数は論理的に1つの処理のみをするべきである)
* [F.3: Keep functions short and simple](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f3-keep-functions-short-and-simple)  
  (関数は短くシンプルに保つ)
* [F.4: If a function may have to be evaluated at compile time, declare it `constexpr`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f4-if-a-function-may-have-to-be-evaluated-at-compile-time-declare-it-constexpr)  
  (関数がコンパイル時に評価されうるなら、`constexpr`で宣言する)
* [F.5: If a function is very small and time-critical, declare it `inline`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f5-if-a-function-is-very-small-and-time-critical-declare-it-inline)  
  (関数が非常に小さく時間的制約が強ければ、`inline`で宣言する)
* [F.6: If your function may not throw, declare it `noexcept`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f6-if-your-function-may-not-throw-declare-it-noexcept)  
  (関数が例外を投げないなら、`noexcept`で宣言する)
* [F.7: For general use, take T* or T& arguments rather than smart pointers](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f7-for-general-use-take-t-or-t-arguments-rather-than-smart-pointers)  
  (一般的な用途の引数にはスマートポインタより普通のポインタまたは参照を使う)
* [F.8: Prefer pure functions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f8-prefer-pure-functions)  
  (関数はできるだけ純粋関数(副作用のない関数)にする)
* [F.9: Unused parameters should be unnamed](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f9-unused-parameters-should-be-unnamed)  
  (使用しない仮引数に名前を付けてはいけない)

## [F.call: Parameter passing](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#fcall-parameter-passing) / 引数・戻り値の受け渡し

### Parameter passing expression rules / 引数の表現のルール

* [F.15: Prefer simple and conventional ways of passing information](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f15-prefer-simple-and-conventional-ways-of-passing-information)  
  (情報を渡す方法はシンプルかつ一般的なものにする)
* [F.16: For "in" parameters, pass cheaply-copied types by value and others by reference to const](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f16-for-in-parameters-pass-cheaply-copied-types-by-value-and-others-by-reference-to-const)  
  (入力用引数は、安価にコピーできる型は値で渡し、それ以外はconst参照で渡す)
* [F.17: For "in-out" parameters, pass by reference to non-const](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f17-for-in-out-parameters-pass-by-reference-to-non-const)  
  (入出力用引数は非const参照で渡す)
* [F.19: For "forward" parameters, pass by `T&&` and only `std::forward` the parameter](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f19-for-forward-parameters-pass-by-tp-and-only-stdforward-the-parameter)  
  (転送する引数は`T&&`にして、引数を`std::forward`する)
* [F.20: For "out" output values, prefer return values to output parameters](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f20-for-out-output-values-prefer-return-values-to-output-parameters)  
  (値を返すには、出力用引数よりも戻り値を使う)
* [F.21: To return multiple "out" values, prefer returning a tuple or struct](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f21-to-return-multiple-out-values-prefer-returning-a-struct-or-tuple)  
  (複数の値を返すには、タプルか構造体を使う)
* [F.60: Prefer `T*` over `T&` when "no argument" is a valid option](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f60-prefer-t-over-t-when-no-argument-is-a-valid-option)  
  (「値なし」がありえるなら参照ではなくポインターを使う)

### Parameter passing semantic rules / 引数の意味論的なルール

* [F.22: Use `T*` or `owner<T*>` to designate a single object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f22-use-t-or-ownert-to-designate-a-single-object)  
  (1つのオブジェクトを指すのに`T*`か(GSLの)`owner<T*>`を使う)
* [F.23: Use a `not_null<T>` to indicate that "null" is not a valid value](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f23-use-a-not_nullt-to-indicate-that-null-is-not-a-valid-value)  
  (nullにならないことを示すのに(GSLの)`not_null<T>`を使う)
* [F.24: Use a `span<T>` or a `span_p<T>` to designate a half-open sequence](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f24-use-a-spant-or-a-span_pt-to-designate-a-half-open-sequence)  
  (半開区間を指すには(GSLの)`span<T>`か(GSLの)`span_p<T>`を使う)
* [F.25: Use a `zstring or` a `not_null<zstring>` to designate a C-style string](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f25-use-a-zstring-or-a-not_nullzstring-to-designate-a-c-style-string)  
  (C文字列を指すには(GSLの)`zstring`か(GSLの)`not_null<zstring>`を使う)
* [F.26: Use a `unique_ptr<T>` to transfer ownership where a pointer is needed](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f26-use-a-unique_ptrt-to-transfer-ownership-where-a-pointer-is-needed)  
  (所有権の移動には`unique_ptr<T>`を使用する)
* [F.27: Use a `shared_ptr<T>` to share ownership](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f27-use-a-shared_ptrt-to-share-ownership)  
  (所有権の共有には`shared_ptr<T>`を使用する)

### Value return semantic rules / 戻り値の意味論的なルール

* [F.42: Return a `T*` to indicate a position (only)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f42-return-a-t-to-indicate-a-position-only)  
  (位置を知らせる場合に限りポインターを返す)
* [F.43: Never (directly or indirectly) return a pointer or a reference to a local object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f43-never-directly-or-indirectly-return-a-pointer-or-a-reference-to-a-local-object)  
  (ローカルオブジェクトの参照やポインターを決して返さない)
* [F.44: Return a `T&` when copy is undesirable and "returning no object" isn’t needed](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f44-return-a-t-when-copy-is-undesirable-and-returning-no-object-isnt-needed)  
  (コピーが望ましくなく、「値なし」が必要なければ参照を返す)
* [F.45: Don’t return a `T&&`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f45-dont-return-a-t)  
  (右辺値参照を返さない)
* [F.46: `int` is the return type for `main()`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f46-int-is-the-return-type-for-main)  
  (`main()`の戻り値は`int`)
* [F.47: Return `T&` from assignment operators](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f47-return-t-from-assignment-operators)  
  (代入演算子は非const参照を返す)
* [F.48: Don’t return std::move(local)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f48-dont-return-stdmovelocal)  
  (ローカル変数をmoveして返さない)

## Other function rules / その他の関数のルール

* [F.50: Use a lambda when a function won’t do (to capture local variables, or to write a local function)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f50-use-a-lambda-when-a-function-wont-do-to-capture-local-variables-or-to-write-a-local-function)  
  (関数が上手くいかないときはラムダ式を使う(ローカル変数をキャプチャーするか、ローカル関数を書きたい場合))
* [F.51: Where there is a choice, prefer default arguments over overloading](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f51-where-there-is-a-choice-prefer-default-arguments-over-overloading)  
  (デフォルト引数とオーバーロードを選べるときはデフォルト引数を使う)
* [F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f52-prefer-capturing-by-reference-in-lambdas-that-will-be-used-locally-including-passed-to-algorithms)  
  (標準アルゴリズムへ渡す場合を含めて、ローカルで使われるラムダ式は参照キャプチャーを優先する)
* [F.53: Avoid capturing by reference in lambdas that will be used nonlocally, including returned, stored on the heap, or passed to another thread](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f53-avoid-capturing-by-reference-in-lambdas-that-will-be-used-non-locally-including-returned-stored-on-the-heap-or-passed-to-another-thread)  
  (ローカルスコープを超えて使用されるラムダ式では参照キャプチャーを避ける(関数から戻すもの、ヒープに取るもの、他のスレッドに渡すものなど))
* [F.54: If you capture `this`, capture all variables explicitly (no default capture)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f54-if-you-capture-this-capture-all-variables-explicitly-no-default-capture)  
  (`this`をキャプチャーするときは、すべての変数を明示的にキャプチャーする(デフォルトキャプチャーを使用しない))
* [F.55: Don’t use `va_arg` arguments](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f55-dont-use-va_arg-arguments)  
  (`va_arg`による可変長引数を使用しない)

# [C: Classes and class hierarchies](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c-classes-and-class-hierarchies) / クラスとクラス階層

* [C.1: Organize related data into structures (`struct`s or `class`es)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c1-organize-related-data-into-structures-structs-or-classes)  
  (関連するデータをクラスまたは構造体で組織化する)
* [C.2: Use `class` if the class has an invariant; use `struct` if the data members can vary independently](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c2-use-class-if-the-class-has-an-invariant-use-struct-if-the-data-members-can-vary-independently)  
  (クラスが不変条件を持つなら`class`を、メンバーが独立に変更できるなら`struct`を使う)
* [C.3: Represent the distinction between an interface and an implementation using a class](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c3-represent-the-distinction-between-an-interface-and-an-implementation-using-a-class)  
  (クラスを使ってインターフェースと実装の区別を表現する)
* [C.4: Make a function a member only if it needs direct access to the representation of a class](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c4-make-a-function-a-member-only-if-it-needs-direct-access-to-the-representation-of-a-class)  
  (クラスの内部表現(※privateメンバー)に直接アクセスする必要がある場合に限り、関数をメンバーにする)
* [C.5: Place helper functions in the same namespace as the class they support](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c5-place-helper-functions-in-the-same-namespace-as-the-class-they-support)  
  (ヘルパー関数は対象とするクラスと同じ名前空間に置く)
* [C.7: Don’t define a class or enum and declare a variable of its type in the same statement](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c7-dont-define-a-class-or-enum-and-declare-a-variable-of-its-type-in-the-same-statement)  
  (クラスなどの定義とその型の変数の宣言を1文で書かない)
* [C.8: Use class rather than struct if any member is non-public](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c8-use-class-rather-than-struct-if-any-member-is-non-public)  
  (publicではないメンバーがあるなら構造体ではなくクラスを使う)
* [C.9: Minimize exposure of members](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c9-minimize-exposure-of-members)  
  (メンバーの露出を最小限にする)

## [C.concrete: Concrete types](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cconcrete-concrete-types) / 具象型

* [C.10: Prefer concrete types over class hierarchies](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c10-prefer-concrete-types-over-class-hierarchies)  
  (クラス階層よりも具象クラスを使う)
* [C.11: Make concrete types regular](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c11-make-concrete-types-regular)  
  (具象型の振る舞いを一般的なものにする)
* [C.12: Don’t make data members const or references](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c12-dont-make-data-members-const-or-references)  
  (データメンバーを`const`または参照にしない)

## [C.ctor: Constructors, assignments, and destructors](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cctor-constructors-assignments-and-destructors) / コンストラクター、代入、デストラクター

### [C.defop: Default Operations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cdefop-default-operations) / デフォルトの操作

* [C.20: If you can avoid defining any default operations, do](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c20-if-you-can-avoid-defining-default-operations-do)  
  (できるだけデフォルトの操作を(自分で)定義しない)
* [C.21: If you define or `=delete` any default operation, define or `=delete` them all](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c21-if-you-define-or-delete-any-copy-move-or-destructor-function-define-or-delete-them-all)  
  (デフォルトの操作を1つでも(自分で)定義または削除するなら、残りも明示的に定義または削除する)
* [C.22: Make default operations consistent](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c22-make-default-operations-consistent)  
  (デフォルトの操作に一貫性を持たせる)

### [C.dtor: Destructors](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cdtor-destructors) / デストラクター

* [C.30: Define a destructor if a class needs an explicit action at object destruction](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c30-define-a-destructor-if-a-class-needs-an-explicit-action-at-object-destruction)  
  (オブジェクトの破棄において特別な処理が必要ならデストラクターを定義する)
* [C.31: All resources acquired by a class must be released by the class’s destructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c31-all-resources-acquired-by-a-class-must-be-released-by-the-classs-destructor)  
  (クラスが獲得したすべてのリソースをデストラクターで解放する)
* [C.32: If a class has a raw pointer (`T*`) or reference (`T&`), consider whether it might be owning](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c32-if-a-class-has-a-raw-pointer-t-or-reference-t-consider-whether-it-might-be-owning)  
  (生ポインターや参照をメンバーに持つなら、それらがオブジェクトを所有するか考慮する)
* [C.33: If a class has an owning pointer member, define or `=delete` a destructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c33-if-a-class-has-an-owning-pointer-member-define-a-destructor)  
  (オブジェクトを所有するポインターがメンバーにあるなら、デストラクターを定義または削除する)
* [C.35: A base class with a virtual function needs a virtual destructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c35-a-base-class-destructor-should-be-either-public-and-virtual-or-protected-and-non-virtual)  
  (仮想関数を持つ基底クラスは仮想デストラクターを持たなければならない)
* [C.36: A destructor may not fail](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c36-a-destructor-may-not-fail)  
  (デストラクターは失敗してはいけない)
* [C.37: Make destructors `noexcept`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c37-make-destructors-noexcept)  
  (デストラクターを`noexcept`にする)

### [C.ctor: Constructors](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cctor-constructors) / コンストラクター

* [C.40: Define a constructor if a class has an invariant](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c40-define-a-constructor-if-a-class-has-an-invariant)  
  (クラスが不変条件を持つ場合はコンストラクターを定義する)
* [C.41: A constructor should create a fully initialized object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c41-a-constructor-should-create-a-fully-initialized-object)  
  (コンストラクターはオブジェクトを完全に初期化すること)
* [C.42: If a constructor cannot construct a valid object, throw an exception](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c42-if-a-constructor-cannot-construct-a-valid-object-throw-an-exception)  
  (コンストラクターが正しいオブジェクトを構築できないときは例外を投げる)
* [C.43: Ensure that a copyable (value type) class has a default constructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c43-ensure-that-a-copyable-value-type-class-has-a-default-constructor)  
  (コピー可能なクラス(値型)にはデフォルトコンストラクターを持たせる)
* [C.44: Prefer default constructors to be simple and non-throwing](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c44-prefer-default-constructors-to-be-simple-and-non-throwing)  
  (デフォルトコンストラクターはシンプルかつ例外を投げないようにする)
* [C.45: Don’t define a default constructor that only initializes data members; use member initializers instead](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c45-dont-define-a-default-constructor-that-only-initializes-data-members-use-in-class-member-initializers-instead)  
  (データメンバーを初期化するだけのデフォルトコンストラクターを定義せず、メンバー初期化子を使用する)
* [C.46: By default, declare single-argument constructors `explicit`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c46-by-default-declare-single-argument-constructors-explicit)  
  (理由がない限り、1引数のコンストラクターは`explicit`にする)
* [C.47: Define and initialize member variables in the order of member declaration](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c47-define-and-initialize-member-variables-in-the-order-of-member-declaration)  
  (メンバー変数は宣言の順に定義し、初期化する)
* [C.48: Prefer in-class initializers to member initializers in constructors for constant initializers](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c48-prefer-in-class-initializers-to-member-initializers-in-constructors-for-constant-initializers)  
  (定数で初期化する場合、コンストラクターでのメンバー初期化子よりもクラス内メンバー初期化子を使う)
* [C.49: Prefer initialization to assignment in constructors](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c49-prefer-initialization-to-assignment-in-constructors)  
  (コンストラクター内では代入よりメンバー初期化子を使う)
* [C.50: Use a factory function if you need "virtual behavior" during initialization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c50-use-a-factory-function-if-you-need-virtual-behavior-during-initialization)  
  (初期化中に仮想関数的な動作をするにはファクトリー関数を使う)
* [C.51: Use delegating constructors to represent common actions for all constructors of a class](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c51-use-delegating-constructors-to-represent-common-actions-for-all-constructors-of-a-class)  
  (すべてのコンストラクターに共通する処理を表現するのには委譲コンストラクターを使う)
* [C.52: Use inheriting constructors to import constructors into a derived class that does not need further explicit initialization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c52-use-inheriting-constructors-to-import-constructors-into-a-derived-class-that-does-not-need-further-explicit-initialization)  
  (追加の初期化処理が必要ない場合は継承コンストラクターを使ってコンストラクターを派生クラスに取り込む)

### [C.copy: Copy and move](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#ccopy-copy-and-move) / コピーとムーブ

* [C.60: Make copy assignment non-virtual, take the parameter by const`&`, and return by non-const `&`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c60-make-copy-assignment-non-virtual-take-the-parameter-by-const-and-return-by-non-const)  
  (コピー代入演算子は非virtualにし、引数はconst参照で受け取り、返り値は非const参照にする)
* [C.61: A copy operation should copy](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c61-a-copy-operation-should-copy)  
  (コピー演算はコピーをしなければならない)
* [C.62: Make copy assignment safe for self-assignment](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c62-make-copy-assignment-safe-for-self-assignment)  
  (コピー代入演算子は自己代入しても問題ないようにする)
* [C.63: Make move assignment non-virtual, take the parameter by `&&`, and return by non-const`&`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c63-make-move-assignment-non-virtual-take-the-parameter-by--and-return-by-non-const-)  
  (ムーブ代入演算子は非virtualにし、引数は右辺値参照で受け取り、返り値は非const参照にする)
* [C.64: A move operation should move and leave its source in a valid state](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c64-a-move-operation-should-move-and-leave-its-source-in-a-valid-state)  
  (ムーブ操作によってムーブ元を無効な状態にしないこと)
* [C.65: Make move assignment safe for self-assignment](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c65-make-move-assignment-safe-for-self-assignment)  
  (ムーブ代入演算子は自己代入しても問題ないようにする)
* [C.66: Make move operations `noexcept`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c66-make-move-operations-noexcept)  
  (ムーブ操作を `noexcept`にする)
* [C.67: A polymorphic class should suppress copying](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c67-a-polymorphic-class-should-suppress-copying)  
  (ポリモーフィッククラスはコピーを禁止する)

### [C.other: Other default operation rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules) / その他のデフォルト操作のルール

* [C.80: Use `=default` if you have to be explicit about using the default semantics](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c80-use-default-if-you-have-to-be-explicit-about-using-the-default-semantics)  
  (デフォルトの動作が必要なら`=default`で実装する)
* [C.81: Use `=delete` when you want to disable default behavior (without wanting an alternative)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c81-use-delete-when-you-want-to-disable-default-behavior-without-wanting-an-alternative)  
  (デフォルトの動作を無効にするには`=delete`で実装を削除する)
* [C.82: Don’t call virtual functions in constructors and destructors](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c82-dont-call-virtual-functions-in-constructors-and-destructors)  
  (コンストラクターまたはデストラクターで仮想関数を呼ばない)
* [C.83: For value-like types, consider providing a noexcept swap function](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c83-for-value-like-types-consider-providing-a-noexcept-swap-function)  
  (値のような型には例外を投げないswap関数の実装を検討する)
* [C.84: A swap may not fail](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c84-a-swap-function-may-not-fail)  
  (swap関数は失敗しないようにする)
* [C.85: Make swap noexcept](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c85-make-swap-noexcept)  
  (swap関数は例外を投げないようにする)
* [C.86: Make == symmetric with respect of operand types and noexcept](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c86-make--symmetric-with-respect-to-operand-types-and-noexcept)  
  (それぞれのオペランドについて`==`を対称にする。`==`を`noexcept`にする)
* [C.87: Beware of `==` on base classes](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c87-beware-of--on-base-classes)  
  (基底クラスでの`==`に注意する)
* [C.89: Make a `hash` `noexcept`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c89-make-a-hash-noexcept)  
  (`hash`をnoexceptにする)
* [C.90: Rely on constructors and assignment operators, not `memset` and `memcpy`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rc-memset)  
  (`memset`や`memcpy`ではなくコンストラクターと代入演算子を信頼する)

## [C.con: Containers and other resource handles](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#ccon-containers-and-other-resource-handles) / コンテナとその他のリソースハンドル

* [C.100: Follow the STL when defining a container](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c100-follow-the-stl-when-defining-a-container)  
  (コンテナを定義するときはSTLに従う)
* [C.101: Give a container value semantics](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c101-give-a-container-value-semantics)  
  (コンテナには値のセマンティクスを持たせる)
* [C.102: Give a container move operations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c102-give-a-container-move-operations)  
  (コンテナはムーブ可能にする)
* [C.103: Give a container an initializer list constructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c103-give-a-container-an-initializer-list-constructor)  
  (コンテナには初期化リストを受け取るコンストラクタを持たせる)
* [C.104: Give a container a default constructor that sets it to empty](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c104-give-a-container-a-default-constructor-that-sets-it-to-empty)  
  (コンテナはデフォルト初期化可能にし、デフォルト値を空とする)
* [C.109: If a resource handle has pointer semantics, provide * and ->](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c109-if-a-resource-handle-has-pointer-semantics-provide--and--)  
  (リソースハンドルがポインターセマンティクスを持つなら、`*`と`->`の演算子を定義する)

## [C.lambdas: Function objects and lambdas](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#clambdas-function-objects-and-lambdas) / 関数オブジェクトとラムダ

F.50, F.52, F.53, ES.28の引用のみ

* [F.50: Use a lambda when a function won’t do (to capture local variables, or to write a local function)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f50-use-a-lambda-when-a-function-wont-do-to-capture-local-variables-or-to-write-a-local-function)  
  (関数が上手くいかないときはラムダ式を使う(ローカル変数をキャプチャーするか、ローカル関数を書きたい場合))
* [F.52: Prefer capturing by reference in lambdas that will be used locally, including passed to algorithms](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f52-prefer-capturing-by-reference-in-lambdas-that-will-be-used-locally-including-passed-to-algorithms)  
  (標準アルゴリズムへ渡す場合を含めて、ローカルで使われるラムダ式は参照キャプチャーを優先する)
* [F.53: Avoid capturing by reference in lambdas that will be used nonlocally, including returned, stored on the heap, or passed to another thread](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#f53-avoid-capturing-by-reference-in-lambdas-that-will-be-used-non-locally-including-returned-stored-on-the-heap-or-passed-to-another-thread)  
  (ローカルスコープを超えて使用されるラムダ式では参照キャプチャーを避ける(関数から戻すもの、ヒープに取るもの、他のスレッドに渡すものなど))
* [ES.28: Use lambdas for complex initialization, especially of const variables](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es28-use-lambdas-for-complex-initialization-especially-of-const-variables)  
  (複雑な初期化にはラムダ式を使う(特にconst変数の場合))

## [C.hier: Class hierarchies (OOP)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#chier-class-hierarchies-oop) / クラス階層

* [C.120: Use class hierarchies to represent concepts with inherent hierarchical structure (only)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c120-use-class-hierarchies-to-represent-concepts-with-inherent-hierarchical-structure-only)  
  (クラス階層は元々階層的な構造を備えているものを表現するためだけに用いる)
* [C.121: If a base class is used as an interface, make it a pure abstract class](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c121-if-a-base-class-is-used-as-an-interface-make-it-a-pure-abstract-class)  
  (インターフェースとして使う基底クラスは純粋抽象クラスにする)
* [C.122: Use abstract classes as interfaces when complete separation of interface and implementation is needed](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c122-use-abstract-classes-as-interfaces-when-complete-separation-of-interface-and-implementation-is-needed)  
  (インターフェースと実装の分離が必要なら抽象クラスをインターフェースとして使う)

### [C.hierclass: Designing classes in a hierarchy](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#chierclass-designing-classes-in-a-hierarchy) / 階層的なクラスの設計

* [C.126: An abstract class typically doesn’t need a constructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c126-an-abstract-class-typically-doesnt-need-a-constructor)  
  (抽象クラスは普通はコンストラクタを必要としない)
* [C.127: A class with a virtual function should have a virtual or protected destructor](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c127-a-class-with-a-virtual-function-should-have-a-virtual-or-protected-destructor)  
  (仮想関数を持つクラスは`virtual`または`protected`なデストラクタを持つこと)
* [C.128: Virtual functions should specify exactly one of `virtual`, `override`, or `final`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c128-virtual-functions-should-specify-exactly-one-of-virtual-override-or-final)  
  (仮想関数には`virtual`, `override`, `final`のうち1つだけを必ず指定すること)
* [C.129: When designing a class hierarchy, distinguish between implementation inheritance and interface inheritance](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c129-when-designing-a-class-hierarchy-distinguish-between-implementation-inheritance-and-interface-inheritance)  
  (クラス階層を設計するときは、実装の継承とインターフェースの継承を区別する)
* [C.130: For making deep copies of polymorphic classes prefer a virtual clone function instead of copy construction/assignment](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c130-for-making-deep-copies-of-polymorphic-classes-prefer-a-virtual-clone-function-instead-of-copy-constructionassignment)  
  (多相クラスのディープコピーを実装するときは、コピーコンストラクタ/代入よりも仮想clone関数を使う)
* [C.131: Avoid trivial getters and setters](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c131-avoid-trivial-getters-and-setters)  
  (自明なゲッター/セッターを避ける)
* [C.132: Don’t make a function virtual without reason](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c132-dont-make-a-function-virtual-without-reason)  
  (訳もなく仮想関数にしない)
* [C.133: Avoid protected data](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c133-avoid-protected-data)  
  (メンバー変数をprotectedにしない)
* [C.134: Ensure all non-const data members have the same access level](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c134-ensure-all-non-const-data-members-have-the-same-access-level)  
  (すべての非constなメンバー変数を同じアクセスレベルにする)
* [C.135: Use multiple inheritance to represent multiple distinct interfaces](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c135-use-multiple-inheritance-to-represent-multiple-distinct-interfaces)  
  (複数の独立したインターフェースを表すのには多重継承を使う)
* [C.136: Use multiple inheritance to represent the union of implementation attributes](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c136-use-multiple-inheritance-to-represent-the-union-of-implementation-attributes)  
  (複数の実装の共通部分を表すのには多重継承を使う)
* [C.137: Use virtual bases to avoid overly general base classes](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c137-use-virtual-bases-to-avoid-overly-general-base-classes)  
  (基底クラスを過度に一般化することを防ぐには仮想基底クラスを使う)
* [C.138: Create an overload set for a derived class and its bases with `using`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c138-create-an-overload-set-for-a-derived-class-and-its-bases-with-using)  
  (派生クラスと基底クラスに跨るオーバーロード集合を作るのには`using`を使う)
* [C.139: Use `final` sparingly](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c139-use-final-on-classes-sparingly)  
  (`final`は控えめに使う)
* [C.140: Do not provide different default arguments for a virtual function and an overrider](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c140-do-not-provide-different-default-arguments-for-a-virtual-function-and-an-overrider)  
  (仮想関数とそのオーバーライダーに異なるデフォルト引数を与えない)

### [C.hier-access: Accessing objects in a hierarchy](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#chier-access-accessing-objects-in-a-hierarchy) / 階層的なクラスへのアクセス

* [C.145: Access polymorphic objects through pointers and references](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c145-access-polymorphic-objects-through-pointers-and-references)  
  (多相的オブジェクトにはポインターと参照を通じてアクセスする)
* [C.146: Use `dynamic_cast` where class hierarchy navigation is unavoidable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c146-use-dynamic_cast-where-class-hierarchy-navigation-is-unavoidable)  
  (クラス階層を下っていくことが避けられない場合は`dynamic_cast`を使用する)
* [C.147: Use `dynamic_cast` to a reference type when failure to find the required class is considered an error](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c147-use-dynamic_cast-to-a-reference-type-when-failure-to-find-the-required-class-is-considered-an-error)  
  (キャストの失敗がエラーだと考えられる場合は、参照型に`dynamic_cast`を使用する)
* [C.148: Use `dynamic_cast` to a pointer type when failure to find the required class is considered a valid alternative](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c148-use-dynamic_cast-to-a-pointer-type-when-failure-to-find-the-required-class-is-considered-a-valid-alternative)  
  (キャストの失敗が有効な場合の1つと考えられる場合は、ポインター型に`dynamic_cast`を使用する)
* [C.149: Use `unique_ptr` or `shared_ptr` to avoid forgetting to delete objects created using new](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c149-use-unique_ptr-or-shared_ptr-to-avoid-forgetting-to-delete-objects-created-using-new)  
  (`new`で作成したオブジェクトを確実に解放するために、`unique_ptr` や `shared_ptr`を使用する)
* [C.150: Use `make_unique()` to construct objects owned by `unique_ptr`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c150-use-make_unique-to-construct-objects-owned-by-unique_ptrs)  
  (`unique_ptr`で保持するオブジェクトは`make_unique()`で作る)
* [C.151: Use `make_shared()` to construct objects owned by `shared_ptr`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c151-use-make_shared-to-construct-objects-owned-by-shared_ptrs)  
  (`shared_ptr`で保持するオブジェクトは`make_shared()`で作る)
* [C.152: Never assign a pointer to an array of derived class objects to a pointer to its base](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c152-never-assign-a-pointer-to-an-array-of-derived-class-objects-to-a-pointer-to-its-base)  
  (派生クラスの配列へのポインターを基本クラスのポインターへ代入しない)
* [C.153: Prefer virtual function to casting](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c153-prefer-virtual-function-to-casting)  
  (キャストではなく仮想関数を使う)

## [C.over: Overloading and overloaded operators](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cover-overloading-and-overloaded-operators) / オーバーロードと演算子オーバーロード

* [C.160: Define operators primarily to mimic conventional usage](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c160-define-operators-primarily-to-mimic-conventional-usage)  
  (演算子は慣例的な用法に倣って定義する)
* [C.161: Use nonmember functions for symmetric operators](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c161-use-non-member-functions-for-symmetric-operators)  
  (対称な演算子は非メンバー関数として定義する)
* [C.162: Overload operations that are roughly equivalent](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c162-overload-operations-that-are-roughly-equivalent)  
  (おおよそ等価な操作はオーバーロードする)
* [C.163: Overload only for operations that are roughly equivalent](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c163-overload-only-for-operations-that-are-roughly-equivalent)  
  (おおよそ等価な操作だけをオーバーロードする)
* [C.164: Avoid implicit conversion operators](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c164-avoid-implicit-conversion-operators)  
  (暗黙の変換演算子を避ける)
* [C.165: Use `using` for customization points](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c165-use-using-for-customization-points)  
  (カスタマイゼーションポイントには`using`を使う)
* [C.166: Overload unary `&` only as part of a system of smart pointers and references](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c166-overload-unary--only-as-part-of-a-system-of-smart-pointers-and-references)  
  (単項`&`演算子はスマートポインターと参照の系を作る場合のみオーバーロードする)
* [C.167: Use an operator for an operation with its conventional meaning](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c167-use-an-operator-for-an-operation-with-its-conventional-meaning)  
  (慣習的に演算子が用いられている操作には演算子を使う)
* [C.168: Define overloaded operators in the namespace of their operands](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c168-define-overloaded-operators-in-the-namespace-of-their-operands)  
  (オーバーロードする演算子はオペランドの名前空間で定義する)
* [C.170: If you feel like overloading a lambda, use a generic lambda](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c170-if-you-feel-like-overloading-a-lambda-use-a-generic-lambda)  
  (ラムダ式をオーバーロードしたいときは、ジェネリックラムダを使う)

## [C.union: Unions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cunion-unions) / 共用体

* [C.180: Use unions to save memory](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c180-use-unions-to-save-memory)  
  (共用体を使ってメモリーを節約する)
* [C.181: Avoid "naked" unions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c181-avoid-naked-unions)  
  (裸の共用体を避ける)
* [C.182: Use anonymous unions to implement tagged unions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c182-use-anonymous-unions-to-implement-tagged-unions)  
  (無名共用体を使ってタグ付けされた共用体を実装する)
* [C.183: Don’t use a union for type punning](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c183-dont-use-a-union-for-type-punning)  
  (共用体を型変換のために使わない) 

# [Enum: Enumerations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum-enumerations) / 列挙

* [Enum.1: Prefer enumerations over macros](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum1-prefer-enumerations-over-macros)  
  (マクロより列挙型を使う)
* [Enum.2: Use enumerations to represent sets of related named constants](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum2-use-enumerations-to-represent-sets-of-related-named-constants)  
  (名前の付いた定数のセットを表すのに列挙型を使う)
* [Enum.3: Prefer enum classes over "plain" enums](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum3-prefer-class-enums-over-plain-enums)  
  (素の`enum`より`enum class`を使う)
* [Enum.4: Define operations on enumerations for safe and simple use](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum4-define-operations-on-enumerations-for-safe-and-simple-use)  
  (列挙型に演算子を定義して安全かつシンプルに使えるようにする)
* [Enum.5: Don’t use ALL_CAPS for enumerators](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum5-dont-use-all_caps-for-enumerators)  
  (列挙型の名前を全て大文字の名前にしない)
* [Enum.6: Avoid unnamed enumerations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum6-avoid-unnamed-enumerations)  
  (無名の列挙型を避ける)
* [Enum.7: Specify the underlying type of an enumeration only when necessary](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum7-specify-the-underlying-type-of-an-enumeration-only-when-necessary)  
  (列挙型の基本型は必要な場合のみ与える)
* [Enum.8: Specify enumerator values only when necessary](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum8-specify-enumerator-values-only-when-necessary)  
  (列挙型の値は必要な場合のみ与える)

# [R: Resource management](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r-resource-management) / リソース管理

* [R.1: Manage resources automatically using resource handles and RAII (Resource Acquisition Is Initialization)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r1-manage-resources-automatically-using-resource-handles-and-raii-resource-acquisition-is-initialization)  
  (リソースはハンドルとRAIIを使って自動で管理する)
* [R.2: In interfaces, use raw pointers to denote individual objects (only)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r2-in-interfaces-use-raw-pointers-to-denote-individual-objects-only)  
  (インターフェースでは、生ポインターは1個のオブジェクトを表すためだけに使う)
* [R.3: A raw pointer (a `T*`) is non-owning](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r3-a-raw-pointer-a-t-is-non-owning)  
  (生ポインタで所有権を表さない)
* [R.4: A raw reference (a `T&`) is non-owning](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r4-a-raw-reference-a-t-is-non-owning)  
  (参照で所有権を表さない)
* [R.5: Prefer scoped objects, don’t heap-allocate unnecessarily](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r5-prefer-scoped-objects-dont-heap-allocate-unnecessarily)  
  (スコープのあるオブジェクトを使い、不必要にヒープを使わない)
* [R.6: Avoid non-const global variables](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r6-avoid-non-const-global-variables)  
  (非constなグローバル変数を避ける)

## [R.alloc: Allocation and deallocation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#ralloc-allocation-and-deallocation) / 確保と解放

* [R.10: Avoid `malloc()` and `free()`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r10-avoid-malloc-and-free)  
  (`malloc()`と`free()`を避ける)
* [R.11: Avoid calling `new` and `delete` explicitly](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r11-avoid-calling-new-and-delete-explicitly)  
  (明示的な`new`と`delete`を避ける)
* [R.12: Immediately give the result of an explicit resource allocation to a manager object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r12-immediately-give-the-result-of-an-explicit-resource-allocation-to-a-manager-object)  
  (明示的なリソース確保の結果を直ちに管理オブジェクトへ渡す)
* [R.13: Perform at most one explicit resource allocation in a single expression statement](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r13-perform-at-most-one-explicit-resource-allocation-in-a-single-expression-statement)  
  (1つの式文で行う明示的なリソース確保は最大でも1つにする)
* [R.14: Avoid `[]` parameters, prefer `span`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r14-avoid--parameters-prefer-span)  
  (引数の型に`[]`をつけるのを避け、`span`を使う)
* [R.15: Always overload matched allocation/deallocation pairs](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r15-always-overload-matched-allocationdeallocation-pairs)  
  (対応する確保と破棄を組でオーバーロードする)

## [R.smart: Smart pointers](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#rsmart-smart-pointers) / スマートポインター

* [R.20: Use `unique_ptr` or `shared_ptr` to represent ownership](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r20-use-unique_ptr-or-shared_ptr-to-represent-ownership)  
  (所有権を表すのに`unique_ptr`か`shared_ptr`を使う)
* [R.21: Prefer `unique_ptr` over `shared_ptr` unless you need to share ownership](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r21-prefer-unique_ptr-over-shared_ptr-unless-you-need-to-share-ownership)  
  (所有権の共有が必要でない限り`shared_ptr`より`unique_ptr`を使う)
* [R.22: Use `make_shared()` to make `shared_ptr`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r22-use-make_shared-to-make-shared_ptrs)  
  (`shared_ptr`の構築には`make_shared()`を使う)
* [R.23: Use `make_unique()` to make `unique_ptr`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r23-use-make_unique-to-make-unique_ptrs)  
  (`unique_ptr`の構築には`make_unique()`を使う)
* [R.24: Use `std::weak_ptr` to break cycles of `shared_ptr`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r24-use-stdweak_ptr-to-break-cycles-of-shared_ptrs)  
  (`shared_ptr`の循環を断つには`weak_ptr`を使う)
* [R.30: Take smart pointers as parameters only to explicitly express lifetime semantics](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r30-take-smart-pointers-as-parameters-only-to-explicitly-express-lifetime-semantics)  
  (引数にスマートポインタを取るのは寿命に関するセマンティクスを表現する時だけにする)
* [R.31: If you have non-std smart pointers, follow the basic pattern from std](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r31-if-you-have-non-std-smart-pointers-follow-the-basic-pattern-from-std)  
  (非標準のスマートポインタを使うとしても、標準の基本的なパターンに従う)
* [R.32: Take a `unique_ptr<widget>` parameter to express that a function assumes ownership of a widget](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r32-take-a-unique_ptrwidget-parameter-to-express-that-a-function-assumes-ownership-of-a-widget)  
  (関数が`widget`の所有権を取る場合は`unique_ptr<widget>`型の引数を取る)
* [R.33: Take a `unique_ptr<widget>&` parameter to express that a function reseats the widget](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r33-take-a-unique_ptrwidget-parameter-to-express-that-a-function-reseats-thewidget)  
  (関数が`widget`を置き換える場合は`unique_ptr<widget>&`型の引数を取る)
* [R.34: Take a `shared_ptr<widget>` parameter to express that a function is part owner](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r34-take-a-shared_ptrwidget-parameter-to-express-that-a-function-is-part-owner)  
  (関数が`widget`を共同所有する場合は`shared_ptr<widget>`型の引数を取る)
* [R.35: Take a `shared_ptr<widget>&` parameter to express that a function might reseat the shared pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r35-take-a-shared_ptrwidget-parameter-to-express-that-a-function-might-reseat-the-shared-pointer)  
  (関数が`shared_ptr`を置き換える可能性がある場合は`shared_ptr<widget>&`型の引数を取る)
* [R.36: Take a `const shared_ptr<widget>&` parameter to express that it might retain a reference count to the object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r36-take-a-const-shared_ptrwidget-parameter-to-express-that-it-might-retain-a-reference-count-to-the-object-)  
  (関数が`shared_ptr`の参照カウントを変えない可能性がある場合は`const shared_ptr<widget>&`型の引数を取る)
* [R.37: Do not pass a pointer or reference obtained from an aliased smart pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r37-do-not-pass-a-pointer-or-reference-obtained-from-an-aliased-smart-pointer)  
  (スマートポインターのエイリアスから得たポインターや参照を渡さない)

# [ES: Expressions and statements](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es-expressions-and-statements) / 式と文

* [ES.1: Prefer the standard library to other libraries and to "handcrafted code"](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es1-prefer-the-standard-library-to-other-libraries-and-to-handcrafted-code)  
  (自作や非標準の物より、標準ライブラリを使う)
* [ES.2: Prefer suitable abstractions to direct use of language features](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es2-prefer-suitable-abstractions-to-direct-use-of-language-features)  
  (言語機能を直接使うより適切な抽象化を使う)

## [ES.dcl: Declarations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#esdcl-declarations) / 宣言

* [ES.5: Keep scopes small](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es5-keep-scopes-small)  
  (スコープを小さく保つ)
* [ES.6: Declare names in for-statement initializers and conditions to limit scope](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es6-declare-names-in-for-statement-initializers-and-conditions-to-limit-scope)  
  (条件部やfor文の初期化部で名前を宣言し、スコープを制限する)
* [ES.7: Keep common and local names short, and keep uncommon and nonlocal names longer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es7-keep-common-and-local-names-short-and-keep-uncommon-and-non-local-names-longer)  
  (一般的で局所的な名前は短く、そうでない名前は長くする)
* [ES.8: Avoid similar-looking names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es8-avoid-similar-looking-names)  
  (似たような見た目の名前を避ける)
* [ES.9: Avoid `ALL_CAPS` names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es9-avoid-all_caps-names)  
  (すべて大文字の名前を避ける)
* [ES.10: Declare one name (only) per declaration](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es10-declare-one-name-only-per-declaration)  
  (1つの宣言で1つの名前だけを宣言する)
* [ES.11: Use `auto` to avoid redundant repetition of type names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es11-use-auto-to-avoid-redundant-repetition-of-type-names)  
  (冗長な型名の繰り返しを避けるために`auto`を使用する)
* [ES.12: Do not reuse names in nested scopes](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es12-do-not-reuse-names-in-nested-scopes)  
  (入れ子になったスコープの内側で名前を再利用しない)
* [ES.20: Always initialize an object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es20-always-initialize-an-object)  
  (オブジェクトは常に初期化する)
* [ES.21: Don’t introduce a variable (or constant) before you need to use it](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es21-dont-introduce-a-variable-or-constant-before-you-need-to-use-it)  
  (必要になるまで変数や定数を導入しない)
* [ES.22: Don’t declare a variable until you have a value to initialize it with](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es22-dont-declare-a-variable-until-you-have-a-value-to-initialize-it-with)  
  (初期化するための値が揃うまで変数を宣言しない)
* [ES.23: Prefer the {}-initializer syntax](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es23-prefer-the--initializer-syntax)  
  (`{}`での初期化を優先的に使う)
* [ES.24: Use a `unique_ptr<T>` to hold pointers](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es24-use-a-unique_ptrt-to-hold-pointers)  
  (ポインターを保持するのに`unique_ptr<T>`を使う)
* [ES.25: Declare an object const or constexpr unless you want to modify its value later on](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es25-declare-an-object-const-or-constexpr-unless-you-want-to-modify-its-value-later-on)  
  (後で変更する必要がない限り、オブジェクトはconstかconstexprにする)
* [ES.26: Don’t use a variable for two unrelated purposes](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es26-dont-use-a-variable-for-two-unrelated-purposes)  
  (変数を無関係な別の目的に使わない)
* [ES.27: Use std::array or stack_array for arrays on the stack](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es27-use-stdarray-or-stack_array-for-arrays-on-the-stack)  
  (配列には`std::array`か(GSLの)`stack_array`を使う)
* [ES.28: Use lambdas for complex initialization, especially of const variables](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es28-use-lambdas-for-complex-initialization-especially-of-const-variables)  
  (複雑な初期化にはラムダ式を使う(特にconst変数の場合))
* [ES.30: Don’t use macros for program text manipulation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es30-dont-use-macros-for-program-text-manipulation)  
  (マクロでプログラムのテキストを変更しない)
* [ES.31: Don’t use macros for constants or "functions"](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es31-dont-use-macros-for-constants-or-functions)  
  (定数や関数形式のためにマクロを使用しない)
* [ES.32: Use `ALL_CAPS` for all macro names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es32-use-all_caps-for-all-macro-names)  
  (マクロの名前はすべて大文字にする)
* [ES.33: If you must use macros, give them unique names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es33-if-you-must-use-macros-give-them-unique-names)  
  (マクロを使わざるを得ないのであれば、ユニークな名前を付ける)
* [ES.34: Don’t define a (C-style) variadic function](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es34)  
  (Cの可変引数関数を定義しない)

## [ES.expr: Expressions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#esexpr-expressions) / 式

* [ES.40: Avoid complicated expressions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es40-avoid-complicated-expressions)  
  (複雑な式を避ける)
* [ES.41: If in doubt about operator precedence, parenthesize](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es41-if-in-doubt-about-operator-precedence-parenthesize)  
  (演算子の優先順位が疑わしい場合、カッコを使う)
* [ES.42: Keep use of pointers simple and straightforward](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es42-keep-use-of-pointers-simple-and-straightforward)  
  (ポインターの使用箇所は単純明快にする))
* [ES.43: Avoid expressions with undefined order of evaluation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es43-avoid-expressions-with-undefined-order-of-evaluation)  
  (未定義の実行順序を持つ式を避ける)
* [ES.44: Don’t depend on order of evaluation of function arguments](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es44-dont-depend-on-order-of-evaluation-of-function-arguments)  
  (引数の評価順に依存しない)
* [ES.45: Avoid "magic constants"; use symbolic constants](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es45-avoid-magic-constants-use-symbolic-constants)  
  (マジックナンバーを避け、名前の付いた定数を使う)
* [ES.46: Avoid narrowing conversions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es46-avoid-lossy-narrowing-truncating-arithmetic-conversions)  
  (縮小変換を避ける)
* [ES.47: Use `nullptr` rather than `0` or `NULL`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es47-use-nullptr-rather-than-0-or-null)  
  (`0`や`NULL`よりも`nullptr`を使う)
* [ES.48: Avoid casts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es48-avoid-casts)  
  (キャストを避ける)
* [ES.49: If you must use a cast, use a named cast](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es49-if-you-must-use-a-cast-use-a-named-cast)  
  (キャストを使わざるを得ないのであれば、名前の付いたキャストを使う)
* [ES.50: Don’t cast away const](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es50-dont-cast-away-const)  
  (`const`を外さない)
* [ES.55: Avoid the need for range checking](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es55-avoid-the-need-for-range-checking)  
  (範囲チェックの必要性を避ける)
* [ES.56: Write `std::move()` only when you need to explicitly move an object to another scope](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es56-write-stdmove-only-when-you-need-to-explicitly-move-an-object-to-another-scope)  
  (`std::move()`は、オブジェクトを他のスコープへ明示的にムーブする必要があるときだけ書く)
* [ES.60: Avoid `new` and `delete` outside resource management functions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es60-avoid-new-and-delete-outside-resource-management-functions)  
  (リソースを管理する関数の中以外で`new`、`delete`を避ける)
* [ES.61: Delete arrays using `delete[]` and non-arrays using `delete`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es61-delete-arrays-using-delete-and-non-arrays-using-delete)  
  (配列は`delete[]`、それ以外のオブジェクトは`delete`で解放する)
* [ES.62: Don’t compare pointers into different arrays](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es62-dont-compare-pointers-into-different-arrays)  
  (異なる配列の中を指すポインターを比較しない)
* [ES.63: Don’t slice](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es63-dont-slice)  
  (スライシングをしない)
* [ES.64: Use the `T{e}` notation for construction](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es64-use-the-tenotation-for-construction)  
  (構築には`T{e}`の記法を使う)
* [ES.65: Don’t dereference an invalid pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es65-dont-dereference-an-invalid-pointer)  
  (無効なポインターをデリファレンスしない)

## [ES.stmt: Statements](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#esstmt-statements) / 文

* [ES.70: Prefer a switch-statement to an if-statement when there is a choice](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es70-prefer-a-switch-statement-to-an-if-statement-when-there-is-a-choice)  
  (選べるならif文よりswitch文を使う)
* [ES.71: Prefer a range-for-statement to a for-statement when there is a choice](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es71-prefer-a-range-for-statement-to-a-for-statement-when-there-is-a-choice)  
  (選べるならfor文より範囲for文を使う)
* [ES.72: Prefer a for-statement to a while-statement when there is an obvious loop variable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es72-prefer-a-for-statement-to-a-while-statement-when-there-is-an-obvious-loop-variable)  
  (明確なループ変数があるならwhile文よりfor文を使う)
* [ES.73: Prefer a while-statement to a for-statement when there is no obvious loop variable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es73-prefer-a-while-statement-to-a-for-statement-when-there-is-no-obvious-loop-variable)  
  (明確なループ変数がないならfor文よりwhile文を使う)
* [ES.74: Prefer to declare a loop variable in the initializer part of a for-statement](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es74-prefer-to-declare-a-loop-variable-in-the-initializer-part-of-a-for-statement)  
  (ループ変数をfor文の初期化部で宣言する)
* [ES.75: Avoid do-statements](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es75-avoid-do-statements)  
  (do文を避ける)
* [ES.76: Avoid goto](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es76-avoid-goto)  
  (gotoを避ける)
* [ES.77: Minimize the use of break and continue in loops](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es77-minimize-the-use-of-break-and-continue-in-loops)  
  (ループでの`break`と`continue`の使用を最小限にする)
* [ES.78: Always end a non-empty case with a break](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es78-dont-rely-on-implicit-fallthrough-in-switch-statements)  
  (空でないcaseは常にbreakで終える)
* [ES.79: Use `default` to handle common cases (only)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es79-use-default-to-handle-common-cases-only)  
  (`default`は一般の場合を扱う場合のみ使用する)
* [ES.84: Don’t try to declare a local variable with no name](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es84-dont-try-to-declare-a-local-variable-with-no-name)  
  (名前のないローカル変数を宣言しない)
* [ES.85: Make empty statements visible](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es85-make-empty-statements-visible)  
  (空文を見えるようにする)
* [ES.86: Avoid modifying loop control variables inside the body of raw for-loops](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es86-avoid-modifying-loop-control-variables-inside-the-body-of-raw-for-loops)  
  (ループ変数をfor文の本体で変更することを避ける)
* [ES.87: Don’t add redundant `==` or `!=` to conditions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es87-dont-add-redundant--or--to-conditions)  
  (条件に冗長な`==`や`!=`を書かない)

## [Arithmetic](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#arithmetic) / 算術

* [ES.100: Don’t mix signed and unsigned arithmetic](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es100-dont-mix-signed-and-unsigned-arithmetic)  
  (符号ありと符号なしの計算を混在させない)
* [ES.101: Use unsigned types for bit manipulation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es101-use-unsigned-types-for-bit-manipulation)  
  (ビット演算には符号なしの型を使う)
* [ES.102: Use signed types for arithmetic](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es102-use-signed-types-for-arithmetic)  
  (算術演算には符号ありの型を使う)
* [ES.103: Don’t overflow](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es103-dont-overflow)  
  (オーバーフローさせない)
* [ES.104: Don’t underflow](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es104-dont-underflow)  
  (アンダーフローさせない)
* [ES.105: Don’t divide by zero](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es105-dont-divide-by-zero)  
  (0で割らない)
* [ES.106: Don’t try to avoid negative values by using unsigned](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es106-dont-try-to-avoid-negative-values-by-using-unsigned)  
  (符号なしの型を使って負の数を避けようとしない)
* [ES.107: Don’t use unsigned for subscripts, prefer `gsl::index`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es107-dont-use-unsigned-for-subscripts-prefer-gslindex)  
  (添字に符号なしの型を使わず、`gsl::index`を使う)

# [Per: Performance](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per-performance) / パフォーマンス

* [Per.1: Don’t optimize without reason](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per1-dont-optimize-without-reason)  
  (訳もなく最適化しない)
* [Per.2: Don’t optimize prematurely](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per2-dont-optimize-prematurely)  
  (早すぎる最適化をしない)
* [Per.3: Don’t optimize something that’s not performance critical](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per3-dont-optimize-something-thats-not-performance-critical)  
  (パフォーマンス上重要でない部分を最適化しない)
* [Per.4: Don’t assume that complicated code is necessarily faster than simple code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per4-dont-assume-that-complicated-code-is-necessarily-faster-than-simple-code)  
  (複雑なコードがシンプルなコードより早いと思わない)
* [Per.5: Don’t assume that low-level code is necessarily faster than high-level code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per5-dont-assume-that-low-level-code-is-necessarily-faster-than-high-level-code)  
  (低レベルなコードが高レベルなコードより早いと思わない)
* [Per.6: Don’t make claims about performance without measurements](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per6-dont-make-claims-about-performance-without-measurements)  
  (計測せずに意見しない)
* [Per.7: Design to enable optimization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per7-design-to-enable-optimization)  
  (最適化できるように設計する)
* [Per.10: Rely on the static type system](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per10-rely-on-the-static-type-system)  
  (静的型システムを信頼する)
* [Per.11: Move computation from run time to compile time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per11-move-computation-from-run-time-to-compile-time)  
  (実行時処理をコンパイル時処理に変える)
* [Per.12: Eliminate redundant aliases](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per12-eliminate-redundant-aliases)  
  (冗長なエイリアスを除去する)
* [Per.13: Eliminate redundant indirections](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per13-eliminate-redundant-indirections)  
  (冗長な間接参照を除去する)
* [Per.14: Minimize the number of allocations and deallocations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per14-minimize-the-number-of-allocations-and-deallocations)  
  (確保と解放を最小限にする)
* [Per.15: Do not allocate on a critical branch](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per15-do-not-allocate-on-a-critical-branch)  
  (クリティカルブランチ上で確保しない)
* [Per.16: Use compact data structures](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per16-use-compact-data-structures)  
  (小さなデータ構造を使う)
* [Per.17: Declare the most used member of a time-critical struct first](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per17-declare-the-most-used-member-of-a-time-critical-struct-first)  
  (タイムクリティカルな構造体では最もよく使われるメンバーを最初に宣言する)
* [Per.18: Space is time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per18-space-is-time)  
  (空間は時間である)
* [Per.19: Access memory predictably](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per19-access-memory-predictably)  
  (メモリーへは予期できるようにアクセスする)
* [Per.30: Avoid context switches on the critical path](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#per30-avoid-context-switches-on-the-critical-path)  
  (クリティカルパス上でのコンテキストスイッチを避ける)

# [CP: Concurrency and parallelism](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp-concurrency-and-parallelism) / 並行・並列処理

* [CP.1: Assume that your code will run as part of a multi-threaded program](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp1-assume-that-your-code-will-run-as-part-of-a-multi-threaded-program)  
  (マルチスレッドプログラムの一部として実行される可能性を考慮する)
* [CP.2: Avoid data races](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp2-avoid-data-races)  
  (データ競合を避ける)
* [CP.3: Minimize explicit sharing of writable data](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp3-minimize-explicit-sharing-of-writable-data)  
  (書き込み可能なデータの明示的な共有を最小限にする)
* [CP.4: Think in terms of tasks, rather than threads](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp4-think-in-terms-of-tasks-rather-than-threads)  
  (スレッドよりもタスクで考える)
* [CP.8: Don’t try to use `volatile` for synchronization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp8-dont-try-to-use-volatile-for-synchronization)  
  (同期のために`volatile`を使おうとしない)
* [CP.9: Whenever feasible use tools to validate your concurrent code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp9-whenever-feasible-use-tools-to-validate-your-concurrent-code)  
  (並行処理のコードを検証するのにツールが使えるときは使う)

## [CP.con: Concurrency](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpcon-concurrency) / 並行処理

* [CP.20: Use RAII, never plain `lock()`/`unlock()`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp20-use-raii-never-plain-lockunlock)  
  (素の`lock()`/`unlock()`を避け、RAIIにする)
* [CP.21: Use `std::lock()` or `std::scoped_lock` to acquire multiple mutexes](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp21-use-stdlock-or-stdscoped_lock-to-acquire-multiple-mutexes)  
  (複数のミューテックスを獲得するのに`std::lock()`や`std::scoped_lock`を使う)
* [CP.22: Never call unknown code while holding a lock (e.g., a callback)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp22-never-call-unknown-code-while-holding-a-lock-eg-a-callback)  
  (ロックを持っている間、コールバックのような未知のコードを決して呼び出さない)
* [CP.23: Think of a joining `thread` as a scoped container](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp23-think-of-a-joining-thread-as-a-scoped-container)  
  (joinするスレッドをスコープ付きコンテナとみなす)
* [CP.24: Think of a `thread` as a global container](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp24-think-of-a-thread-as-a-global-container)  
  (スレッドをグローバルなコンテナとみなす)
* [CP.25: Prefer `gsl::joining_thread` over `std::thread`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp25-prefer-gsljoining_thread-over-stdthread)  
  (`std::thread`よりも`gsl::joining_thread`を使う)
* [CP.26: Don’t `detach()` a `thread`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp26-dont-detach-a-thread)  
  (スレッドを`detach()`しない)
* [CP.31: Pass small amounts of data between threads by value, rather than by reference or pointer](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp31-pass-small-amounts-of-data-between-threads-by-value-rather-than-by-reference-or-pointer)  
  (スレッド間では、参照やポインターを使うより値で少量のデータを渡す)
* [CP.32: To share ownership between unrelated threads use `shared_ptr`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp32-to-share-ownership-between-unrelated-threads-use-shared_ptr)  
  (無関係なスレッドの間で所有権を共有するには`shared_ptr`を使用する)
* [CP.40: Minimize context switching](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp40-minimize-context-switching)  
  (コンテキストスイッチを最小限にする)
* [CP.41: Minimize thread creation and destruction](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp41-minimize-thread-creation-and-destruction)  
  (スレッドの生成と破棄を最小限にする)
* [CP.42: Don’t wait without a condition](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp42-dont-wait-without-a-condition)  
  (無条件に待機しない)
* [CP.43: Minimize time spent in a critical section](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp43-minimize-time-spent-in-a-critical-section)  
  (クリティカルセクションへの滞在時間を最小限にする)
* [CP.44: Remember to name your `lock_guard`s and `unique_lock`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp44-remember-to-name-your-lock_guards-and-unique_locks)  
  (`lock_guard`や`unique_lock`には忘れずに名前を付ける(変数へ束縛する))
* [CP.50: Define a `mutex` together with the data it guards. Use `synchronized_value<T>` where possible](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp50-define-a-mutex-together-with-the-data-it-guards-use-synchronized_valuet-where-possible)  
  (ガードするデータとミューテックスを同時に宣言する。可能なら`synchronized_value<T>`を使う)

## [CP.par: Parallelism](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cppar-parallelism) / 並列処理

未定義

## [CP.mess: Message passing](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpmess-message-passing) / メッセージパッシング

* [CP.60: Use a `future` to return a value from a concurrent task](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp60-use-a-future-to-return-a-value-from-a-concurrent-task)  
  (並行するタスクから値を返すには`future`を使う)
* [CP.61: Use an `async()` to spawn a concurrent task](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp61-use-async-to-spawn-concurrent-tasks)  
  (並行タスクをスポーンするには`async()`を使う)

## [CP.vec: Vectorization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpvec-vectorization) / ベクトル化

未定義

## [CP.free: Lock-free programming](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpfree-lock-free-programming) / ロックフリープログラミング

* [CP.100: Don’t use lock-free programming unless you absolutely have to](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp100-dont-use-lock-free-programming-unless-you-absolutely-have-to)  
  (本当に必要な場合を除き、ロックフリープログラミングをしない)
* [CP.101: Distrust your hardware/compiler combination](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp101-distrust-your-hardwarecompiler-combination)  
  (自分のハードウェア、コンパイラの組み合わせを信用しない)
* [CP.102: Carefully study the literature](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp102-carefully-study-the-literature)  
  (文献で入念に勉強する)
* [CP.110: Do not write your own double-checked locking for initialization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp110-do-not-write-your-own-double-checked-locking-for-initialization)  
  (初期化のためのダブルチェックロックを自分で書かない)
* [CP.111: Use a conventional pattern if you really need double-checked locking](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp111-use-a-conventional-pattern-if-you-really-need-double-checked-locking)  
  (本当にダブルチェックロックが必要ならパターンに従う)

## [CP.etc: Etc. concurrency rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpetc-etc-concurrency-rules) / その他

* [CP.200: Use `volatile` only to talk to non-C++ memory](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cp200-use-volatile-only-to-talk-to-non-c-memory)  
  (`volatile`はC++外のメモリーを読み書きするためだけに使う)

# [E: Error handling](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e-error-handling) / エラーハンドリング

* [E.1: Develop an error-handling strategy early in a design](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e1-develop-an-error-handling-strategy-early-in-a-design)  
  (エラーハンドリング戦略を設計の早い段階で作る)
* [E.2: Throw an exception to signal that a function can’t perform its assigned task](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e2-throw-an-exception-to-signal-that-a-function-cant-perform-its-assigned-task)  
  (関数がその目的を果たせないことを知らせるために例外を投げる)
* [E.3: Use exceptions for error handling only](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e3-use-exceptions-for-error-handling-only)  
  (例外はエラーハンドリングのためだけに使う)
* [E.4: Design your error-handling strategy around invariants](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e4-design-your-error-handling-strategy-around-invariants)  
  (不変条件に関するエラーハンドリング戦略を設計する)
* [E.5: Let a constructor establish an invariant, and throw if it cannot](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e5-let-a-constructor-establish-an-invariant-and-throw-if-it-cannot)  
  (コンストラクターで不変条件を確立し、できないときは例外を投げる)
* [E.6: Use RAII to prevent leaks](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e6-use-raii-to-prevent-leaks)  
  (リークを防ぐためにRAIIを使う)
* [E.7: State your preconditions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e7-state-your-preconditions)  
  (事前条件を明記する)
* [E.8: State your postconditions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e8-state-your-postconditions)  
  (事後条件を明記する)
* [E.12: Use `noexcept` when exiting a function because of a throw is impossible or unacceptable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e12-use-noexcept-when-exiting-a-function-because-of-a-throw-is-impossible-or-unacceptable)  
  (例外を投げることが不可能または受け入れられない関数を抜けるために`noexcept`を使う)
* [E.13: Never throw while being the direct owner of an object](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e13-never-throw-while-being-the-direct-owner-of-an-object)  
  (オブジェクトを直接(RAIIラッパー無しで)所有している場合は決して例外を投げない)
* [E.14: Use purpose-designed user-defined types as exceptions (not built-in types)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e14-use-purpose-designed-user-defined-types-as-exceptions-not-built-in-types)  
  (目的に沿って設計されたユーザー定義の例外クラスを用いる(組み込みのものを使わない))
* [E.15: Catch exceptions from a hierarchy by reference](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e15-catch-exceptions-from-a-hierarchy-by-reference)  
  (クラス階層を持つ例外は参照で`catch`する)
* [E.16: Destructors, deallocation, and `swap` must never fail](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e16-destructors-deallocation-and-swap-must-never-fail)  
  (デストラクター、解放処理、`swap`は失敗してはいけない)
* [E.17: Don’t try to catch every exception in every function](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e17-dont-try-to-catch-every-exception-in-every-function)  
  (すべての関数ですべての例外を`catch`しようとしない)
* [E.18: Minimize the use of explicit `try`/`catch`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e18-minimize-the-use-of-explicit-trycatch)  
  (明示的な`try`/`catch`の使用を最小限にする)
* [E.19: Use a `final_action` object to express cleanup if no suitable resource handle is available](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e19-use-a-final_action-object-to-express-cleanup-if-no-suitable-resource-handle-is-available)  
  (適当なリソースハンドラーが使えない場合は`final_action`オブジェクトで後始末の処理を表現する)
* [E.25: If you can’t throw exceptions, simulate RAII for resource management](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e25-if-you-cant-throw-exceptions-simulate-raii-for-resource-management)  
  (例外を投げることができない場合、リソース管理はRAIIをシミュレートする)
* [E.26: If you can’t throw exceptions, consider failing fast](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e26-if-you-cant-throw-exceptions-consider-failing-fast)  
  (例外を投げることができない場合、早めに失敗させる)
* [E.27: If you can’t throw exceptions, use error codes systematically](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e27-if-you-cant-throw-exceptions-use-error-codes-systematically)  
  (例外を投げることができない場合、エラーコードは体系的に使う)
* [E.28: Avoid error handling based on global state (e.g. `errno`)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e28-avoid-error-handling-based-on-global-state-eg-errno)  
  (`errno`のようなグローバルな状態を使ったエラーハンドリングを避ける)
* [E.30: Don’t use exception specifications](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e30-dont-use-exception-specifications)  
  (例外仕様を使わない)
* [E.31: Properly order your catch-clauses](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#e31-properly-order-your-catch-clauses)  
  (`catch`節を適切に並べる)

# [Con: Constants and immutability](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con-constants-and-immutability) / 定数と不変性

* [Con.1: By default, make objects immutable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con1-by-default-make-objects-immutable)  
  (まずはオブジェクトを不変にする)
* [Con.2: By default, make member functions `const`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con2-by-default-make-member-functions-const)  
  (まずはメンバ－関数を`const`にする)
* [Con.3: By default, pass pointers and references to `const`s](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con3-by-default-pass-pointers-and-references-to-consts)  
  (まずはポインターと参照は`const`で渡す)
* [Con.4: Use `const` to define objects with values that do not change after construction](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con4-use-const-to-define-objects-with-values-that-do-not-change-after-construction)  
  (構築後に変化しないオブジェクトは`const`で定義する)
* [Con.5: Use `constexpr` for values that can be computed at compile time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#con5-use-constexpr-for-values-that-can-be-computed-at-compile-time)  
  (コンパイル時にも計算できる値には`constexpr`を使う)

# [T: Templates and generic programming](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t-templates-and-generic-programming) / テンプレートとジェネリックプログラミング

## [T.gp: Generic programming](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tgp-generic-programming) / ジェネリックプログラミング

* [T.1: Use templates to raise the level of abstraction of code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t1-use-templates-to-raise-the-level-of-abstraction-of-code)  
  (テンプレートを使ってコードの抽象化度を上げる)
* [T.2: Use templates to express algorithms that apply to many argument types](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t2-use-templates-to-express-algorithms-that-apply-to-many-argument-types)  
  (テンプレートを使って多数の引数の型に適用できるアルゴリズムを表現する)
* [T.3: Use templates to express containers and ranges](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t3-use-templates-to-express-containers-and-ranges)  
  (テンプレートを使ってコンテナと範囲を表現する)
* [T.4: Use templates to express syntax tree manipulation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t4-use-templates-to-express-syntax-tree-manipulation)  
  (テンプレートを使って構文木の操作を表現する)
* [T.5: Combine generic and OO techniques to amplify their strengths, not their costs](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t5-combine-generic-and-oo-techniques-to-amplify-their-strengths-not-their-costs)  
  (ジェネリックプログラミングとオブジェクト指向プログラミングを組み合わせ、お互いのコストではなく、強みを伸ばす)

## [T.concepts: Concept rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tconcepts-concept-rules) / コンセプトのルール

### [T.con-use: Concept use](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tcon-use-concept-use) / コンセプト利用時のルール

* [T.10: Specify concepts for all template arguments](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t10-specify-concepts-for-all-template-arguments)  
  (すべてのテンプレート引数にコンセプトを書く)
* [T.11: Whenever possible use standard concepts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t11-whenever-possible-use-standard-concepts)  
  (可能なら標準のコンセプトを使う)
* [T.12: Prefer concept names over `auto` for local variables](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t12-prefer-concept-names-over-auto-for-local-variables)  
  (ローカル変数の宣言には`auto`よりコンセプト名を使う)
* [T.13: Prefer the shorthand notation for simple, single-type argument concepts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t13-prefer-the-shorthand-notation-for-simple-single-type-argument-concepts)  
  (1引数の単純なコンセプトには略記法を使う)

### [T.concepts.def: Concept definition rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tconceptsdef-concept-definition-rules) / コンセプト定義時のルール

* [T.20: Avoid "concepts" without meaningful semantics](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t20-avoid-concepts-without-meaningful-semantics)  
  (有意義な意味論の無いコンセプトを作らない)
* [T.21: Require a complete set of operations for a concept](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t21-require-a-complete-set-of-operations-for-a-concept)  
  (コンセプトの制約には必要な操作をすべて含める)
* [T.22: Specify axioms for concepts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t22-specify-axioms-for-concepts)  
  (コンセプトを定義する公理を(コメントで)書く)
* [T.23: Differentiate a refined concept from its more general case by adding new use patterns](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t23-differentiate-a-refined-concept-from-its-more-general-case-by-adding-new-use-patterns)  
  (汎用的なコンセプトに制約を追加して詳細なコンセプトを定義する)
* [T.24: Use tag classes or traits to differentiate concepts that differ only in semantics](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t24-use-tag-classes-or-traits-to-differentiate-concepts-that-differ-only-in-semantics)  
  (意味論的な違いだけが違うコンセプトを差別化するためにタグクラスやトレイトを使用する)
* [T.25: Avoid complementary constraints](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t25-avoid-complementary-constraints)  
  (補集合としてのコンセプトを避ける)
* [T.26: Prefer to define concepts in terms of use-patterns rather than simple syntax](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t26-prefer-to-define-concepts-in-terms-of-use-patterns-rather-than-simple-syntax)  
  (コンセプトをはシンプルな構文で定義するよりも使用例によって定義する)
* [T.30: Use concept negation (`!C<T>`) sparingly to express a minor difference](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t30)  
  (コンセプトの否定は控えめにする)
* [T.31: Use concept disjunction (`C1<T> || C2<T>`) sparingly to express alternatives](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t31)  
  (コンセプトのOR条件は控えめにする)

## [Template interfaces](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#template-interfaces) / テンプレートインターフェース

* [T.40: Use function objects to pass operations to algorithms](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t40-use-function-objects-to-pass-operations-to-algorithms)  
  (アルゴリズムへ操作を渡すのには関数オブジェクトを使う)
* [T.41: Require only essential properties in a template’s concepts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t41-require-only-essential-properties-in-a-templates-concepts)  
  (テンプレートのコンセプトでは最も重要な性質だけを要求する)
* [T.42: Use template aliases to simplify notation and hide implementation details](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t42-use-template-aliases-to-simplify-notation-and-hide-implementation-details)  
  (テンプレートのエイリアスを使って記述を簡潔にし、実装の詳細を隠す)
* [T.43: Prefer `using` over `typedef` for defining aliases](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t43-prefer-using-over-typedef-for-defining-aliases)  
  (`typedef`よりも`using`を使う)
* [T.44: Use function templates to deduce class template argument types (where feasible)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t44-use-function-templates-to-deduce-class-template-argument-types-where-feasible)  
  (可能ならクラステンプレートの引数を推論するために関数テンプレートを使う)
* [T.46: Require template arguments to be at least `Regular` or `SemiRegular`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t46-require-template-arguments-to-be-at-least-regular-or-semiregular)  
  (テンプレート引数は最低でも`Regular`か`SemiRegular`であることを要求する)
* [T.47: Avoid highly visible unconstrained templates with common names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t47-avoid-highly-visible-unconstrained-templates-with-common-names)  
  (一般的な名前で広範囲に渡って見えている制約のないテンプレートを避ける)
* [T.48: If your compiler does not support concepts, fake them with `enable_if`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t48-if-your-compiler-does-not-support-concepts-fake-them-with-enable_if)  
  (コンセプトに対応していないコンパイラの場合は、`enable_if`で再現する)
* [T.49: Where possible, avoid type-erasure](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t49-where-possible-avoid-type-erasure)  
  (可能な限り型消去をしない)

## [T.def: Template definitions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tdef-template-definitions) / テンプレート定義

* [T.60: Minimize a template’s context dependencies](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t60-minimize-a-templates-context-dependencies)  
  (テンプレートはコンテキストにできる限り依存させない)
* [T.61: Do not over-parameterize members (SCARY)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t61-do-not-over-parameterize-members-scary)  
  (メンバーをパラメーター化しすぎない)
* [T.62: Place non-dependent class template members in a non-templated base class](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t62-place-non-dependent-class-template-members-in-a-non-templated-base-class)  
  (非依存のクラステンプレートメンバーはテンプレートではない基底クラスに置く)
* [T.64: Use specialization to provide alternative implementations of class templates](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t64-use-specialization-to-provide-alternative-implementations-of-class-templates)  
  (クラステンプレートの別の実装を提供するには特殊化をする)
* [T.65: Use tag dispatch to provide alternative implementations of functions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t65-use-tag-dispatch-to-provide-alternative-implementations-of-a-function)  
  (関数の別の実装を与えるにはタグディスパッチを使う)
* [T.67: Use specialization to provide alternative implementations for irregular types](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t67-use-specialization-to-provide-alternative-implementations-for-irregular-types)  
  (特別な型に対する異なる実装を与えるには特殊化をする)
* [T.68: Use `{}` rather than `()` within templates to avoid ambiguities](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t68-use--rather-than--within-templates-to-avoid-ambiguities)  
  (テンプレートでは`()`より`{}`を使い、曖昧性を避ける)
* [T.69: Inside a template, don’t make an unqualified nonmember function call unless you intend it to be a customization point](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t69-inside-a-template-dont-make-an-unqualified-non-member-function-call-unless-you-intend-it-to-be-a-customization-point)  
  (テンプレートの中では、カスタマイゼーションポイントである場合を除いて非修飾・非メンバーの関数を呼び出さない)

## [T.temp-hier: Template and hierarchy rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#ttemp-hier-template-and-hierarchy-rules) / テンプレートとクラス階層のルール

* [T.80: Do not naively templatize a class hierarchy](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t80-do-not-naively-templatize-a-class-hierarchy)  
  (クラス階層全体を単純にテンプレート化しない)
* [T.81: Do not mix hierarchies and arrays](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t81-do-not-mix-hierarchies-and-arrays)  
  (クラス階層と配列を混ぜて使わない)
* [T.82: Linearize a hierarchy when virtual functions are undesirable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t82-linearize-a-hierarchy-when-virtual-functions-are-undesirable)  
  (仮想関数が好ましくないなら、クラス階層を直線的にする)
* [T.83: Do not declare a member function template virtual](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t83-do-not-declare-a-member-function-template-virtual)  
  (メンバー関数テンプレートを`virtual`宣言しない)
* [T.84: Use a non-template core implementation to provide an ABI-stable interface](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t84-use-a-non-template-core-implementation-to-provide-an-abi-stable-interface)  
  (安定したABIを提供するには、中核部分の実装はテンプレートにしない)

## [T.var: Variadic template rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tvar-variadic-template-rules) / 可変引数テンプレートのルール

* [T.100: Use variadic templates when you need a function that takes a variable number of arguments of a variety of types](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t100-use-variadic-templates-when-you-need-a-function-that-takes-a-variable-number-of-arguments-of-a-variety-of-types)  
  (異なる型の可変長の引数をとる関数が必要な場合は、可変引数テンプレートを使う)
* [T.103: Don’t use variadic templates for homogeneous argument lists](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t103-dont-use-variadic-templates-for-homogeneous-argument-lists)  
  (同じ型の引数リストを可変引数テンプレートにしない)

## [T.meta: Template metaprogramming (TMP)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#tmeta-template-metaprogramming-tmp) / テンプレートメタプログラミング

* [T.120: Use template metaprogramming only when you really need to](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t120-use-template-metaprogramming-only-when-you-really-need-to)  
  (テンプレートメタプログラミングは本当に必要なときだけにする)
* [T.121: Use template metaprogramming primarily to emulate concepts](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t121-use-template-metaprogramming-primarily-to-emulate-concepts)  
  (テンプレートメタプログラミングでコンセプトを模倣する)
* [T.122: Use templates (usually template aliases) to compute types at compile time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t122-use-templates-usually-template-aliases-to-compute-types-at-compile-time)  
  (コンパイル時に型を計算するにはテンプレートやテンプレートエイリアスを使う)
* [T.123: Use `constexpr` functions to compute values at compile time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t123-use-constexpr-functions-to-compute-values-at-compile-time)  
  (コンパイル時に値を計算するには`constexpr`を使う)
* [T.124: Prefer to use standard-library TMP facilities](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t124-prefer-to-use-standard-library-tmp-facilities)  
  (標準ライブラリのテンプレートメタプログラミングライブラリを使用する)
* [T.125: If you need to go beyond the standard-library TMP facilities, use an existing library](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t125-if-you-need-to-go-beyond-the-standard-library-tmp-facilities-use-an-existing-library)  
  (標準ライブラリのテンプレートメタプログラミングライブラリの範囲で出来ないときも、既存のライブラリを使う)

## [Other template rules](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#other-template-rules) / その他

* [T.140: Name all operations with potential for reuse](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t140-name-all-operations-with-potential-for-reuse)  
  (再利用する可能性があるすべての操作に名前をつける)
* [T.141: Use an unnamed lambda if you need a simple function object in one place only](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t141-use-an-unnamed-lambda-if-you-need-a-simple-function-object-in-one-place-only)  
  (一か所でしか使わない単純な関数オブジェクトが必要ならラムダ式を使う)
* [T.142: Use template variables to simplify notation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t142-use-template-variables-to-simplify-notation)  
  (変数テンプレートを使って記述を簡素にする)
* [T.143: Don’t write unintentionally nongeneric code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t143-dont-write-unintentionally-non-generic-code)  
  (意図せずに汎用性の低いコードを書かない)
* [T.144: Don’t specialize function templates](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t144-dont-specialize-function-templates)  
  (関数テンプレートを特殊化しない)
* [T.150: Check that a class matches a concept using `static_assert`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#t150-check-that-a-class-matches-a-concept-using-static_assert)  
  (`static_assert`を使ってクラスがコンセプトを満たすか確認する)

# [CPL: C-style programming](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpl-c-style-programming) / Cスタイルプログラミング

* [CPL.1: Prefer C++ to C](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpl1-prefer-c-to-c)  
  (CよりもC++)
* [CPL.2: If you must use C, use the common subset of C and C++, and compile the C code as C++](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpl2-if-you-must-use-c-use-the-common-subset-of-c-and-c-and-compile-the-c-code-as-c)  
  (Cを使わざるを得ないなら、CとC++の共通部分を使い、CのコードをC++としてコンパイルする)
* [CPL.3: If you must use C for interfaces, use C++ in the calling code using such interfaces](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cpl3-if-you-must-use-c-for-interfaces-use-c-in-the-calling-code-using-such-interfaces)  
  (Cをインターフェースに使わざるを得ないなら、そのようなインターフェースを呼び出すコードはC++で書く)

# [SF: Source files](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf-source-files) / ソースファイル

* [SF.1: Use a `.cpp` suffix for code files and `.h` for interface files if your project doesn’t already follow another convention](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf1-use-a-cpp-suffix-for-code-files-and-h-for-interface-files-if-your-project-doesnt-already-follow-another-convention)  
  (プロジェクトがまだ他の慣習に従っていないのであれば、ソースファイルには`.cpp`、ヘッダーファイルには`.h`の拡張子を使う)
* [SF.2: A `.h` file may not contain object definitions or non-inline function definitions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf2-a-h-file-may-not-contain-object-definitions-or-non-inline-function-definitions)  
  (`.h`ファイルにオブジェクトの定義やインラインでない関数の定義を含めてはいけない)
* [SF.3: Use `.h` files for all declarations used in multiple source files](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf3-use-h-files-for-all-declarations-used-in-multiple-source-files)  
  (`.h`ファイルに複数のソースファイルで使う宣言を書く)
* [SF.4: Include `.h` files before other declarations in a file](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf4-include-h-files-before-other-declarations-in-a-file)  
  (`.h`ファイルをファイル内の他の宣言より先にインクルードする)
* [SF.5: A `.cpp` file must include the `.h` file(s) that defines its interface](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf5-a-cpp-file-must-include-the-h-files-that-defines-its-interface)  
  (`.cpp`ファイルはそのインターフェースを定義する`.h`ファイルをインクルードしなければならない)
* [SF.6: Use `using namespace` directives for transition, for foundation libraries (such as std), or within a local scope (only)](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf6-use-using-namespace-directives-for-transition-for-foundation-libraries-such-as-std-or-within-a-local-scope-only)  
  (`using namespace`は移行のため、`std`のような基礎的ライブラリのため、あるいはローカルスコープに限って使う)
* [SF.7: Don’t write `using namespace` at global scope in a header file](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf7-dont-write-using-namespace-at-global-scope-in-a-header-file)  
  (ヘッダーファイルのグローバルスコープにおいて`using namespace`をしない)
* [SF.8: Use `#include` guards for all `.h` files](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf8-use-include-guards-for-all-h-files)  
  (すべての`.h`ファイルにインクルードガードを書く)
* [SF.9: Avoid cyclic dependencies among source files](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf9-avoid-cyclic-dependencies-among-source-files)  
  (ソースファイルの依存関係が循環しないようにする)
* [SF.10: Avoid dependencies on implicitly `#include`d names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf10-avoid-dependencies-on-implicitly-included-names)  
  (暗黙にインクルードされた名前への依存を避ける)
* [SF.11: Header files should be self-contained](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf11-header-files-should-be-self-contained)  
  (ヘッダーファイルは自己完結すべきである)
* [SF.20: Use `namespace`s to express logical structure](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf20-use-namespaces-to-express-logical-structure)  
  (論理的な構造を名前空間で表現する)
* [SF.21: Don’t use an unnamed (anonymous) namespace in a header](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf21-dont-use-an-unnamed-anonymous-namespace-in-a-header)  
  (ヘッダーファイルで無名名前空間を使わない)
* [SF.22: Use an unnamed (anonymous) namespace for all internal/nonexported entities](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sf22-use-an-unnamed-anonymous-namespace-for-all-internalnon-exported-entities)  
  (内部的なものは無名名前空間に置く)

# [SL: The Standard library](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sl-the-standard-library) / 標準ライブラリ

* [SL.1: Use libraries wherever possible](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sl1--use-libraries-wherever-possible)  
  (可能な限りライブラリを使う)
* [SL.2: Prefer the standard library to other libraries](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sl2-prefer-the-standard-library-to-other-libraries)  
  (他のライブラリより標準ライブラリを使う)
* [SL.3: Do not add non-standard entities to namespace `std`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sl3-do-not-add-non-standard-entities-to-namespace-std)  
  (`std`名前空間に非標準の要素を追加しない)
* [SL.4: Use the standard library in a type-safe manner](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#sl4-use-the-standard-library-in-a-type-safe-manner)  
  (標準ライブラリは型安全性を守って使う)

## [SL.con: Containers](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slcon-containers) / コンテナ

* [SL.con.1: Prefer using STL `array` or `vector` instead of a C array](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rsl-arrays)  
  (C配列よりもSTLの`array`や`vector`を使う)
* [SL.con.2: Prefer using STL `vector` by default unless you have a reason to use a different container](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rsl-vector)  
  (他のコンテナを使う理由がなければまずは`vector`を使う)
* [SL.con.3: Avoid bounds errors](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rsl-bounds)  
  (境界エラーを避ける)
* [SL.con.4: don’t use `memset` or `memcpy` for arguments that are not trivially-copyable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rsl-copy)  
  (トリビアルコピー可能ではない型の引数に `memset` や `memcpy` を使わない)

## [SL.str: String](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slstr-string) / 文字列

* [SL.str.1: Use `std::string` to own character sequences](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-string)  
  (文字列を所有するには`std::string`を使う)
* [SL.str.2: Use `std::string_view` or `gsl::span<char>` to refer to character sequences](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-view)  
  (文字列を参照するには`std::string_view`や`gsl::span<char>`を使う)
* [SL.str.3: Use `zstring` or `czstring` to refer to a C-style, zero-terminated, sequence of characters](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-zstring)  
  (C文字列を参照するには`zstring`や`czstring`を使う)
* [SL.str.4: Use `char*` to refer to a single character](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-char*)  
  (1文字を参照するには`char*`を使う)
* [SL.str.5: Use `std::byte` to refer to byte values that do not necessarily represent characters](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-byte)  
  (文字とは限らない1バイトの値を参照するには`std::byte`を使う)
* [SL.str.10: Use `std::string` when you need to perform locale-sensitive string operations](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-locale)  
  (ロケール依存の文字列処理が必要なら`std::string`を使う)
* [SL.str.11: Use `gsl::span<char>` rather than `std::string_view` when you need to mutate a string](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-span)  
  (文字列を変更する必要があるなら`std::string_view`より`gsl::span<char>`を使う)
* [SL.str.12: Use the `s` suffix for string literals meant to be standard-library strings](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rstr-s)  
  (文字列リテラルにはユーザー定義リテラル`s`を付けて`std::string`であることを示す)

## [SL.io: Iostream](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slio-iostream) / 入出力ストリーム

* [SL.io.1: Use character-level input only when you have to](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rio-low)  
  (文字単位の入力は必要なときだけ使う)
* [SL.io.2: When reading, always consider ill-formed input](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rio-validate)  
  (入力では、常に正しくないフォーマットで入力される場合を考慮する)
* [SL.io.3: Prefer `iostream`s for I/O](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rio-streams)  
  (I/Oには`iostream`を優先的に使う)
* [SL.io.10: Unless you use printf-family functions call `ios_base::sync_with_stdio(false)`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rio-sync)  
  (`printf`系関数を使わないなら`ios_base::sync_with_stdio(false)`を実行する)
* [SL.io.50: Avoid `endl`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rio-endl)  
  (`endl`を避ける)

## [SL.regex: Regex](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slregex-regex) / 正規表現

未定義

## [SL.chrono: Time](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slchrono-time) / 時間

未定義

## [SL.C: The C Standard Library](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#slc-the-c-standard-library) / C標準ライブラリ

* [S.C.1: Don’t use `setjmp`/`longjmp`](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#s.c1)  
  (`setjmp`/`longjmp`を使わない)

# [A: Architectural Ideas](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#a-architectural-ideas) / アーキテクチャー

* [A.1: Separate stable code from less stable code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#a1-separate-stable-code-from-less-stable-code)  
  (安定したコードと不安定なコードを分ける)
* [A.2: Express potentially reusable parts as a library](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#a2-express-potentially-reusable-parts-as-a-library)  
  (再利用できそうなものはライブラリにする)
* [A.4: There should be no cycles among libraries](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#a4-there-should-be-no-cycles-among-libraries)  
  (ライブラリ間の依存関係が循環してはならない)

# [NR: Non-Rules and myths](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr-non-rules-and-myths) / ルールではないもの、迷信

* [NR.1: Don’t: All declarations should be at the top of a function](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr1-dont-insist-that-all-declarations-should-be-at-the-top-of-a-function)  
  (NG: すべての宣言を関数の頭に置く)
* [NR.2: Don’t: Have only a single return-statement in a function](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr2-dont-insist-to-have-only-a-single-return-statement-in-a-function)  
  (NG: return文は1つの関数につき1つまでにする)
* [NR.3: Don’t: Don’t use exceptions](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr3-dont-avoid-exceptions)  
  (NG: 例外を使わない)
* [NR.4: Don’t: Place each class declaration in its own source file](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr4-dont-insist-on-placing-each-class-declaration-in-its-own-source-file)  
  (NG: 1つ1つのクラス宣言をそれ専用のソースファイルに置く)
* [NR.5: Don’t: Don’t do substantive work in a constructor; instead use two-phase initialization](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr5-dont-use-two-phase-initialization)  
  (NG: コンストラクタで実質的に何もせず、2段階で初期化する)
* [NR.6: Don’t: Place all cleanup actions at the end of a function and goto exit](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr6-dont-place-all-cleanup-actions-at-the-end-of-a-function-and-goto-exit)  
  (NG: 後始末の処理を関数の最後に置き、goto exit:でジャンプする)
* [NR.7: Don’t: Make all data members protected](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nr7-dont-make-all-data-members-protected)  
  (NG: すべてのデータメンバーをprotectedにする)

# [RF: References](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#rf-references) / 参考文献

(略) 参考文献の説明であり、コーディングガイドラインではない。

# [Pro: Profiles](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#pro-profiles) / プロファイル

※ プロファイルは、C++ Core Guidelinesのルールを機械的に検証しやすいように選んだサブセットであり、目的にあわせて使うことができる。

## [Pro.type: Type safety](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#prosafety-type-safety-profile) / 型安全性

* Type.1: Avoid casts:  
  (キャストを避ける)
    * a. Don’t use `reinterpret_cast`; A strict version of Avoid casts(ES.48) and prefer named casts(ES.49).  
      (`reinterpret_cast`を使わない)
    * b. Don’t use `static_cast` for arithmetic types; A strict version of Avoid casts(ES.48) and prefer named casts(ES.49).  
      (算術型への`static_cast`を使わない)
    * c. Don’t cast between pointer types where the source type and the target type are the same; A strict version of Avoid casts(ES.48).  
      (ソースの型とターゲットの型が同じときはポインター型同士をキャストしない)
    * d. Don’t cast between pointer types when the conversion could be implicit; A strict version of Avoid casts(ES.48).  
      (変換が暗黙的になる可能性があるときは、ポインター型同士をキャストしない)
* Type.2: Don’t use `static_cast` to downcast: Use `dynamic_cast` instead(C.146).  
  (ダウンキャストには`static_cast`ではなく`dynamic_cast`を使う(C.146))
* Type.3: Don’t use `const_cast` to cast away const (i.e., at all): Don’t cast away const(ES.50).  
  (`const`を外さない)
* Type.4: Don’t use C-style `(T)`expression or functional `T(expression)` casts: Prefer construction(ES.64) or named casts(ES.49).  
  (Cスタイルキャスト、関数スタイルのキャストを使用しない。その代わり、初期化(ES.64)や名前の付いたキャスト(ES.49)を用いる)
* Type.5: Don’t use a variable before it has been initialized: always initialize(ES.20).  
  (変数は初期化する前に一切使わない)
* Type.6: Always initialize a member variable: always initialize(ES.20), possibly using default constructors(C.43) or default member initializers(C.48).  
  (メンバー変数を必ず初期化する(ES.20)、特に、デフォルトコンストラクタ(C.43)またはデフォルトメンバー初期化子(C.48)を使う)
* Type.7: Avoid naked `union`: Use `variant` instead(C.181).  
  (裸の`union`を避け、`variant`を使う(C.181))
* Type.8: Avoid varargs: Don’t use `va_arg` arguments(F.55).  
  (可変長引数を使わない、特に、`va_arg`を使わない(F.55))

## [Pro.bounds: Bounds safety](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#probounds-bounds-safety-profile) / 境界安全性

* Bounds.1: Don’t use pointer arithmetic. Use `span` instead: Pass pointers to single objects (only)(I.13) and Keep pointer arithmetic simple.(ES.42)  
  (ポインターの算術演算を使わず、`span`を使う。ポインターは1つのオブジェクトを表すためだけに使用する(I.13)。ポインターの演算は単純にする(ES.42))
* Bounds.2: Only index into arrays using constant expressions: Pass pointers to single objects (only)(I.13) and Keep pointer arithmetic simple.(ES.42)  
  (配列への添え字は定数式だけを使う。ポインターは1つのオブジェクトを表すためだけに使用する(I.13)。ポインターの演算は単純にする(ES.42))
* Bounds.3: No array-to-pointer decay: Pass pointers to single objects (only)(I.13) and Keep pointer arithmetic simple.(ES.42)  
  (配列からポインターへのdecayを利用しない。ポインターは1つのオブジェクトを表すためだけに使用する(I.13)。ポインターの演算は単純にする(ES.42))
* Bounds.4: Don’t use standard-library functions and types that are not bounds-checked: Use the standard library in a type-safe manner(SL.con.3).  
  (境界チェックのない標準ライブラリ関数と型を使用しない。標準ライブラリでの境界エラーを避ける(SL.con.3))

## [Pro.lifetime: Lifetime safety](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#prolifetime-lifetime-safety-profile) / ライフタイム安全性

* Lifetime.1: Don’t dereference a possibly invalid pointer: detect or avoid(ES.65).  
  (無効になる可能性のあるポインターをデリファレンスしない。検出するか回避する(ES.65))

# [GSL: Guideline support library](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#gsl-guidelines-support-library) / ガイドラインサポートライブラリ

(略) GSLの説明であり、コーディングガイドラインではない。GSLはC++ Core Guidelinesをサポートするライブラリで、ルールの中にはGSLに依存するものがある。

# [NL: Naming and layout](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl-naming-and-layout-rules) / 名前付けとレイアウト

* [NL.1: Don’t say in comments what can be clearly stated in code](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl1-dont-say-in-comments-what-can-be-clearly-stated-in-code)  
  (コードで明確に表現できることをコメントで書かない)
* [NL.2: State intent in comments](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl2-state-intent-in-comments)  
  (意図をコメントに書く)
* [NL.3: Keep comments crisp](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl3-keep-comments-crisp)  
  (コメントは短く明快にする)
* [NL.4: Maintain a consistent indentation style](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl4-maintain-a-consistent-indentation-style)  
  (一貫したインデントスタイルを守る)
* [NL.5: Avoid encoding type information in names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl5-avoid-encoding-type-information-in-names)  
  (型の情報を名前に埋め込まない)
* [NL.7: Make the length of a name roughly proportional to the length of its scope](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl7-make-the-length-of-a-name-roughly-proportional-to-the-length-of-its-scope)  
  (名前の長さがスコープの長さにおおよそ比例するようにする)
* [NL.8: Use a consistent naming style](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl8-use-a-consistent-naming-style)  
  (一貫した名前のスタイルを使う)
* [NL.9: Use `ALL_CAPS` for macro names only](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl9-use-all_caps-for-macro-names-only)  
  (すべて大文字の名前はマクロの名前だけに使う)
* [NL.10: Prefer `underscore_style` names](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl10-prefer-underscore_style-names)  
  (名前のスタイルを`underscore_style`にする)
* [NL.11: Make literals readable](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl11-make-literals-readable)  
  (リテラルを読みやすくする)
* [NL.15: Use spaces sparingly](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl15-use-spaces-sparingly)  
  (スペースは控えめに使う)
* [NL.16: Use a conventional class member declaration order](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl16-use-a-conventional-class-member-declaration-order)  
  (クラスのメンバーの並びは慣習に従う)
* [NL.17: Use K&R-derived layout](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl17-use-kr-derived-layout)  
  (K&Rから継承したレイアウトを使う)
* [NL.18: Use C++-style declarator layout](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl18-use-c-style-declarator-layout)  
  (C++スタイルの宣言のレイアウトを使う)
* [NL.19: Avoid names that are easily misread](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl19-avoid-names-that-are-easily-misread)  
  (誤解を生む名前を避ける)
* [NL.20: Don’t place two statements on the same line](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl20-dont-place-two-statements-on-the-same-line)  
  (1行に2つの文を書かない)
* [NL.21: Declare one name (only) per declaration](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl21-declare-one-name-only-per-declaration)  
  (1つの宣言で1つの名前だけを宣言する)
* [NL.25: Don’t use `void` as an argument type](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl25-dont-use-void-as-an-argument-type)  
  (引数リストにvoidを書かない)
* [NL.26: Use conventional const notation](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#nl26-use-conventional-const-notation)  
  (`const`の表記は慣習に従う)