blocks|key|1560972|text|它将被它的默认构造函数初始化。如果你想使用一个不同的构造函数，你可能会有这样的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1560973|class+Foo
{
++++public:+
++++Foo(int+val)+{+}
++++//stuff
};

class+Bar
{
++++public:
++++Bar()+:+foo(2)+{+}

++++Foo+foo;
};|code-block|syntax|javascript|1560974|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It will be initialized by its default constructor. If you want to use a different constructor, you might have something like this:

<pre><code>class Foo
{
 public: 
 Foo(int val) { }
 //stuff
};

class Bar
{
 public:
 Bar() : foo(2) { }

 Foo foo;
};
</code></pre>

blocks|key|1345470|text|如果您没有在Bar的构造函数中显式调用foo的构造函数，那么将使用默认的构造函数。可以通过显式调用构造函数来控制这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1345471|Bar::Bar()+:+foo(42)+{}|code-block|syntax|javascript|1345472|当然，这是假设您在代码中添加了Foo::Foo(int)+:)|1345473|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you do not explicitly call a constructor of foo inside of Bar's constructor then the default one will be used. You can control this by explicitly calling the constructor

<pre><code>Bar::Bar() : foo(42) {}
</code></pre>

This is of course assuming you add a Foo::Foo(int) to the code :)

blocks|key|1561111|text|完整对象。不，它是在Bar的默认构造函数中默认构造的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561112|现在，如果Foo有一个只接受int的构造函数。您需要在Bar中使用一个构造函数来调用Foo的构造函数，并说明这是什么：|1561113|class+Foo+{
public:
++++Foo(int+x)+{+....+}
};

class+Bar+{
public:
++++Bar()+:+foo(42)+{}

++++Foo+foo;
};|code-block|syntax|javascript|1561114|但是如果Foo有一个默认的构造函数Foo()，编译器会自动生成Bar的构造函数，这将调用Foo的默认构造函数(即Foo())|1561115|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Full object. No, it's default constructed in Bar's default constructor.

Now, if Foo had a constructor that only took, say, an int. You'd need a constructor in Bar to call Foo's constructor, and say what that is:

<pre><code>class Foo {
public:
 Foo(int x) { .... }
};

class Bar {
public:
 Bar() : foo(42) {}

 Foo foo;
};
</code></pre>

But if Foo had a default constructor Foo(), the compiler generates Bar's constructor automatically, and that would call Foo's default (i.e. Foo())

blocks|key|1345594|text|除非另行指定，否则foo将使用其默认构造函数进行初始化。如果你想使用其他的构造函数，你需要在Bar的初始化器列表中这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1345595|Bar::Bar(+int+baz+)+:+foo(+baz+)
{
++++//+Rest+of+the+code+for+Bar::Bar(+int+)+goes+here...
}|code-block|syntax|javascript|1345596|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Unless you specify otherwise, foo is initialized using its default constructor. If you want to use some other constructor, you need to do so in the initializer list for Bar:

<pre><code>Bar::Bar( int baz ) : foo( baz )
{
 // Rest of the code for Bar::Bar( int ) goes here...
}
</code></pre>

blocks|key|1561242|text|您不需要在C%2B%2B中显式调用默认构造器，它将为您调用。如果你想调用不同的构造器，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561243|Foo+foo(somearg)|code-block|syntax|javascript|1561244|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You do not need to call the default contructor explicitly in C++, it will be called for you. If you wanted to call a different contructor, you could do this:

<pre><code>Foo foo(somearg)
</code></pre>

blocks|key|1345727|text|如果可以，C%2B%2B编译器将为每个类生成四个函数，如果您不提供它们:一个默认构造函数、一个复制构造函数、一个赋值操作符和一个析构函数。在C%2B%2B标准(第12章，“特殊函数”)中，这些被称为“隐式声明”和“隐式定义”。他们将拥有公共访问权限。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1345728|不要混淆构造函数中的“隐式定义”和“默认”。默认构造函数是可以在没有任何参数的情况下调用的函数。如果不提供构造函数，则默认构造函数将被隐式定义。它将使用每个基类和数据成员的默认构造函数。|1345729|所以，Foo类有一个隐式定义的默认构造函数，而Bar+(似乎没有用户定义的构造函数)使用它的隐式定义的默认构造函数来调用Foo的默认构造函数。|1345730|如果您确实想为Bar编写一个构造函数，可以在它的初始化器列表中提到foo，但是因为您使用的是默认构造函数，所以实际上不必指定它。|1345731|请记住，如果您确实为Foo编写了一个构造函数，编译器将不会自动生成默认构造函数，因此如果您需要一个构造函数，则必须指定一个。因此，如果您要将类似Foo(int+n);的内容放入Foo的定义中，并且没有显式地编写默认构造函数(+Foo();或Foo(int+n+=+0);)，那么就不可能有目前形式的Bar，因为它不能使用Foo的默认构造函数。在这种情况下，必须有一个像Bar(int+n+=+0):+foo(n)+{}这样的构造函数，让Bar构造函数初始化Foo。(请注意，Bar(int+n+=+0)+{foo+=+n;}或类似的东西不能工作，因为Bar构造函数将首先尝试初始化foo，但这将失败。)|offset|length|style|CODE|1345732|entityMap^0|0|0|0|0|20|B|35|6|3C|F|54|P|6L|P|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$J|U|K|V|L|M]|$J|W|K|X|L|M]|$J|Y|K|Z|L|M]|$J|10|K|11|L|M]|$J|12|K|13|L|M]]|9|@]|A|$]]|$1|N|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|O|$]]

There are four functions the C++ compiler will generate for each class, if it can, and if you don't provide them: a default constructor, a copy constructor, an assignment operator, and a destructor. In the C++ Standard (chapter 12, "Special Functions"), these are referred to as "implicitly declared" and "implicitly defined". They will have public access.

Don't confuse "implicitly-defined" with "default" in a constructor. The default constructor is the one that can be called without any arguments, if there is one. If you provide no constructor, a default one will be implicitly defined. It will use the default constructors for each base class and data member.

So, what is happening is that class Foo has an implicitly defined default constructor, and Bar (which doesn't seem to have a user-defined constructor) uses its implicitly defined default constructor which calls Foo's default constructor.

If you did want to write a constructor for Bar, you could mention foo in its initializer list, but since you're using the default constructor you don't actually have to specify it.

Remember that, if you do write a constructor for Foo, the compiler will not automatically generate a default constructor, and so you will have to specify one if you need one. Therefore, if you were to put something like <code>Foo(int n);</code> into the definition of Foo, and didn't explicitly write a default constructor (either <code>Foo();</code> or <code>Foo(int n = 0);</code>), you couldn't have a Bar in its present form, since it couldn't use Foo's default constructor. In this case, you'd have to have a constructor like <code>Bar(int n = 0): foo(n) {}</code> having the Bar constructor initialize the Foo. (Note that <code>Bar(int n = 0) {foo = n;}</code> or the like wouldn't work, since the Bar constructor would first try to initialize foo, and that would fail.)

blocks|key|1345806|text|用于设置对象的初始状态的构造函数。在继承层次结构的情况下，基类对象将按照继承层次结构(+OO术语中的IS-A关系)的顺序构造，然后是派生类对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1345807|类似地，当一个对象嵌入到另一个对象中(在OO术语或容器中是HAS-A关系)时，嵌入对象的构造函数按照它们的声明顺序被调用。|1345808|编译器解析类B的所有成员，然后为每个方法生成代码。在这一点上，它知道所有的成员和它们的顺序，它将按顺序构造成员，使用默认构造函数，除非另有指定。因此，foo是在没有显式调用其默认构造函数的情况下构造的。你需要做的就是创建Bar的对象。|1345809|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Constructor meant for setting an initial state of object. In case of inheritance hierarchy, base class objects will be constructed in the order of inheritance hierarchy (IS-A relation in OO terminology) followed by derived class objects.

Similarly when an object is embedded in another object (HAS-A relation in OO terms or containment), constructors of embedded object are called in the order of their declaration.

The compiler parses all the members of the class B, and then generates the code for each method. At that point, it knows all the members and their order, and it'll construct the members in order, using the default constructors unless otherwise specified. So foo is constructed without calling explicitly its default constructor. What you need to do is just create object of Bar.

I'm fairly new to C++, and I'm not sure about this one. Have a look at the following example which sums up my current problem.

<pre><code>class Foo
{
 //stuff
};

class Bar
{
 Foo foo;
};
</code></pre>

So Bar constains a full Foo object, not just a reference or pointer. Is this object initialized by its default constructor ? Do I need to explicitly call its constructor, and if so, how and where ?

Thanks.

C++ - construction of an object inside a class

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我是C++的新手，对这一点我不太确定。看看下面的例子，它总结了我目前的问题。class Foo{    //stuff};class Bar{    Foo foo;};所以Bar约束了一个完整的Foo对象，而不仅仅是一个引用或指针。此对象是由其默认构造函数初始化的吗？我需要显式地调用它的构造函数吗?如果需要，如何调用...

问C++ -在类中构造对象
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++ -在类中构造对象EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++ -在类中构造对象
EN