ES.23: Prefer the {}-initializer syntax
ES.23:優先使用{}初始化器語法
Reason(原因)
Prefer {}. The rules for {} initialization are simpler, more general, less ambiguous, and safer than for other forms of initialization.
優先使用{}。{}初始化器原則簡單,更通用,更少歧義,並且比其他形式的初始化更安全。
Use = only when you are sure that there can be no narrowing conversions. For built-in arithmetic types, use = only with auto.
Avoid () initialization, which allows parsing ambiguities.
只在你確定不會發生窄化時使用=。對於內置算數類型,只在給auto賦值時使用=。避免()初始化,它允許模糊解析.
Example(示例)
int x {f(99)};
int y = x;
vector<int> v = {1, 2, 3, 4, 5, 6};
Exception(例外)
For containers, there is a tradition for using {...} for a list of elements and (...) for sizes:
對於容器來講,習慣上使用{...}表示要素列表,使用()表示大小。
vector<int> v1(10); // vector of 10 elements with the default value 0
vector<int> v2{10}; // vector of 1 element with the value 10
vector<int> v3(1, 2); // vector of 1 element with the value 2
vector<int> v4{1, 2}; // vector of 2 element with the values 1 and 2
Note(注意)
{}-initializers do not allow narrowing conversions (and that is usually a good thing) and allow explicit constructors (which is fine, we're intentionally initializing a new variable).
{}初始化器不允許窄化轉換(這通常是好事)並且允許顯式構造函數(這沒有問題,我們就是要初始化一個新變量)
Example(示例)
int x {7.9}; // error: narrowing
int y = 7.9; // OK: y becomes 7. Hope for a compiler warning
int z = gsl::narrow_cast<int>(7.9); // OK: you asked for it
Note(注意)
{} initialization can be used for nearly all initialization; other forms of initialization can't:
{}初始化器差不多可以被用於任何初始化;其他形式的初始化則不行。
auto p = new vector<int> {1, 2, 3, 4, 5}; // initialized vector
D::D(int a, int b) :m{a, b} { // member initializer (e.g., m might be a pair)
// ...
};
X var {}; // initialize var to be empty
struct S {
int m {7}; // default initializer for a member
// ...
};
For that reason, {}-initialization is often called "uniform initialization" (though there unfortunately are a few irregularities left).
由於這個原因,{}初始化經常被稱爲“統一初始化”(雖然很不幸還存在很少的例外。)
Note(注意)
Initialization of a variable declared using auto with a single value, e.g., {v}, had surprising results until C++17. The C++17 rules are somewhat less surprising:
用一個單值初始化一個用auto聲明的變量,例如:{v},在C++17之前會產生以外的結果,C++17原則某種程度上好一些:
auto x1 {7}; // x1 is an int with the value 7
auto x2 = {7}; // x2 is an initializer_list<int> with an element 7
auto x11 {7, 8}; // error: two initializers
auto x22 = {7, 8}; // x22 is an initializer_list<int> with elements 7 and 8
Use ={...} if you really want an initializer_list<T>
如果你確實想要一個列表初始化,使用={...};
auto fib10 = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55}; // fib10 is a list
Note(注意)
={} gives copy initialization whereas {} gives direct initialization. Like the distinction between copy-initialization and direct-initialization itself, this can lead to surprises. {} accepts explicit constructors; ={} does not. For example:
={} 提供拷貝初始化,但是{}提供直接初始化。就像拷貝初始化和直接初始化之間的區別一樣,這會使人驚訝。{}接受顯式構造函數,={}不會。例如:
struct Z { explicit Z() {} };
Z z1{}; // OK: direct initialization, so we use explicit constructor
Z z2 = {}; // error: copy initialization, so we cannot use the explicit constructor
Use plain {}-initialization unless you specifically want to disable explicit constructors.
使用直接的{}初始化,除非你就是想禁止顯式構造函數。
Example(示例)
template<typename T>
void f()
{
T x1(1); // T initialized with 1
T x0(); // bad: function declaration (often a mistake)
T y1 {1}; // T initialized with 1
T y0 {}; // default initialized T
// ...
}
See also: Discussion
參見:
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#???
Enforcement(實施建議)
-
Flag uses of = to initialize arithmetic types where narrowing occurs.
-
提示使用=進行算數類型的初始化而且發生窄化轉換的情況。
-
Flag uses of () initialization syntax that are actually declarations. (Many compilers should warn on this already.)
-
提示使用()初始化語法但實際上是聲明的情況(很多編譯器應該已經對這種情況報警)
原文鏈接
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es23-prefer-the--initializer-syntax
覺得本文有幫助?歡迎點贊並分享給更多的人。
閱讀更多更新文章,請關注微信公衆號【面向對象思考】