blocks|key|4571741|text|委托构造函数的一个关键用途是获得额外的模板参数包，特别是指定成员初始化器所需的整数索引序列：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4571742|例如：|4571743|struct+constant_t;

template+<class+T,+size_t+N>
struct+Array+{
++++T+data[N];
++++template+<size_t...+Is>
++++constexpr+Array(constant_t,+T+const+&value,+std::index_sequence<Is...>)
++++++++:+data+{+(Is,value)...+}
++++{}

++++constexpr+Array(constant_t,+T+const+&value)
++++++++:+Array(constant_t{},+value,+std::make_index_sequence<N>{})
++++{}
};|code-block|syntax|javascript|4571744|通过这种方式，我们可以定义一个构造函数，该构造函数将数组初始化为常量值，而无需首先默认初始化每个元素。据我所知，实现这一点的另一种方法是将数据成员粘贴到基类中。|4571745|当然，对模板参数包的更好的语言支持可能会使这一点变得不必要。|4571746|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

One key use of delegating constructors that doesn't merely reduce code duplication is to obtain additional template parameter packs, particular a sequence of integer indices, needed to specify a member initializer:

For example:

<pre class="lang-cpp prettyprint-override"><code>struct constant_t;

template &lt;class T, size_t N&gt;
struct Array {
 T data[N];
 template &lt;size_t... Is&gt;
 constexpr Array(constant_t, T const &amp;value, std::index_sequence&lt;Is...&gt;)
 : data { (Is,value)... }
 {}

 constexpr Array(constant_t, T const &amp;value)
 : Array(constant_t{}, value, std::make_index_sequence&lt;N&gt;{})
 {}
};
</code></pre>

In this way we can define a constructor that initializes the array to a constant value without first default initializing each element. The only other way to achieve this, as far as I know, would require sticking the data member in a base class.

Of course, better language support for template parameter packs might make this unnecessary.

blocks|key|65450|text|我描述了Overload+#113中委托构造函数的另一种用法，它简化了Cassio+Neri的Complex+Logic+in+the+Member+Initialiser+List中重载#112中描述的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|65451|与函数体中的代码不同，在编写构造函数的成员初始值设定项时，不能创建局部变量来存储多个成员所需的中间结果。|65452|考虑如下的构造函数：|65453|double+some_expensive_calculation(double+d);

bar::bar(double+d)
:+x_(cos(some_expensive_calculation(d))),+y_(sin(some_expensive_calculation(d)))
{+}|code-block|syntax|javascript|65454|我们希望避免执行两次昂贵的计算(在Cassio描述的原始问题的上下文中，基类也想要计算的结果，因此您不能在构造函数体中简单地分配给x_和y_+)。|style|CODE|65455|我描述的技巧是计算中间结果并委托给使用该结果的另一个构造函数：|65456|class+bar+{
++struct+tag+{+};
++...
++bar(double+result,+tag);

public:
++bar(double+d);
};

bar::bar(double+d)
:+bar(some_expensive_calculation(d),+tag{})
{+}

bar::bar(double+result,+tag)
:+x_(cos(result)),+y_(sin(result))
{+}|65457|entityMap|0|LINK|mutability|MUTABLE|url|http://accu.org/index.php/journals/1876|1|http://accu.org/index.php/journals/1882^0|4|D|0|1B|18|1|0|0|0|0|1T|2|1W|2|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]]|C|$]]|$1|D|3|E|5|6|7|1B|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1C|8|@]|9|@]|C|$]]|$1|H|3|I|5|J|7|1D|8|@]|9|@]|C|$K|L]]|$1|M|3|N|5|6|7|1E|8|@$A|1F|B|1G|O|P]|$A|1H|B|1I|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|C|$]]|$1|S|3|T|5|J|7|1K|8|@]|9|@]|C|$K|L]]|$1|U|3|-4|5|6|7|1L|8|@]|9|@]|C|$]]]|V|$W|$5|X|Y|Z|C|$10|11]]|12|$5|X|Y|Z|C|$10|13]]]]

I described another use of delegating constructors in <a href="http://accu.org/index.php/journals/1876" rel="nofollow">Overload #113</a> which simplifies the solutions described in Cassio Neri's <a href="http://accu.org/index.php/journals/1882" rel="nofollow">Complex Logic in the Member Initialiser List</a> in Overload #112.

Unlike code inside a function body, when you are writing a constructor's member initialisers you cannot create a local variable to store an intermediate result that is needed by more than one of the members.

Consider a constructor like this:

<pre><code>double some_expensive_calculation(double d);

bar::bar(double d)
: x_(cos(some_expensive_calculation(d))), y_(sin(some_expensive_calculation(d)))
{ }
</code></pre>

We want to avoid performing the expensive calculation twice (and in the context of the original problem described by Cassio, a base class also wants the result of the calculation, so you cannot simply assign to <code>x_</code> and <code>y_</code> in the constructor body).

The trick I described is to calculate the intermediate result and delegate to another constructor that uses that result:

<pre><code>class bar {
 struct tag { };
 ...
 bar(double result, tag);

public:
 bar(double d);
};

bar::bar(double d)
: bar(some_expensive_calculation(d), tag{})
{ }

bar::bar(double result, tag)
: x_(cos(result)), y_(sin(result))
{ }
</code></pre>

blocks|key|65493|text|在我看来，值得一提的是，偶尔有人建议，可以通过将公共代码重构为私有init-function来减轻多个构造函数之间的代码重复。这样做的问题是，如果类有朋友，这些朋友可以多次调用init+-它不应该被多次调用。委托构造函数可以防止此类问题，因为构造函数不能在对象初始化后运行。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|65494|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It seems to me that it's worth mentioning that it has occasionally been suggested that the code duplication between multiple constructors can be alleviated by refactoring the common code into a private init-function. The problem with that is that if the class has friends, those friends can invoke the init multiple times - and it's not supposed to be invoked multiple times. Delegating constructors prevent such problems by the virtue that constructors cannot run after the object has been initialized already.

I cannot understand what the use is of delegating constructors. Simply, what cannot be achieve without having delegating constructors? 

It can do something simple like this

<pre><code>class M 
{
 int x, y;
 char *p;
public:
 M(int v) : x(v), y(0), p(new char [MAX]) {}
 M(): M(0) {cout&lt;&lt;"delegating ctor"&lt;&lt;endl;}
};
</code></pre>

But I don't see it is worth introduce a new feature for such a simple thing? May be I couldn't recognize the important point. Any idea?

Why did C++11 introduce delegating constructors?

我不明白委托构造函数的用途是什么。简单地说，没有委托构造函数就不能实现什么？它可以像这样做一些简单的事情class M { int x, y; char *p;public: M(int v) : x(v), y(0), p(new char [MAX]) {} M(): M(0) {cout<<"delegating...

问为什么C++11引入了委托构造函数？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么C++11引入了委托构造函数？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么C++11引入了委托构造函数？
EN