blocks|key|5033816|text|No。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|5033817|不能在初始值设定项列表之外调用成员类的构造函数。|5033818|PS:即使你没有在初始化器列表中自己调用它，编译器也会隐式地调用它。|5033819|5033820|如果您不能在初始化器列表中调用它，并且您不想使用类似init的方法，那么请重新考虑您的设计/方法。|5033821|entityMap^0|0|2|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|S|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|T|8|@]|D|@]|E|$]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

No.

You cannot call the constructor of a member class outside the initializer list.

PS: Even if you don't call it yourself in the initializer list, then the compiler will do it implicitly.

<hr>

If you cannot call it in the initializer list, and you don't want to use an init-like method, then re-think your design/approach.

blocks|key|1249152|text|您有两个选择:使用动态存储或放置新的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1249153|第一个是显而易见的(正如评论中指出的，您可以使用unique_ptr)。如果您想避免这种情况，您可以尝试使用std::aligned_union作为存储来放置新的内容：|offset|length|style|CODE|1249154|class+SomeClass+{+...+};

class+Owner
{
public:
++++Owner()
++++{
++++++++m_ptr+=+new(&m_storage)+SomeClass();
++++}

++++~Owner()
++++{
+++++++++m_ptr->~SomeClass();
++++}+

private:
++++std::aligned_union<0,+SomeClass>+m_storage;
++++SomeClass*+m_ptr;
};|code-block|syntax|javascript|1249155|注意:在这种情况下，你需要负责调用对象的析构函数，如上所示。|1249156|你可以用一个unique_ptr来包装m_ptr+(使用一个只调用析构函数的deleted+)来避免这种情况：|1249157|struct+DtorDeleter+
{+
++++template<typename+T>
++++void+operator+()(T*+ptr)+{+ptr->~T();+}+
};

std::unique_ptr<SomeClass,+DtorDeleter>+m_ptr;+//+no+need+to+call+destructor+manually|1249158|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/types/aligned_union^0|0|O|A|1I|I|1I|I|0|0|0|0|6|A|J|5|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@$D|16|E|17|1|18]]|A|$]]|$1|H|3|I|5|J|7|19|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1A|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1B|8|@$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|S|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

You have two options: either use dynamic storage, or placement new.

The first one is obvious (as pointed out in comments, you can use <code>unique_ptr</code>). If you want to avoid this, you might try placement new with <a href="https://en.cppreference.com/w/cpp/types/aligned_union" rel="nofollow noreferrer"><code>std::aligned_union</code></a> as storage:

<pre><code>class SomeClass { ... };

class Owner
{
public:
 Owner()
 {
 m_ptr = new(&amp;m_storage) SomeClass();
 }

 ~Owner()
 {
 m_ptr-&gt;~SomeClass();
 } 

private:
 std::aligned_union&lt;0, SomeClass&gt; m_storage;
 SomeClass* m_ptr;
};
</code></pre>

Note: in this case, you are responsible to calling destructor of the object, as shown above.

You can wrap <code>m_ptr</code> with a <code>unique_ptr</code> (with a deleted which only calls a destructor) to avoid this:

<pre><code>struct DtorDeleter 
{ 
 template&lt;typename T&gt;
 void operator ()(T* ptr) { ptr-&gt;~T(); } 
};

std::unique_ptr&lt;SomeClass, DtorDeleter&gt; m_ptr; // no need to call destructor manually
</code></pre>

blocks|key|1249183|text|您可以为此使用联合(需要C%2B%2B11)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1249184|#include+<new>

class+Foo+{
++++public:
++++++++Foo(int+a)+{+}
};

class+Bar+{
++++public:
++++++++Bar()+{
++++++++++++new(&m_foo)+Foo(42);+//+call+the+constructor
++++++++++++//+you+can+use+m_foo+from+this+point
++++++++}

++++++++~Bar()+{
++++++++++++m_foo.~Foo();+//+call+the+destructor
++++++++}

++++private:
++++++++union+{+//+anonymous+union
++++++++++++Foo+m_foo;
++++++++};
};|code-block|syntax|javascript|1249185|请注意，您需要在~Bar()显式调用m_foo的析构函数。|offset|length|style|CODE|1249186|entityMap^0|0|0|8|6|I|5|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|N|$]]

You can use an union for this (C++11 needed):

<pre><code>#include &lt;new&gt;

class Foo {
 public:
 Foo(int a) { }
};

class Bar {
 public:
 Bar() {
 new(&amp;m_foo) Foo(42); // call the constructor
 // you can use m_foo from this point
 }

 ~Bar() {
 m_foo.~Foo(); // call the destructor
 }

 private:
 union { // anonymous union
 Foo m_foo;
 };
};
</code></pre>

Note that you need to explicitly call the destructor of <code>m_foo</code> at <code>~Bar()</code>.

blocks|key|1249232|text|我想调用所有者构造函数中的成员对象的构造函数，但由于依赖关系，无法构造初始化器列表中的成员对象|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1249233|您可以修改您的类，使其具有正确的依赖顺序，也可以使用委托构造函数：|1249234|所以转身：|1249235|struct+S
{
++++S(/*..*/)+:+/*m1(data),+m2(data),*/+data(/*..*/)+//+Issue,+m1,+m2+constructed+before+data
++++{
++++++++ComplexData2+data2+=+Query();

++++++++m1.init(data,+data2.someField1);+//+Doesn't+like+init+method
++++++++m2.init(data,+data2.someField2);+//+Doesn't+like+init+method
++++}+

++++Member1+m1;+//+Cannot+be+const+with+init+method+:/
++++Member2+m2;+//+Cannot+be+const+with+init+method+:/
++++ComplexData+data;
};|code-block|syntax|javascript|1249236|转到|1249237|struct+S
{
++++S(/*..*/)+:+S(Query()+/*,+..*/)+{}

//+private:+//+probably+private
++++S(const+ComplexData2&+data2+/*,+..*/)+:
++++++++data(/*..*/),
++++++++m1(data,+data2.someField1),
++++++++m2(data,+data2.someField2)
++++{
++++}+

public:
++++ComplexData+data;+//+Before+m1,+m2+for+dependencies.
++++/*const*/+Member1+m1;+//+Can+be+const
++++/*const*/+Member2+m2;+//+Can+be+const
};|1249238|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|V|8|@]|9|@]|A|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

want to call a constructor of a member object in the owners constructor, but can not construct the member object in the initializer-list because of dependencies

You might modify your class to have correct dependency order, and maybe use delegating constructor:

So turning:

<pre><code>struct S
{
 S(/*..*/) : /*m1(data), m2(data),*/ data(/*..*/) // Issue, m1, m2 constructed before data
 {
 ComplexData2 data2 = Query();

 m1.init(data, data2.someField1); // Doesn't like init method
 m2.init(data, data2.someField2); // Doesn't like init method
 } 

 Member1 m1; // Cannot be const with init method :/
 Member2 m2; // Cannot be const with init method :/
 ComplexData data;
};
</code></pre>

into

<pre><code>struct S
{
 S(/*..*/) : S(Query() /*, ..*/) {}

// private: // probably private
 S(const ComplexData2&amp; data2 /*, ..*/) :
 data(/*..*/),
 m1(data, data2.someField1),
 m2(data, data2.someField2)
 {
 } 

public:
 ComplexData data; // Before m1, m2 for dependencies.
 /*const*/ Member1 m1; // Can be const
 /*const*/ Member2 m2; // Can be const
};
</code></pre>

I want to call a constructor of a member object in the owners constructor, but can not construct the member object in the initializer-list because of dependencies. How can I call the constructer after my initializations? I would really like to not use an init method

C++: How to call member constructor outside the initializer list during object construction?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想在所有者构造函数中调用成员对象的构造函数，但由于依赖关系，无法在初始化器列表中构造成员对象。如何在初始化后调用构造器？我真的不想使用init方法

问C++：如何在对象构造过程中调用初始化器列表外的成员构造函数？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++：如何在对象构造过程中调用初始化器列表外的成员构造函数？EN