blocks|key|1166025|text|因为初始化需要时间。在C%2B%2B中，您应该对任何变量做的第一件事就是显式地初始化它：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1166026|int+*+p+=+&+some_int;|code-block|syntax|javascript|1166027|或者：|1166028|int+*+p+=+0;|1166029|1166030|class+A+{
+++public:
+++++A()+:+p(+0+)+{}++//+initialise+via+constructor
+++private:
+++++int+*+p;
};|1166031|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Q|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|R|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|K|3|H|5|6|7|T|8|@]|9|@]|A|$]]|$1|L|3|M|5|D|7|U|8|@]|9|@]|A|$E|F]]|$1|N|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|O|$]]

Because initialisation takes time. And in C++, the very first thing you should do with any variable is to explicitly initialise it:

<pre><code>int * p = &amp; some_int;
</code></pre>

or:

<pre><code>int * p = 0;
</code></pre>

or:

<pre><code>class A {
 public:
 A() : p( 0 ) {} // initialise via constructor
 private:
 int * p;
};
</code></pre>

blocks|key|1381129|text|此外，我们确实有一个警告，当你搞砸它的时候：“在赋值之前可能使用”或类似的动词，这取决于你的编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381130|你编译的时候会有警告，对吧？|1381131|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Besides, we do have a warning for when you blow it: "is possibly used before assigned a value" or similar verbage depending on your compiler.

You do compile with warnings, right?

blocks|key|1381095|text|在极少数情况下，变量被取消初始化是有意义的，而且默认初始化的成本很小，那么为什么要这样做呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381096|C%2B%2B不是C89。见鬼，连C都不是C89。您可以混合声明和代码，因此应该将声明推迟到有合适的值进行初始化时再进行声明。|1381097|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

There are vanishingly few situations in which it ever makes sense for a variable to be uninitialized, and default-initialization has a small cost, so why do it?

C++ is not C89. Hell, even C isn't C89. You can mix declarations and code, so you should defer declaration until such a time as you have a suitable value to initialize with.

blocks|key|1381199|text|指针只是另一种类型。如果你创建了一个int，char或者任何其他的POD类型，它不会被初始化为零，那么为什么要初始化一个指针呢？对于像这样编写程序的人来说，这可能被认为是不必要的开销。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1381200|char*+pBuf;
if+(condition)
{
++++pBuf+=+new+char[50];
}
else
{
++++pBuf+=+m_myMember->buf();
}|code-block|syntax|javascript|1381201|如果你知道你要初始化它，为什么当你第一次在方法的顶部创建pBuf时，程序会产生成本呢？这就是零开销原则。|1381202|entityMap^0|I|3|M|4|0|0|S|4|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

A pointer is just another type. If you create an <code>int</code>, <code>char</code> or any other POD type it isn't initialised to zero, so why should a pointer? This could be considered unnecessary overhead to someone who writes a program like this.

<pre><code>char* pBuf;
if (condition)
{
 pBuf = new char[50];
}
else
{
 pBuf = m_myMember-&gt;buf();
}
</code></pre>

If you know you're going to initialise it, why should the program incur a cost when you first create <code>pBuf</code> at the top of the method? This is the zero overhead principle.

blocks|key|1381415|text|请注意，静态数据被初始化为0(除非您另行说明)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381416|是的，你应该总是尽可能晚的声明你的变量，并且使用一个初始值。代码类似于|1381417|int+j;
char+*foo;|code-block|syntax|javascript|1381418|当你读到它的时候，应该会敲响警钟。我不知道有没有lint可以被说服来吹毛求疵，因为它是100%25合法的。|offset|length|1381419|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Lint_%2528software%2529^0|0|0|0|O|4|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

Note that static data is initialized to 0 (unless you say otherwise).

And yes, you should always declare your variables as late as possible and with an initial value. Code like 

<pre><code>int j;
char *foo;
</code></pre>

should set off alarm bells when you read it. I don't know if any <a href="http://en.wikipedia.org/wiki/Lint_%28software%29" rel="nofollow noreferrer">lint</a>s can be persuaded to carp about it though since it's 100% legal.

blocks|key|1381593|text|如果您希望指针始终初始化为NULL，则可以使用C%2B%2B模板来模拟该功能：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381594|template<typename+T>+class+InitializedPointer
{
public:
++++typedef+T+++++++TObj;
++++typedef+TObj++++*PObj;
protected:
++++PObj++++++++m_pPointer;

public:
++++//+Constructors+/+Destructor
++++inline+InitializedPointer()+{+m_pPointer=0;+}
++++inline+InitializedPointer(PObj+InPointer)+{+m_pPointer+=+InPointer;+}
++++inline+InitializedPointer(const+InitializedPointer&+oCopy)
++++{+m_pPointer+=+oCopy.m_pPointer;+}
++++inline+~InitializedPointer()+{+m_pPointer=0;+}

++++inline+PObj+GetPointer()+const++{+return+(m_pPointer);+}
++++inline+void+SetPointer(PObj+InPtr)++{+m_pPointer+=+InPtr;+}

++++//+Operator+Overloads
++++inline+InitializedPointer&+operator+=+(PObj+InPtr)
++++{+SetPointer(InPtr);+return(*this);+}
++++inline+InitializedPointer&+operator+=+(const+InitializedPointer&+InPtr)
++++{+SetPointer(InPtr.m_pPointer);+return(*this);+}
++++inline+PObj+operator+->()+const+{+return+(m_pPointer);+}
++++inline+TObj+&operator+*()+const+{+return+(*m_pPointer);+}

++++inline+bool+operator!=(PObj+pOther)+const
++++{+return(m_pPointer!=pOther);+}
++++inline+bool+operator==(PObj+pOther)+const
++++{+return(m_pPointer==pOther);+}
++++inline+bool+operator!=(const+InitializedPointer&+InPtr)+const
++++{+return(m_pPointer!=InPtr.m_pPointer);+}
++++inline+bool+operator==(const+InitializedPointer&+InPtr)+const
++++{+return(m_pPointer==InPtr.m_pPointer);+}

++++inline+bool+operator<=(PObj+pOther)+const
++++{+return(m_pPointer<=pOther);+}
++++inline+bool+operator>=(PObj+pOther)+const
++++{+return(m_pPointer>=pOther);+}
++++inline+bool+operator<=(const+InitializedPointer&+InPtr)+const
++++{+return(m_pPointer<=InPtr.m_pPointer);+}
++++inline+bool+operator>=(const+InitializedPointer&+InPtr)+const
++++{+return(m_pPointer>=InPtr.m_pPointer);+}

++++inline+bool+operator<(PObj+pOther)+const
++++{+return(m_pPointer<pOther);+}
++++inline+bool+operator>(PObj+pOther)+const
++++{+return(m_pPointer>pOther);+}
++++inline+bool+operator<(const+InitializedPointer&+InPtr)+const
++++{+return(m_pPointer<InPtr.m_pPointer);+}
++++inline+bool+operator>(const+InitializedPointer&+InPtr)+const
++++{+return(m_pPointer>InPtr.m_pPointer);+}
};|code-block|syntax|javascript|1381595|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 you want a pointer that is always initialized to NULL, you can use a C++ template to emulate that functionality:

<pre><code>template&lt;typename T&gt; class InitializedPointer
{
public:
 typedef T TObj;
 typedef TObj *PObj;
protected:
 PObj m_pPointer;

public:
 // Constructors / Destructor
 inline InitializedPointer() { m_pPointer=0; }
 inline InitializedPointer(PObj InPointer) { m_pPointer = InPointer; }
 inline InitializedPointer(const InitializedPointer&amp; oCopy)
 { m_pPointer = oCopy.m_pPointer; }
 inline ~InitializedPointer() { m_pPointer=0; }

 inline PObj GetPointer() const { return (m_pPointer); }
 inline void SetPointer(PObj InPtr) { m_pPointer = InPtr; }

 // Operator Overloads
 inline InitializedPointer&amp; operator = (PObj InPtr)
 { SetPointer(InPtr); return(*this); }
 inline InitializedPointer&amp; operator = (const InitializedPointer&amp; InPtr)
 { SetPointer(InPtr.m_pPointer); return(*this); }
 inline PObj operator -&gt;() const { return (m_pPointer); }
 inline TObj &amp;operator *() const { return (*m_pPointer); }

 inline bool operator!=(PObj pOther) const
 { return(m_pPointer!=pOther); }
 inline bool operator==(PObj pOther) const
 { return(m_pPointer==pOther); }
 inline bool operator!=(const InitializedPointer&amp; InPtr) const
 { return(m_pPointer!=InPtr.m_pPointer); }
 inline bool operator==(const InitializedPointer&amp; InPtr) const
 { return(m_pPointer==InPtr.m_pPointer); }

 inline bool operator&lt;=(PObj pOther) const
 { return(m_pPointer&lt;=pOther); }
 inline bool operator&gt;=(PObj pOther) const
 { return(m_pPointer&gt;=pOther); }
 inline bool operator&lt;=(const InitializedPointer&amp; InPtr) const
 { return(m_pPointer&lt;=InPtr.m_pPointer); }
 inline bool operator&gt;=(const InitializedPointer&amp; InPtr) const
 { return(m_pPointer&gt;=InPtr.m_pPointer); }

 inline bool operator&lt;(PObj pOther) const
 { return(m_pPointer&lt;pOther); }
 inline bool operator&gt;(PObj pOther) const
 { return(m_pPointer&gt;pOther); }
 inline bool operator&lt;(const InitializedPointer&amp; InPtr) const
 { return(m_pPointer&lt;InPtr.m_pPointer); }
 inline bool operator&gt;(const InitializedPointer&amp; InPtr) const
 { return(m_pPointer&gt;InPtr.m_pPointer); }
};
</code></pre>

blocks|key|1166421|text|另一个可能的原因是，在链接时，指针被给予一个地址，但是间接寻址/解除对指针的引用是程序员的责任。通常，编译器并不关心，但将管理指针和确保不发生内存泄漏的负担传递给程序员。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1166422|实际上，简而言之，它们是在链接时为指针变量提供地址的意义上进行初始化的。在上面的示例代码中，这肯定会崩溃或生成SIGSEGV。|1166423|为了保持理智，请始终将指针初始化为NULL，这样，如果试图在不使用malloc或new的情况下取消对指针的引用，程序员就会发现程序运行不正常的原因。|offset|length|style|CODE|1166424|希望这对我有帮助，也有意义，|1166425|entityMap^0|0|0|X|6|14|3|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@$F|Q|G|R|H|I]|$F|S|G|T|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|U|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|M|$]]

Another possible reason why, is that at link-time pointers are given an address, but the indirect addressing/de-referencing a pointer is the responsibility of the programmer. Quite ordinarily, the compiler does not care less, but the burden is passed on to the programmer to manage the pointers and to make sure that no memory leaks occur. 

Really, in a nutshell, they are initialized in the sense that at link-time the pointer variable is given an address. In your example code above, that is guaranteed to crash or generate a SIGSEGV. 

For the sake of sanity, always initialize pointers to NULL, in that way if any attempt to dereference it without <code>malloc</code> or <code>new</code> will clue the programmer into the reason why the program mis-behaved.

Hope this helps and make sense,

blocks|key|1166303|text|好吧，如果C%2B%2B确实初始化了指针，那么抱怨"C%2B%2B比C慢“的C语言的人就会有真正的东西可以依靠了;)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1166304|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|$]]

Well, if C++ did initialize pointers, then the C folks complaining "C++ is slower than C" would have something real to hang on to ;)

blocks|key|1381504|text|C%2B%2B来自C语言背景--这里有几个原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381505|C，甚至比C%2B%2B更是汇编语言的替代品。它不会做任何你没有告诉它去做的事情。因此:如果你想让它为空，那就去做吧！|1381506|此外，如果你在像C这样的裸机语言中自动将东西设为空，一致性问题就会出现:如果你对一些东西进行了malloc+--它应该自动归零吗？在堆栈上创建的结构又如何呢？是否应该将所有字节都置零？那么全局变量呢？那么像"(*+0x18+);“这样的语句是不是意味着应该将内存位置0x18清零？|1381507|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|$]]

C++ comes from a C background - and there are a few reasons coming back from this:

C, even more than C++ is an assembly language replacement. It does not do anything you do not tell it to do. Therefor: If you want to NULL it - do it!

Also, if you null things in a bare-metal language like C automatically consistency questions crop up: If you malloc something - should it automatically be zeroed? What about a struct created on the stack? should all bytes be zeroed? What about global variables? what about a statement like "(*0x18);" does that not then mean that memory position 0x18 should be zeroed?

blocks|key|1166629|text|你所说的这些指针是什么？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1166630|为了异常安全，请始终使用auto_ptr、shared_ptr、weak_ptr和它们的其他变体。|offset|length|style|CODE|1166631|好代码的一个特点是不包含对delete的任何调用。|1166632|entityMap^0|0|C|8|L|A|W|8|0|D|6|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@$D|N|E|O|F|G]|$D|P|E|Q|F|G]|$D|R|E|S|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|T|8|@$D|U|E|V|F|G]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|K|$]]

What are these pointers you speak of? 

For exception safety, always use <code>auto_ptr</code>, <code>shared_ptr</code>, <code>weak_ptr</code> and their other variants. 
A hallmark of good code is one that doesn't include a single call to <code>delete</code>.

blocks|key|1381630|text|哦，天哪。真正的答案是，将内存清零很容易，这是一个指针的基本初始化。这也与初始化对象本身无关。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1381631|考虑到大多数编译器在最高级别给出的警告，我无法想象在最高级别编程并将其视为错误。因为在生成的大量代码中，即使只有一个bug也无法避免，所以我不推荐这样做。|1381632|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Oh boy. The real answer is that it is easy to zero out memory, which is basic initialization for say a pointer. Which also has nothing to do with initializing the object itself.

Considering the warnings most compilers give at highest levels I can't imagine programming at the highest level and treating them as errors. Since turning them up has never saved me even one bug in huge amounts of code produced I can't recommend this.

Can someone please explain why pointers aren't initialized to <code>NULL</code>? 
Example:

<pre><code> void test(){
 char *buf;
 if (!buf)
 // whatever
 }
</code></pre>

The program wouldn't step inside the if because <code>buf</code> is not null.

I would like to know why, in what case do we need a variable with trash on, specially pointers addressing the trash on the memory?

Why aren't pointers initialized with NULL by default?

编译器

有人能解释一下为什么指针没有初始化到NULL吗示例：  void test(){     char *buf;     if (!buf)        // whatever  }程序不会单步执行if，因为buf不是null。我想知道为什么，在什么情况下，我们需要一个带垃圾的变量，特别是指向内存中垃圾的指针？

问为什么默认情况下指针不是用NULL初始化的？
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么默认情况下指针不是用NULL初始化的？EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么默认情况下指针不是用NULL初始化的？
EN