如何使用构造函数初始化列表？
构造函数初始化列表是一种在C++中用于初始化类成员变量的方法。它通过在构造函数的定义中使用冒号（:）后跟成员变量的初始化列表来实现。
使用构造函数初始化列表的语法如下：
ClassName::ClassName(parameters) : member1(value1), member2(value2), ... {
// 构造函数的其他代码
}其中，ClassName是类的名称，parameters是构造函数的参数列表，member1、member2等是类的成员变量，value1、value2等是成员变量的初始值。
使用构造函数初始化列表的优势有：
- 效率：使用初始化列表可以直接初始化成员变量，避免了先调用默认构造函数再赋值的过程，提高了代码的执行效率。
- 可选性：初始化列表可以用于初始化const成员变量和引用类型成员变量，而赋值操作无法对const成员变量进行初始化。
- 初始化顺序：初始化列表可以指定成员变量的初始化顺序，而不受它们在类中声明的顺序的影响。
构造函数初始化列表的应用场景包括但不限于：
- 初始化const成员变量和引用类型成员变量。
- 初始化成员变量时需要调用其他类的构造函数。
- 初始化成员变量时需要进行一些复杂的计算或逻辑操作。
在腾讯云的云计算领域，没有特定的产品与构造函数初始化列表直接相关。然而，腾讯云提供了一系列云计算产品和服务，如云服务器、云数据库、云存储等，可以帮助用户构建和管理自己的云计算基础设施。您可以访问腾讯云官方网站（https://cloud.tencent.com/）了解更多关于腾讯云的产品和服务信息。
相关·内容
如果成员对象data在构造函数的初始化列表中显示而不是，则data由其默认构造函数构造。
如果data 在构造函数的初始化列表中显示，则只需将其初始化为给定的值。这是否意味着没有创建data的构造函数调用？那么，新对象data是如何构造的呢？
浏览 6提问于2013-10-24得票数 1
回答已采纳
1回答
可以从初始化程序列表(如std::vector<int> v = {1,2,3,4,5}; )构造数组、向量和映射等类型。
这是很好的，因为初始化程序列表和向量都有一个类型。
我想知道std::pair<int, std::string> p = {1,"text"};是如何工作的。它不可能通过初始化程序列表，因为它必须有一个类型。
我听说过分段构造，但我也看不出这是怎么回事。
浏览 7提问于2022-01-25得票数 1
自C++2003以来，我们有值初始化和默认初始化。意思是：
struct Foo {
int i;
std :: string s;
};
Foo f1; // f1.s is default-constructed, f1.i is uninitialised
Foo f2 = Foo (); // f1.s is default-constructed, f1.i is zero
对吗？
现在假设我有这门课
class Bar : public Foo {
int n;
Foo f [SIZE];
public:
Bar ();
浏览 3提问于2012-02-07得票数 3
5回答
这是关于在C++中使用构造函数的一个非常琐碎的问题。我将以面试对话的形式呈现(很难以任何其他形式呈现)。
面试官-什么是构造函数？
me -构造函数是一种特殊的函数，它确保所有对象在使用前都被初始化。
面试官-什么是初始化程序列表？
me -，它是所有初始化发生的列表。只有在初始化所有数据成员或调用所有成员对象的某些构造函数之后，才会输入构造函数的主体。
面试官-，这意味着初始化是在初始化程序列表中进行的，而不是在构造函数中执行的.但是您说过构造函数初始化对象！你不是吗？你想回答我的第一个问题吗。
me -我认为构造函数是赋值的，它对已经初始化的成员对象调用赋值操作符。
所以我对你的问题是
初
浏览 8提问于2011-07-04得票数 15
回答已采纳
4回答
我在我的头文件"Test.h“中有一个类的变量，这个类没有带参数的构造函数。我有一个这样的构造函数：
Test::Test() // <-- Here he complains:
// error: no matching function for call to ‘Beer::Beer()’
{
int i = 2;
theVar = Beer(1, i); // Beer(int, int) is the only constructor
}
但我是在构造函数体的(空)初始化器列表之后初始化它的。
我该如何解决这个问题呢？如果这个问题有一
浏览 3提问于2010-06-24得票数 1
回答已采纳
我们有一个类，比方说AnimalShelter，它有一个动物列表。当我们在类级别初始化它时，它将在类负载期间或在创建对象期间创建内存。
class Animal{
String name;
}
class AnimalShelter{
private List<Animal> animals = new ArrayList<>();
}
我的理解是，它将在内存加载期间初始化该属性，或者当我们构造一个对象时，它将创建一个带有新列表的对象。一个初始化总是在类级别上。
如果我们在构造函数中初始化列表，它将只有一个引用，并且当我们创建一个对象时，它将分配内存。在类级别
浏览 3提问于2021-06-28得票数 0
回答已采纳
5回答
我需要创建一个类，该类还将两个事件列表初始化为新的空列表。我不确定这是否是要求我做的事情，但我知道如何创建一个列表以及如何创建一个构造函数。我创建了两个列表，现在我应该创建构造函数了。以下是我的列表之一：
List<Person> organize = new List<Person>();
如何将构造函数中的两个事件列表初始化为新列表？
浏览 0提问于2010-03-23得票数 3
1回答
我们知道T v(x);被称为直接初始化，而T v = x;被称为复制初始化，这意味着它将从x构建一个临时T，该T将被复制/移动到v (这很可能是被省略的)。
对于列表初始化，标准根据上下文区分两种形式。T v{x};称为直接列表初始化，而T v = {x};称为复制列表初始化。
§8.5.4 [dcl.init.list] p1
..。列表初始化可以在直接初始化或复制初始化上下文中进行；直接初始化上下文中的列表初始化称为直接列表初始化，副本初始化上下文中的列表初始化称为复制列表初始化。..。
然而，在整个标准中，只有两处引用。对于直接列表初始化，在创建像T{x} (§5.2.3/3)这
浏览 4提问于2012-11-19得票数 40
回答已采纳
1回答
我已经开始尝试C++11标准，我发现了问题，这个问题描述了如何从同一个类中的另一个ctor调用你的ctor，以避免有一个初始化方法或类似的东西。现在，我用类似于下面这样的代码尝试同样的事情：
hpp：
class Tokenizer
{
public:
Tokenizer();
Tokenizer(std::stringstream *lines);
virtual ~Tokenizer() {};
private:
std::stringstream *lines;
};
cpp：
Tokenizer::Tokenizer()
: expected('='
浏览 6提问于2012-08-30得票数 107
回答已采纳
我已经试着学了大约一个月的C++，它仍然困扰着我。例如，这段“容易”的代码：
class A
{
int m;
public:
A() = default;
int getM() { return m; }
};
class B
{
int m;
public:
// empty body and empty initializer list
B() {} // isn't this the same as "B() = default;" ?
int getM() { return m; }
};
int
浏览 1提问于2019-04-10得票数 9
回答已采纳
切线相关，跟踪初学者的问题，我最初发布的问题。
简而言之：(不使用任何标准库的容器)，我如何访问指向列表初始化的第一个和最后一个元素的T类型的指针？如果我的解释不能理解的话：
int x = {1, 2, 3, 4, 5}
如果我想创建一个自定义类template<typename T> class array<T> {};，我可以列出它-初始化，我的理解是，我可以利用std::initializer_list成为。
我的问题是:我怎样才能复制这种行为？看起来它利用了来完成这个任务，但是(除非我弄错了)，这仍然是一个问题:我如何编写代码“返回指向要在堆栈上分配的列表的第
浏览 3提问于2014-10-16得票数 0
回答已采纳
3回答
我需要知道如何让一些东西工作。我有一个带构造函数的类，在初始化器列表中初始化了一些常量。我想要的是能够创建一个不同的构造函数，它接受一些额外的参数，但仍然使用初始化器列表。如下所示：
class TestClass
{
const int cVal;
int newX;
TestClass(int x) : cVal(10)
{ newX = x + 1; }
TestClass(int i, int j) : TestClass(i)
{ newX += j; }
}
非常糟糕的例子，但它让人明白了这一点。问题是，我怎么才能让它工作呢？
浏览 3提问于2009-11-25得票数 1
回答已采纳
2回答
让我们假设我有下面的课
class NoDefaultConstructor {
NoDefaultConstructor() = delete;
...
};
还有另一个类，它有一个类型为NoDefaultConstructor的数组和其他成员
class Wrapper {
std::array<NoDefaultConstructor, 2> arr;
...
};
如何在Wrapper的构造函数中初始化数组(可能在使用std::intializer_list的初始化程序列表中)？
更具体地说，是否我可以将参数传递给Wrapper初始化程序列
浏览 9提问于2016-07-07得票数 10
回答已采纳
假设我的B班是这样的：
class B {
B (double d,double e)
private:
std::shared_ptr < class A > sp;
}
A类的构造器看起来如下：
A(double a, double b){...};
现在，我想为B类编写构造函数，在B类中，使用上面编写的构造函数构造来自A类的对象(初始化或分配)。有人能解释一下我怎么能专业地做这件事吗？我尝试了如下所示，但是我得到了一些错误，比如"term不计算到接受1参数的函数“和”初始化程序列表在这种情况下是意外的“.
class B (double d, double e){
d
浏览 7提问于2022-05-15得票数 0
回答已采纳
我必须从C++中的STL列表创建一个队列。如何在模板中创建并初始化一个列表作为类成员？
这是.h：
#pragma once
template <class T>
class QueueQ
{
public:
QueueQ(void);
~QueueQ(void);
bool empty(void);
int size(void);
T front(void);
void push(T _object);
void pop(void);
private:
int a;
list<T> m_lis
浏览 2提问于2014-09-27得票数 0
2回答
在C++11下，可以在声明时直接初始化类成员。但是，也可以在构造函数的初始化列表中再次初始化它们.为什么？
#include <iostream>
struct MyStr
{
MyStr()
:j(0)
{
std::cout << "j is " << j << std::endl; // prints "j is 0"
}
const int j = 1;
};
int main()
{
const int i = 0;
浏览 2提问于2015-09-14得票数 5
回答已采纳
1回答
在C++11之前，我们可以通过编写类似于A a = 1;的东西来进行复制初始化，它或多或少相当于A a = A(1);。也就是说，首先创建一个临时的，然后调用一个复制ctor。无论复制省略，这必须是这样的概念和复制ctor必须是可访问的。
使用C++11中的列表初始化，我们可以通过编写A a = {1, 2};来进行复制列表初始化。在我看来，这应该或多或少地等同于A a = A(1, 2);。然而，在GCC和clang上，即使复制和移动ctor无法访问(声明为私有)，A a = {1, 2}也会进行编译。不过，如果无法访问相应的复制/移动ctor，则A a = 1;不会在GCC或clang上编
浏览 4提问于2014-11-17得票数 10
回答已采纳
我想用这样的初始化列表初始化一个结构：
struct S
{
int a;
int b;
// S() : a(0), b(0){} // uncommenting will cause compile error:
// error C2440: 'initializing' : cannot convert from 'initializer-list' to 'S'
// S(int aArg, int bArg) : a(aArg), b(bAr
浏览 6提问于2014-10-18得票数 3
回答已采纳
2回答
函数在构造函数初始化列表中？
、、、、
Heyy，我正在尝试从初始化构造函数中的变量切换到使用构造函数初始化列表。
所以不要写
Class::Class(int width, int height) {
this->width = width;
this->height = height;
}
我是这样做的：
Class::Class(int width, int height) :
width(width),
height(height) {
}
但现在我的问题是..。假设我有以下构造函数：
Class::Class(int width, int height) {
this->width
浏览 1提问于2013-09-27得票数 0
回答已采纳
3回答
我关心的是一个默认构造函数和它的初始化列表。在一个简单的例子中，这是很清楚的，比如：
class A
{
protected:
double d1;
//classB obj1; //how to initialize this one in a default constructor?
public:
A (double x = 0.0): d1(x){} //constructor
virtual ~A(void) {};
//something
}
但是如何初始化拥有大量成员的classB对象呢？或者一般情况下，如何在默
浏览 3提问于2012-12-07得票数 1
回答已采纳
由于在某些情况下我只需要使用初始化程序列表，所以我习惯于在构造函数只用于设置成员值时将所有内容都放在初始化程序列表中。
就像我在这里做的那样：
template <typename generic>
class setsPool
{
protected:
set<generic> *pool;
size_t maxSets;
generic maximumValue, minimumValue;
public:
setsPool() = delete;
explicit setsPool( size_t m
浏览 2提问于2015-11-06得票数 3
回答已采纳
3回答
// Example program
#include <iostream>
#include <string>
class T{
public:
int x, y;
T(){
std::cout << "T() constr called..." << std::endl;
};
T(int x, int y):x(x),y(y){
std::cout << "T(x,y) constr called..." << s
浏览 10提问于2021-11-02得票数 4
回答已采纳
2回答
class Foo
{
public:
Foo() {}
Foo(int i)
: Foo(), m_bar(0) {}
private:
int m_bar;
};
有没有办法使这样的代码有效？
如果我们有一个委托构造函数，有没有办法在初始化列表中有多个成员，以及为什么限制委托构造函数是初始化列表中唯一的成员。
浏览 0提问于2020-03-10得票数 0
2回答
我有一个关于对基本构造函数的隐式和显式调用的问题。如果我们有这样的类层次结构：
class Person{
protected:
std::string m_name;
public:
Person(std::string& _name) : m_name(_name){std::cout << "A person is being constructed." << std::endl;}
};
class Baby : public Person{
private:
in
浏览 0提问于2015-05-19得票数 4
回答已采纳
1回答
列表初始化是隐式转换吗？
、、、
#include <iostream>
#include <string>
#include <typeinfo>
#include <typeindex>
#include <map>
#include <vector>
class Base{
public:
virtual ~Base() {}
};
class Derived: public Base { };
int main(){
int arr[10];
Derived d;
Base *p = &d;
浏览 1提问于2016-01-20得票数 7
回答已采纳
2回答
从cppref对的看法来看
如果T是没有默认构造函数的类类型，或者具有用户提供的或删除的默认构造函数，则对象为。
但是既然这个类类型已经删除了默认构造函数，那么该对象如何被默认初始化呢？
据我所知，类类型的默认初始化需要访问默认构造函数。如果我们有：
struct A {
A() = delete;
int k;
};
那么A *a = new A;就会失败，A* a = new A();也会失败。
但是A a{};还好。但是为什么呢？根据
否则，如果大括号-init-列表为空且T是一个类类型，并具有默认构造函数，则执行值初始化。
浏览 0提问于2018-05-17得票数 10
回答已采纳
2回答
我目前有一个匹配结构，它包含一个块列表。
public struct Match{
public List<Block> blocks;
}
当我尝试创建一个新的匹配(在本例中称为matchData)并将块添加到它的阻止列表时，我的编译器输出：
Use of unassigned local variable 'matchData'
我尝试通过以下操作初始化列表：
public struct Match{
public List<Block> blocks = new List<Block>();
}
这将导致以下错误：
St
浏览 0提问于2014-06-13得票数 4
回答已采纳
3回答
在您的帮助下，我可以使用构造函数初始化程序列表来解决我在这个最小示例()中描述的问题。
在我的现实生活中，事情会更困难一些。我的构造函数现在看起来有点像这样：
ClassC::ClassC() : _objectB(_objectA.getInt()) {
_objectA = ClassA();
}
这个能行吗？编译器不返回任何错误。但是，_objectB是用_objectA值初始化的，该值在下面的行中初始化。那么_objectA.getInt()将如何返回一个有效值？
如果它不起作用，我怎样才能使它起作用？
浏览 5提问于2016-11-17得票数 2
回答已采纳
3回答
我知道这一点，因为这将把构造函数参数分配给类成员：
class A
{
public:
some_type B;
A(some_type B)
{
this->B = B;
}
}
但是这会有什么作用呢：
class A
{
public:
some_type B;
A(some_type B) : B(B)
{
}
}
这是将参数赋值给自身，还是将参数赋值给类成员，或者执行其他操作？
在construct thing (
浏览 1提问于2011-09-13得票数 2
回答已采纳
目前，我试图围绕C++11的统一初始化。我遇到了一个模棱两可的情况:考虑一个类，它既可以由两个参数的构造函数构造，也可以用任意长度的初始化程序列表来构造：
class Foo {
public:
Foo(int a, int b) {
std::cout << "constructor 1" << std::endl;
}
Foo(std::initializer_list<int>) {
std::cout << "constructor 2" <<
浏览 10提问于2020-10-01得票数 7
回答已采纳
2回答
我相信任何未初始化的东西都会自动初始化，这有点危险(而且实践也很糟糕)。我还理解初始化列表通常更高效(在某些情况下是必要的)，但是，在分配给成员变量之前，我希望通过函数调用验证一些参数。
例如，使用典型的赋值构造函数，我可以得到如下内容：
class MyObj
{
private:
int one_;
int two_;
DiffObj diffObj_;
... // other stuff
}
MyObj::MyObj(int a, int b, std::string type, std::vector<doub
浏览 2提问于2016-09-06得票数 2
回答已采纳
问题
以下两种代码的输出是相同的，但本质上的区别是什么？
import 'dart:math';
class Point {
final num x;
final num y;
final num distanceFromOrigin;
Point(x, y)
: x = x,
y = y,
distanceFromOrigin = sqrt(x * x + y * y);
}
main() {
var p = Point(3, 4);
print(p.distanceFromOrigin);
}
我的
浏览 0提问于2018-08-25得票数 22
回答已采纳
我目前的情况如下。这是一个或多或少简单的继承案例，我对此有很多疑问。
我有一个抽象类(=它有纯虚拟函数)，它有两个变量foo_和bar_。foo_由构造函数中的参数设置。对于大多数子类，bar_应该默认为1000，但我希望有一个特定的类将其重写为50000。
下面是一个代码片段：
class Base {
protected:
const int foo_;
const int bar_;
public:
Base(int foo) : foo_{foo}, bar_{1000} {}
}
class Derived : public Base {}
首先，有一个简单的问题:
浏览 8提问于2019-11-07得票数 0
回答已采纳
std::pair没有以初始化程序列表作为参数的构造函数，但是下面的代码是如何编译的？
void foo(std::pair<int,int> pr)
{
}
void foo2(std::tuple<int,int,int> t)
{
}
void bar()
{
foo({1,2}); // compile OK
foo(std::pair<int,int>{1,2}); // compile OK
foo2(std::tuple<int
浏览 3提问于2015-12-10得票数 3
回答已采纳
有了C++11，我们现在可以在头声明中初始化类成员：
class aClass
{
private:
int mInt{100};
public:
aClass();
~aClass();
};
所以我有点困惑。传统上，构造函数中的初始化列表用于成员初始化：
aClass::aClass()
: mInt(100)
{
...
}
声明时新的C++11成员初始化特性是否已使初始化列表过时？如果不是，其中一个比另一个有什么优势？什么情况会使声明时的初始化或初始化列表的初始化变得有利？什么时候应该使用一种而不是另一种？
浏览 0提问于2014-06-11得票数 82
回答已采纳
为什么下面的代码提供不同的输出？
std::vector<int> v{12};
std::cout << v.size() << std::endl;
std::vector<int> v(12);
std::cout << v.size() << std::endl;
如果我列出-初始化一个对象，该对象具有接受initializer_list作为参数的ctor？
如何通过列表初始化调用std::vector::vector(size_t)？
浏览 5提问于2022-04-04得票数 1
回答已采纳
在C#中哪种对象初始化样式更合适？
声明私有对象并在同一行中初始化它：
私有列表行=新列表()；
声明私有对象并在构造函数中初始化它：
私人列表行；
内构造函数
rows =新List()；
声明私有对象并在使用它的方法中初始化它：
私人列表行；
在我的Run()方法中
rows =新List()；
谢谢
浏览 6提问于2012-12-31得票数 2
回答已采纳
1回答
我正在学习建构主义者。我感到困惑的一部分是构造函数的初始化器列表部分。例如，看看下面的代码
class a{
Public:
typedef std::string::size_type pos;
s() = default;
s(pos ht, pos wt, char c) : height(ht), width(wt), contents(ht * wt, c);
private:
pos height, width;
std::string contents;
};
我不理解/无法读取的部分是最后一次列表初始化器contents(ht * wt, c)，我从未见过有
浏览 2提问于2015-02-15得票数 0
回答已采纳
1回答
列表初始化规则
、、、
我想用计数和值初始化std::vector<char>。
这样做是可行的：
int n = 100;
std::vector<char> v(n, 0);
但是，列表初始化std::vector<char> v{n, char(0)};提供了以下内容：
warning: narrowing conversion of ‘n’ from ‘int’ to ‘char’.
是否有方法使用列表初始化语法，但避免调用initializer_list构造函数？
浏览 10提问于2022-06-24得票数 1
回答已采纳
1回答
为了说明这个问题，让我们考虑这两个简单的定义，Bar是一个用户类型，具有来自int的显式构造函数：
struct Bar
{
explicit Bar(int a)
{}
};
void f(Bar)
{}
现在，正如所说：
直接列表初始化(同时考虑显式和非显式构造函数)
我们可以这样初始化一个实例。
Bar b1{5};
但是，这是以这种方式调用函数的编译错误。
f({5});
它仍然天真地看起来像Bar参数f的直接列表初始化，而且人们可能会争辩说，在参数周围使用大括号可以使它.明示的。
禁止对列表初始化函数参数使用显式构造函数的理由是什么？
编辑
链接页面确实是说
浏览 3提问于2016-12-16得票数 1
我有一个棘手的C++问题:当你有一个带有委托构造函数的构造函数初始化列表时，列表的执行顺序是什么？
这里有两个相互冲突的标准规则：
1.)构造函数初始化列表不是按列表顺序执行的，而是按项的声明顺序执行的。
2.)构造函数初始化列表中的委托构造函数总是在“母构造函数”执行之前被调用。
哪条规则更优越？(因为构造函数也是一个类项目)为什么这很重要:假设委托构造函数重新初始化一个已经由“母构造函数”初始化的项目，反之亦然。
浏览 1提问于2013-02-14得票数 5
回答已采纳
因为容器小部件有一个约束实例变量。但是构造函数也有一个约束参数。
在initializor列表中，我们可以看到如下代码：
constraints = (****） constraints;
那么，我们如何知道哪些约束是对实例变量的引用，哪些约束是对函数参数的引用？
浏览 0提问于2021-06-29得票数 1
回答已采纳
1回答
在标准文本中，8.5.4 (3)列表初始化dcl.init.list中有一个示例
struct S {
S(std::initializer_list<double>); // #1
S(const std::string&); // #2
};
const S& r1 = { 1, 2, 3.0 }; // OK: invoke #1
const S& r2 { "Spinach" }; // OK: invoke #2 !!!
(这个例子是关于推荐到临时的，但我在这里指的是重载解析)。
斯
浏览 1提问于2011-07-19得票数 3
回答已采纳
6回答
最近，我在初始化程序列表中遇到了一些问题。考虑一个存储类似地图数据的程序。
struct MyMapLike {
MyMapLike(std::map<std::string, int> data)
:data(std::move(data))
{ }
private:
std::map<std::string, int> data;
};
往前看。但是当初始化它时，它就变得丑陋了。我想让它看起来像
MyMapLike maps = { { "One", 1 }, { "Two", 2 } };
但是编译器不想接受这
浏览 0提问于2011-04-20得票数 25
3回答
嘿，我对构造函数如何初始化向量的大小有点困惑>。这是我的hpp
#include <vector>
#include <list>
#include <ostream>
using namespace std ;
typedef struct { double successful[2] , unsuccessful[2] ; } Perform ;
template <class DATA>
class Table {
private :
vector<list<DATA> > theList;
浏览 1提问于2012-02-13得票数 0
4回答
我倾向于在构造函数中使用成员初始化列表...但我早就忘记了背后的原因...
您是否在构造函数中使用成员初始化列表？如果有，原因何在？若否，原因为何？
浏览 34提问于2009-05-29得票数 252
回答已采纳
1回答
代码中由clang 3.5.0和gcc 4.9.1生成的可执行文件
#include <iostream>
struct Foo
{
Foo() { std::cout << "Foo()" << std::endl; }
Foo(int x) { std::cout << "Foo(int = " << x << ")" << std::endl; }
Foo(int x, int y) { std::cout << "F
浏览 3提问于2014-11-06得票数 15
回答已采纳
1回答
我知道这类问题被问了很多次，我读过关于它的不同答案，以及ISO标准的一些部分。
但是，我仍然需要对所期望的C++标准的确切行为做一些澄清。
假设这一点：
class A
{
public:
A( void ) {}
A( const A & a ) {}
};
class B: public A
{
public:
B( void ) {}
B( const B & b ) {}
};
我知道调用B类的复制构造函数不会调用A类的复制构造函数，我们可以使用初始化列表来正确地完成它。
我还知道如何
浏览 1提问于2014-11-18得票数 3
回答已采纳
当使用包含多个大括号内列表的大括号列表时，B、C和D的标准定义了哪些规则？
对于B，我相信这个场景在标准中被定义为一个带有单个元素的大括号-init-列表，因此它直接调用Test(int)而没有临时的--但是我找不到位置。
对于C和D，我不确定这是否是未定义的行为。
我还感兴趣的是，当使用多个元素(即{{{1, 2}}} )时会发生什么，以及这是否会改变B、C或D的行为？
#include <iostream>
struct Test {
Test(const int a) {
// A and B call this
}
Test(Te
浏览 0提问于2018-11-02得票数 12
回答已采纳
2回答
这个程序合法吗？
struct X { X(const X &); };
struct Y { operator X() const; };
int main() {
X{Y{}}; // ?? error
}
在之后，经修正的13.3.3.1 over.best.ics有：
然而，当考虑构造函数或用户定义的转换函数的参数时.到13.3.1.7 ..。当初始化器列表正好有一个元素，并且对于X的构造函数的第一个参数考虑转换到某类X或引用(可能是cv限定的)X时，只考虑标准转换序列和省略转换序列。
这似乎很不正常；其结果是使用列表初始化强制转换指定转换是非法的：
void
浏览 1提问于2012-10-01得票数 6
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
