值初始化。 。 。 [英] Value initialization. . .
问题描述
以下代码演示了当你这样做时：
AnyNonPOD& blah = * new AnyNonPOD（）;
该对象的成员变量*不要*初始化为零。
我一直试图找到一种方法来创建非POD的非const对象
类并将其所有成员变量初始化为零...唯一的
捕获是这个非POD将是不可复制的（即私有拷贝
构造函数）。无论如何，以下代码在我的系统上打印以下内容：
我是非常量的！
初始化为零：false
这里是代码：
#include< iostream>
class NonCopyable
{
私人：
NonCopyable（NonCopyable const&）;
public：
NonCopyable（）{}
//注意，没有初始化列表可以设置
//将事物归零。 />
unsigned int a;
unsigned char b;
void * p_c [9999999];
} ;
void Func（NonCopyable&）
{
std :: cout<< 我是非常数！\ n;
}
void Func（NonCopyable const&）
{
std :: cout<< 我是常客！\ n;
}
int main（）
{
NonCopyable& blah = * new NonCopyable（）;
Func（blah）; //确保它不是函数声明！
bool is_zero_initialized = true;
if（！blah.a&&！blah .b）
{
for（unsigned i = 0; i< 9999999; ++ i）
{
if（blah.p_c）
{
is_zero_initialized = false;
break;
} < br $>
}
}
else is_zero_initialized = false;
std :: cout<< 初始化为零： << （is_zero_initialized？
" true"：" false"）;
delete& blah;
}
总的来说，我正试图绕过一个顶级的废话并发症。在
C ++中，你不能这样做：
类对象（）;
代替必须这样做：
Class object = Class（）;
会产生2个问题。
问题A ）临时
问题B）复制构造函数必须公开
如果只有一些清晰度，如：
函数声明：extern Class object（）;
对象定义：class类object（）;
当你这样做时：
类对象（）;
或
类对象（无效）;
它是's函数声明（现在就是这样）。
-JKop
The following code demonstrates that when you do:
AnyNonPOD &blah = *new AnyNonPOD();
that the object''s member variables *don''t* get zero initialized.
I''ve been trying to find a way to create a non-const object of a non-POD
class and have all its member variables initialized to zero... the only
catch is that this non-POD will be non-copyable(ie. private copy
constructor). Anyway, the following code prints the following on my system:
I''m non-const!
Is it zero initialized: false
Here''s the code:
#include <iostream>
class NonCopyable
{
private:
NonCopyable(NonCopyable const &);
public:
NonCopyable() {}
//Note that there''s no initializer list to set
//things to zero.
unsigned int a;
unsigned char b;
void* p_c[9999999];
};
void Func(NonCopyable &)
{
std::cout << "I''m non-const!\n";
}
void Func(NonCopyable const &)
{
std::cout << "I''m const!\n";
}
int main()
{
NonCopyable &blah = *new NonCopyable();
Func(blah); //Making sure it''s not a function declaration!
bool is_zero_initialized = true;
if ( !blah.a && !blah.b )
{
for(unsigned i = 0; i < 9999999; ++i)
{
if ( blah.p_c )
{
is_zero_initialized = false;
break;
}
}
}
else is_zero_initialized = false;
std::cout << "Is it zero initialized: " << ( is_zero_initialized ?
"true" : "false" );
delete &blah;
}
Overall, I''m trying to get around one of the top "bullshit complications" in
C++, in that you can''t do:
Class object();
instead having to do:
Class object = Class();
which creates 2 problems.
Problem A) A temporary
Problem B) Copy constructor must be public
If only there were some clarity, as in:
Function Declaration: extern Class object();
Object Definition: class Class object();
and that when you did:
Class object();
or
Class object(void);
that it''s a function declaration (which is how it is now).
-JKop
推荐答案
> #include< iostream>
> #include <iostream>
class NonCopyable
{
私人：
NonCopyable（NonCopyable const&）;
公开：
NonCopyable（）{}
//请注意，没有初始化列表可以将事物设置为零。
unsigned int a;
unsigned char b;
void * p_c [9999999];
};
void Func（NonCopyable&）
{
std :: cout<< 我是非常规的！\ n;;
}
虚拟Func（NonCopyable const&）
{
std :: cout< ;< 我是常数！\ n;;
}
int main（）
{
NonCopyable& blah = * new NonCopyable（）;
const NonCopyable& blah = * new NonCopyable（）;
Func（blah）; //确保它不是函数声明！
bool is_zero_initialized = true;
if（！blah.a&&！blah.b）
{
for（unsigned i = 0; i< 9999999; ++ i）
{
if（blah.p_c）
{
is_zero_initialized =错误;
休息;
}
}
}
其他is_zero_initialized = false;
std :: cout<< 初始化为零： << （is_zero_initialized
？
" true"：" false"）;
删除& blah;
}
class NonCopyable
{
private:
NonCopyable(NonCopyable const &);
public:
NonCopyable() {}
//Note that there''s no initializer list to set
//things to zero.
unsigned int a;
unsigned char b;
void* p_c[9999999];
};
void Func(NonCopyable &)
{
std::cout << "I''m non-const!\n";
}
void Func(NonCopyable const &)
{
std::cout << "I''m const!\n";
}
int main()
{
NonCopyable &blah = *new NonCopyable();
const NonCopyable &blah = *new NonCopyable();
Func(blah); //Making sure it''s not a function declaration!
bool is_zero_initialized = true;
if ( !blah.a && !blah.b )
{
for(unsigned i = 0; i < 9999999; ++i)
{
if ( blah.p_c )
{
is_zero_initialized = false;
break;
}
}
}
else is_zero_initialized = false;
std::cout << "Is it zero initialized: " << ( is_zero_initialized
?
"true" : "false" );
delete &blah;
}
const NonCopyable& blah = * new NonCopyable（）;
const NonCopyable &blah = *new NonCopyable();
.. 。为什么？
也许你错了：
NonCopyable const& blah = NonCopyable（）;
" const"修改器在那里是必要的。 （我认为）
....但无论如何你会有一个无效的引用。 （我认为）
-JKop
.. . . Why?
Perhaps you''re mistaken with:
NonCopyable const &blah = NonCopyable();
the "const" modifier would be necessary there alright. (I think)
....but anyway you''d have an invalid reference. (I think)
-JKop
Gernot Frisch写道：
Gernot Frisch wrote:
#include< iostream>
类NonCopyable
{
私人：
NonCopyable（NonCopyable const&）;
添加
NonCopyable& operator =（NonCopyable const&）;
public：
NonCopyable（）{}
//请注意，没有初始化列表可以设置
//将事物归零。
unsigned int a;
unsigned char b;
void * p_c [9999999];
};
void Func（NonCopyable&）
{
std :: cout<< 我是非常规的！\ n;;
}
虚拟Func（NonCopyable const&）
{
std :: cout< ;< 我是常数！\ n;;
}
int main（）
{
NonCopyable& blah = * new NonCopyable（）;
#include <iostream>
class NonCopyable
{
private:
NonCopyable(NonCopyable const &);
Add
NonCopyable& operator=(NonCopyable const&);
public:
NonCopyable() {}
//Note that there''s no initializer list to set
//things to zero.
unsigned int a;
unsigned char b;
void* p_c[9999999];
};
void Func(NonCopyable &)
{
std::cout << "I''m non-const!\n";
}
void Func(NonCopyable const &)
{
std::cout << "I''m const!\n";
}
int main()
{
NonCopyable &blah = *new NonCopyable();
const NonCopyable& blah = * new NonCopyable（）;
const NonCopyable &blah = *new NonCopyable();
Func（blah）; //确保它不是函数声明！
bool is_zero_initialized = true;
if（！blah.a&&！blah.b）
{
for（unsigned i = 0; i< 9999999; ++ i）
{
if（blah.p_c）
{
is_zero_initialized =错误;
休息;
}
}
}
其他is_zero_initialized = false;
std :: cout<< 初始化为零： << （is_zero_initialized
？
" true"：" false"）;
删除& blah;
}
Func(blah); //Making sure it''s not a function declaration!
bool is_zero_initialized = true;
if ( !blah.a && !blah.b )
{
for(unsigned i = 0; i < 9999999; ++i)
{
if ( blah.p_c )
{
is_zero_initialized = false;
break;
}
}
}
else is_zero_initialized = false;
std::cout << "Is it zero initialized: " << ( is_zero_initialized
?
"true" : "false" );
delete &blah;
}
Victor
Victor
这篇关于值初始化。 。 。的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
