Question

我有以下代码：

bool c (a == b);

和

bool c {a == b};

其中a和b是一些相同类型的变量。

我想知道，上述两种初始化有什么不同，哪种情况应该优先选择？任何形式的帮助将不胜感激。

Answer 1

这两种形式都是direct initialization。

使用花括号{}进行初始化检查以缩小转换次数，并在发生此类转换时生成错误。与()不同。（gcc is buggy in this regard和需要-Werror=narrowing编译器选项在发生缩小时生成错误。）

花括号{}的另一个用途是统一初始化：使用相同的语法初始化带有和不带构造函数的两种类型，例如：

template<class T, class... Args>
T create(Args&&... args) {
    T value{std::forward<Args>(args)...}; // <--- uniform initialization + perfect forwarding
    return value;
}

struct X { int a, b; };
struct Y { Y(int, int, int); };

int main() {
    auto x = create<X>(1, 2);    // POD
    auto y = create<Y>(1, 2, 3); // A class with a constructor.
    auto z = create<int>(1);     // built-in type
}

使用花括号{}进行初始化的唯一缺点是它与auto关键字的交互。 auto将{}推断为std::initializer_list，这是一个已知问题，请参阅"Auto and braced-init-lists"。

Answer 2

第一个是C ++ 03样式的直接初始化。第二种是C ++ 11样式直接初始化，它还检查缩小转换。 Herb Sutter在新代码中推荐以下内容：

auto c = <expression>;

或当您想要提交特定类型T：

时

auto c = T{<expression>};

当T是一些具有重载构造函数的类时，花括号的一个已知缺点，其中一个构造函数将std :: initializer_list作为参数，std :: vector例如：

auto v = std::vector<int>{10}; // create vector<int> with one element = 10
auto v = std::vector<int>(10); // create vector<int> with 10 integer elements

Answer 3

现在我们有五种初始化形式。他们是

T x = expression;
T x = ( expression );
T x (  expression );
T x = { expression };
T x { expression };

每种形式都有自己的特色。：）

例如，假设您在全局命名空间中有以下声明

int x;

void f( int x ) { ::x = x; }
int g() { return x ; }
long h() { return x; }

然后在主要你可以写

int main()
{
    int x ( g() );
}

此代码将成功编译。

然而程序员错误地写错了

int main()
{
    int x; ( g() );
         ^^
}

糟糕！此代码也成功编译。：）

但如果程序员会写

int main()
{
    int x = ( g() );
}

然后拼错

int main()
{
    int x; = ( g() );
         ^^
}

然后在这种情况下代码将无法编译。

假设程序员在初始化局部变量之前首先决定为全局变量x设置一个新值。

所以他写了

int main()
{
    int x ( f( 10 ), g() );
}

但是这段代码不能编译！

让; s插入等号

int main()
{
    int x = ( f( 10 ), g() );
}

现在代码编译成功了！

大括号呢？

这段代码

int main()
{
    int x { f( 10 ), g() };
}

也不是这段代码

int main()
{
    int x = { f( 10 ), g() };
}

编译：！）

现在程序员决定使用函数h（），他写了

int main()
{
    int x ( h() );
}

并且他的代码编译成功。但过了一段时间后他决定使用大括号

int main()
{
    int x { h() };
}

糟糕！他的编译器发出错误

错误：非常量表达式不能从类型'long'缩小到初始化列表中的'int'

程序决定使用类型说明符auto。他尝试了两种方法

int main()
{
    auto x { 10 };
    x = 20;
}

和

int main()    
{
    auto x = { 10 };
    x = 20;
}

和...一些编译器编译了第一个程序，但没有编译第二个程序，一些编译器没有编译这两个程序。:)

那么使用decltype呢？

例如程序员写了

int main()
{
    int a[] = { 1, 2 };
    decltype( auto ) b = a;
}

他的编译器发出错误！

但是当程序员用括号括起来时

int main()
{
    int a[] = { 1, 2 };
    decltype( auto ) b = ( a );
}

代码编译成功！：）

现在程序员决定学习OOP。他写了一个简单的课程

struct Int
{
    Int( int x = 0 ) : x( x ) {}
    int x;
};

int main()
{
    Int x = { 10 };    
}

并且他的代码编译成功。但是程序员已经知道有函数说明符explicit并且他决定使用它

struct Int
{
    explicit Int( int x = 0 ) : x( x ) {}
    int x;
};

int main()
{
    Int x = { 10 };    
}

糟糕！他的编译器发出错误

error: chosen constructor is explicit in copy-initialization

程序员决定删除作业标志

struct Int
{
    explicit Int( int x = 0 ) : x( x ) {}
    int x;
};

int main()
{
    Int x { 10 };    
}

并且他的代码编译成功！：）

在C ++中初始化变量的正确方法是什么？

3 个答案: