容桂微信网站建设,金融互助网站开发,网站设计南方企业网,wordpress付费阅读全文一直对C初始化使用圆括号和花括号的区别有所疑惑#xff0c;参考书籍和博客简单总结一下 文章目录 常见的初始化操作统一初始化(Uniform Initialization)初始化列表(Initializer Lists) 常见的初始化操作
对于一个基础数据类型进行初始化#xff0c;比如 int#xff1a;
i… 一直对C初始化使用圆括号和花括号的区别有所疑惑参考书籍和博客简单总结一下 文章目录 常见的初始化操作统一初始化(Uniform Initialization)初始化列表(Initializer Lists) 常见的初始化操作
对于一个基础数据类型进行初始化比如 int
int x(0);
int y 0;
int z{0};对于用户定义的类型
Foo foo1; // default construction
Foo foo2 foo1; // equivalent to Foo foo2(foo1)
foo1 foo2; // assignment operation, call operator function统一初始化(Uniform Initialization)
C11之前初始化一个变量或一个对象可以使用圆括号()、花括号{} 以及赋值运算符。这就会对初学者产生一定疑惑(具体应该使用哪一种)。对此C11 引入了统一初始化的概念即对于任意初始化可以使用一个统一的语法一个花括号 {}举个栗子
int values[] {1, 2, 3}; // initialize int array
std::vectorint v{2, 3, 5, 7, 11, 13, 17}; // initialize vectorint
std::vectorstd::string cities{Berlin, New York, London, Braunschweig, Cairo, Cologne}; // implicit conversion: const char * std::string
std::complexdouble c{4.0, 3.0}; // equivalent to c(4.0, 3.0)一个初始化列表强迫进行值初始化基础数据类型初始化为0指针类型初始化为 nullptr
int i; // i has undefined value
int j{}; // j is initialized by 0
int* p; // p has undefined value
int* q{}; // q is initialized by nullptr需要注意的是如果存在收缩转换(narrowing)即精度减小那么不能使用统一初始化
int x1(5.3); // OK, but OUCH: x1 becomes 5
int x2 5.3; // OK, but OUCH: x2 becomes 5
int x3{5.0}; // ERROR: narrowing
int x4 {5.3}; // ERROR: narrowing
char c1{7}; // OK: even though 7 is an int, this is not narrowing
char c2{99999}; // ERROR: narrowing (if 99999 doesn’t fit into a char)
std::vectorint v1 { 1, 2, 4, 5 }; // OK
std::vectorint v2 { 1, 2.3, 4, 5.6 }; // ERROR: narrowing doubles to ints初始化列表(Initializer Lists)
为了支持用户定义类型的初始化列表C11 提供了模板类 std::initializer_list。其可被用于支持使用一列值进行初始化或对一列值进行处理。例如
void print (std::initializer_listint vals)
{
for (auto pvals.begin(); p!vals.end(); p) { // process a list of values
std::cout *p \n;
}
}
print ({12,3,5,7,11,13,17}); // pass a list of values to print()当使用统一初始化时如果构造函数同时匹配指定数量的构造函数以及使用初始化列表的构造函数优先选择使用初始化列表的构造函数
class P
{
public:
P(int,int);
P(std::initializer_listint);
};
P p(77,5); // calls P::P(int,int)
P q{77,5}; // calls P::P(initializer_list)
P r{77,5,42}; // calls P::P(initializer_list)
P s {77,5}; // calls P::P(initializer_list)如果构造函数为显示构造函数那么不能使用 语法进行初始化因为不能进行隐式转换
class P
{
public:
P(int a, int b) {
...
}
explicit P(int a, int b, int c) {
...
}
};
P x(77,5); // OK
P y{77,5}; // OK
P z {77,5,42}; // OK
P v {77,5}; // OK (implicit type conversion allowed)
P w {77,5,42}; // ERROR due to explicit (no implicit type conversion allowed)void fp(const P);
fp({47,11}); // OK, implicit conversion of {47,11} into P
fp({47,11,3}); // ERROR due to explicit
fp(P{47,11}); // OK, explicit conversion of {47,11} into P
fp(P{47,11,3}); // OK, explicit conversion of {47,11,3} into P类似地使用一个初始化列表的显示构造函数禁用隐式转换对于0个、1个或多个初值。
相比于使用圆括号的一个优势比如当我们使用带参构造函数可以使用如下语法
Foo foo1(10); // call Foo constrution with arguments但使用类似语法调用无参构造函数时却是声明了个函数而不是创建对象
Foo foo2(); // declare a foo2 function without arguments and return Foo object
Foo foo2; // foo2 is a default initialized object我们可以使用花括号来解决这个歧义因为花括号无法声明为函数
Foo f2{}; // no ambiguity
