blocks|key|2108243|text|这是不可能的，在任何情况下都会调用默认构造函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2108244|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 is impossible, default constructor will be called in any case.

blocks|key|1087943|text|这是不可能的，因为与内置类型相反，您的类构造函数将始终被调用(+be+called+)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1087944|如果你真的想做“未初始化”的对象(为什么？由于未初始化的变量，你的bug还不够多吗？)，你可能不得不使用放置new的技巧。|offset|length|style|CODE|1087945|entityMap^0|0|1I|3|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

It is impossible, because as opposed to the built-in types, your class constructor will always be called.

If you really want to do "uninitialized" object (why ???? Don't you have enough bugs because of uninitialized variables?), you'll have to do tricks with placement <code>new</code>, probably.

blocks|key|1711113|text|如果未定义任何构造函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1711114|struct+A+{+int+x;+};

A+a;+//+default-initialized+(unintialized)
A+b+=+A();+//+value-initialized
A+c+=+{+4+};+//+four|code-block|syntax|javascript|1711115|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|$]]

If no constructors defined:

<pre><code>struct A { int x; };

A a; // default-initialized (unintialized)
A b = A(); // value-initialized
A c = { 4 }; // four
</code></pre>

blocks|key|1087621|text|class+A+{+
public:
++++A()+{}

};
A*+a+=+(A*)malloc(sizeof(A));|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1087622|(孩子们，不要在家里这样做。根本不要这样做！)|unstyled|1087623|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>class A { 
public:
 A() {}

};
A* a = (A*)malloc(sizeof(A));
</code></pre>

(kids, don't do this at home. Don't do this at all!)

blocks|key|2108308|text|“未初始化的结构”是矛盾的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2108309|构造中缺少初始化只是由于错误(无法递归构造整个对象)。|2108310|如果C%2B%2B类有构造函数，就会调用它。如果由于任何原因不能调用它，那么这种情况就是错误的(例如，传递了错误的构造参数，这些参数与任何构造函数都不匹配)。|2108311|C%2B%2B类可以包含基本类型的成员，其构造函数可以忽略对这些成员的初始化。|2108312|这可以用于优化:如果您有一个复杂的初始化，您可以避免写入这些成员的开销。|2108313|这就是这样做的方式，而不是试图创建一个可以保持未初始化的整个类。|2108314|如果你真的想要它，一种模拟它的方法是创建一个没有任何构造函数的POD+(普通老式数据结构)，然后使用一些额外的技术，以便可以以保证其初始化的方式使用它。例如，从它创建一个添加构造的派生类，或者使用奇怪的重复模板模式，等等。|2108315|然后，如果您不想初始化POD，您仍然可以直接使用它。|2108316|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|W|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|X|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|Y|8|@]|9|@]|A|$]]|$1|P|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|Q|$]]

"uninitialized construction" is oxymoronic.

Lack of initialization in construction only occurs as a result of bugs (failing to recursively construct the entire object).

If a C++ class has a constructor, it is called. If for any reason it cannot be called, then that situation is erroneous (for instance wrong construction arguments passed that don't match any constructor).

A C++ class can contain members which are of basic types, and its constructors can neglect to initialize those members.

This could be exploited for optimization: if you have a complex initialization which happens later, you can avoid the overhead of writing to those members.

That would be the way to do it, rather than trying to create an entire class that can be left uninitialized.

If you really want that, a way to emulate it would be to create a POD (plain old datastructure) without any constructors, and then use some additional techniques so that it can be used in ways that guarantee its initialization. For instance make a derived class from it which adds construction, or make use of the curiously repeating template pattern, etc.

Then you can still use the POD directly if you want it not initialized.

blocks|key|2108348|text|默认承包商将始终被调用。你可以做很多“技巧”，但这取决于你为什么想要这个行为，以及你想让用户代码看起来是什么样子。您可以定义一个特殊构造函数，该构造函数不对数据成员执行任何操作并调用该构造函数。或者，你可以做很多不同的事情...一种选择是这样..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2108349|你也可以使用模板...|2108350|struct+uninitialized_ctor+{};

class+Foo
{
public:
++int+x;
++Foo()+:+x(42)
++{
++++std::cout+<<+"Foo::Foo\n";
++}
protected:
++Foo(uninitialized_ctor+const+&)
++{
++++std::cout+<<+"Foo::Foo+-+uninitialized\n";
++}
};


struct+UninitializedFoo+:+public+Foo
{
++UninitializedFoo()
++++:+Foo(uninitialized_ctor())
++{
++++//+Does+not+call+base+class+ctor...
++++std::cout+<<+"UninitializedFoo\n";
++}
};


int+main(int,+char+*[])
{
++Foo+foo1;
++UninitializedFoo+foo2;
++Foo+*+f1+=+new+Foo();
++Foo+*+f2+=+new+UninitializedFoo();

++std::cout+<<+foo1.x+<<+'\n'+<<+foo2.x+<<+'\n'+<<+f1->x+<<+'\n'+<<+f2->x+<<+'\n';
}|code-block|syntax|javascript|2108351|但是--这取决于你真正的目标是什么。以及它如何影响代码的用户。|2108352|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|$]]

The default contractor will always be called. There are lots of "tricks" you can do, but it depends on why you want this behavior, and what you want the user code to look like. You can define a special constructor that just doe not do anything with the data members and call that. Or, you can do lots of different things... one option is this...

You can also play with templates...

<pre><code>struct uninitialized_ctor {};

class Foo
{
public:
 int x;
 Foo() : x(42)
 {
 std::cout &lt;&lt; "Foo::Foo\n";
 }
protected:
 Foo(uninitialized_ctor const &amp;)
 {
 std::cout &lt;&lt; "Foo::Foo - uninitialized\n";
 }
};


struct UninitializedFoo : public Foo
{
 UninitializedFoo()
 : Foo(uninitialized_ctor())
 {
 // Does not call base class ctor...
 std::cout &lt;&lt; "UninitializedFoo\n";
 }
};


int main(int, char *[])
{
 Foo foo1;
 UninitializedFoo foo2;
 Foo * f1 = new Foo();
 Foo * f2 = new UninitializedFoo();

 std::cout &lt;&lt; foo1.x &lt;&lt; '\n' &lt;&lt; foo2.x &lt;&lt; '\n' &lt;&lt; f1-&gt;x &lt;&lt; '\n' &lt;&lt; f2-&gt;x &lt;&lt; '\n';
}
</code></pre>

BUT -- it depends on what your real goal is... and how it impacts users of the code...

blocks|key|67874|text|聚合类类型本质上具有您喜欢的行为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|67875|struct+Foo+{+int+a;+int+b;+};

Foo+x;+++//+x.a,+x.b+uninitialized

Foo+*+p+=+new+Foo();+//+p->x,+p->y+value-initialized,+i.e.+zero

Foo+y+{+1,+2+};+//+brace-initialization+does+what+you+think

Foo+z+{+};++++++//+brace-initialization+can+also+"fake"+value-init+for+automatics|code-block|syntax|javascript|67876|对于聚合，默认初始化和值初始化以递归方式传播到成员。|67877|当然，您也可以创建一个未初始化成员的非聚合：|67878|struct+Bar
{
++++int+a;
++++int+b;
++++Bar()+:+a()+{+}++//+no+b!
++++Bar(int+a_,+int+b_)+:+a(a_),+b(b_)+{+}
};

Bar+x;+++//+x.a+is+value-,+x.b+is+default-initialized|67879|entityMap^0|0|0|0|0|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|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Aggregate class types have essentially the behaviour you like:

<pre><code>struct Foo { int a; int b; };

Foo x; // x.a, x.b uninitialized

Foo * p = new Foo(); // p-&gt;x, p-&gt;y value-initialized, i.e. zero

Foo y { 1, 2 }; // brace-initialization does what you think

Foo z { }; // brace-initialization can also "fake" value-init for automatics
</code></pre>

For aggregates, default- and value-initialization propagate recursively to members.

Of course you can also make a non-aggregate that leaves a member uninitialized:

<pre><code>struct Bar
{
 int a;
 int b;
 Bar() : a() { } // no b!
 Bar(int a_, int b_) : a(a_), b(b_) { }
};

Bar x; // x.a is value-, x.b is default-initialized
</code></pre>

blocks|key|2108390|text|也许你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2108391|template<typename+T>
struct+uninitialized+{
++++static_assert(std::is_trivially_destructible<T>::value,"T+must+have+trivial+dtor");

++++alignas(T)+char+raw[sizeof(T)];

++++template<typename...+Us>
++++T+&initialize(Us+&&...+us)+{
++++++++return+*(new+(raw)+T(std::forward<Us>(us)...));
++++}

++++T+&get()+{+return+reinterpret_cast<T&>(raw);+}
};|code-block|syntax|javascript|2108392|需要使用简单的析构函数，否则您必须跟踪对象是否已被构造，以便适当地销毁它。|2108393|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|$]]

Perhaps you could do something like this:

<pre><code>template&lt;typename T&gt;
struct uninitialized {
 static_assert(std::is_trivially_destructible&lt;T&gt;::value,"T must have trivial dtor");

 alignas(T) char raw[sizeof(T)];

 template&lt;typename... Us&gt;
 T &amp;initialize(Us &amp;&amp;... us) {
 return *(new (raw) T(std::forward&lt;Us&gt;(us)...));
 }

 T &amp;get() { return reinterpret_cast&lt;T&amp;&gt;(raw); }
};
</code></pre>

trivial destructor is required because otherwise you'd have to keep track of whether the object had been constructed or not in order to destroy it appropriately.

The constructor semantics of int/double/etc. are:

<pre><code>int a; // uninitialized
int b = int(); // zero initialized
int c = int(4); // four
</code></pre>

Is it possible to define a class with exactly the same behavior? I.e., one that has both uninitialized and initialized default constructors? I believe this is impossible, and currently work around it by making a constructor that compiles only when called with 0, but want to make sure there isn't a way to exactly mimic fundamental types.

Is it possible to make a C++ type that mimics the constructor semantics of fundamental types?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

int/double/等的构造函数语义是：int a; // uninitializedint b = int(); // zero initializedint c = int(4); // four是否有可能定义一个具有完全相同行为的类？即同时具有未初始化和已初始化的默认构造函数的构造函数？我认为这是不可能的，目前...

问有没有可能创建一个模仿基本类型的构造函数语义的C++类型？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有可能创建一个模仿基本类型的构造函数语义的C++类型？EN