blocks|key|1281187|text|如果可以，可以在堆栈上分配它，如果有必要，可以从空闲存储中分配它。这里有一个similar+question，你可以在这里找到所有的“为什么”。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1281188|当涉及到游戏和其他东西时，你会看到大量指针使用的原因是因为DirectX是一个COM接口，老实说，当时的大多数游戏程序员并不是真正的C%2B%2B程序员，他们是使用C%2B%2B类的程序员，在C中，指针的使用是非常普遍的。|1281189|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1064325/why-not-use-pointers-for-everything-in-c^0|12|G|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

Allocate it on the stack if you can, from the free-store if you have to. There is a <a href="https://stackoverflow.com/questions/1064325/why-not-use-pointers-for-everything-in-c">similar question</a> here, where you will find all the "why's".

The reason you see lots of pointer usage when it comes to games and stuff is because DirectX is a COM interface, and in honesty, most games programmers from back in the day aren't really C++ programmers, they are C-with-classes programmers, and in C pointer usage is very common.

blocks|key|1281267|text|指针具有以下优点：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281268|a)你可以做一个延迟初始化，这意味着只在第一次实际使用之前初始化/创建对象。|1281269|b)设计:如果你对一个外部类类型的成员使用指针，你可以在你的类上面放置一个正向声明，因此不需要在你的头中包括该类型的头-而不是在你的.cpp中包括第三方头-这样做的好处是减少编译时间，并防止由于包括太多其他头而产生的副作用。|1281270|class+ExtCamera;++//+forward+declaration+to+external+class+type+in+"ExtCamera.h"

class+MyCamera+{
public:+
++MyCamera()+:+m_pCamera(0)+{+}

++void+init(const+ExtCamera+&cam);

private:
+++ExtCamera++*m_pCamera;+++//+do+not+use+it+in+inline+code+inside+header!
};|code-block|syntax|javascript|1281271|c)指针可以随时删除-这样你就可以对livetime有更多的控制，并且可以重新创建对象-例如在失败的情况下。|1281272|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A pointer has following advantages:

a) You can do a lazy initialization, that means to init / create the object only short before the first real usage.

b) The design: if you use pointers for members of an external class type, you can place a forward declaration above your class and thus don't need to include the headers of that types in your header - instead of that you include the third party headers in your .cpp - that has the advantage to reduce the compile time and prevents side effects by including too many other headers.

<pre><code>class ExtCamera; // forward declaration to external class type in "ExtCamera.h"

class MyCamera {
public: 
 MyCamera() : m_pCamera(0) { }

 void init(const ExtCamera &amp;cam);

private:
 ExtCamera *m_pCamera; // do not use it in inline code inside header!
};
</code></pre>

c) A pointer can be deleted anytime - so you have more control about the livetime and can re-create an object - for example in case of a failure.

blocks|key|1281398|text|3DH概述了使用指针的优点:延迟初始化、减少标头依赖以及控制对象的生命周期。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1281399|这也是缺点。当您有一个指针数据成员时，您可能必须编写自己的复制构造函数和赋值运算符，以确保正确创建对象的副本。当然，您还必须记住删除析构函数中的对象。此外，如果将指针数据成员添加到现有类中，则必须记得更新复制构造函数和operator=。简而言之，拥有一个指针数据成员对您来说是更多的工作。|1281400|另一个缺点是在指针指向的对象的生命周期上的控制的另一面。当对象被销毁时，非指针数据成员将自动销毁，这意味着只要对象存在，您就可以始终确保它们存在。使用指针，你必须检查它是否为nullptr，这也意味着当它没有指向任何东西时，你必须确保将它设置为nullptr。必须处理所有这些可能很容易导致错误。|offset|length|style|CODE|1281401|最后，访问非指针成员可能会更快，因为它们在内存中是连续的。另一方面，访问指向堆上分配的对象的指针数据成员可能会导致缓存未命中，从而使其变得较慢。|1281402|你的问题没有唯一的答案。您必须查看您的设计，并决定指针数据成员的优势是否大于额外的麻烦。如果减少编译时间和标头依赖关系很重要，请使用pimpl+idiom。如果您的对象在某些情况下不需要您的数据成员，请使用指针，并在需要时分配它。如果这些听起来不像是令人信服的理由，并且您不想做额外的工作，那么就不要使用指针。|1281403|如果延迟初始化和减少头依赖关系很重要，那么您应该首先考虑使用智能指针，如std::unique_ptr或std::shared_ptr，而不是原始指针。智能指针使您免于使用上面描述的原始指针带来的许多麻烦。|1281404|当然，仍然有一些警告。std::unique_ptr会在自身之后进行清理，因此您不需要添加或修改类的析构函数。但是，它是不可复制的，因此拥有一个唯一的指针作为数据成员会使你的类也不可复制。|1281405|使用std::shared_ptr，您不必担心析构函数、复制或赋值。但是，共享指针会导致引用计数的性能损失。|1281406|entityMap|0|LINK|mutability|MUTABLE|url|http://c2.com/cgi/wiki?PimplIdiom^0|0|0|2F|7|3E|7|0|0|1U|B|0|0|10|F|1G|F|0|B|F|0|2|F|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|13|8|@$F|14|G|15|H|I]|$F|16|G|17|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|18|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|19|8|@]|9|@$F|1A|G|1B|1|1C]]|A|$]]|$1|N|3|O|5|6|7|1D|8|@$F|1E|G|1F|H|I]|$F|1G|G|1H|H|I]]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1I|8|@$F|1J|G|1K|H|I]]|9|@]|A|$]]|$1|R|3|S|5|6|7|1L|8|@$F|1M|G|1N|H|I]]|9|@]|A|$]]|$1|T|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

The advantages of using a pointer are outlined by 3DH: lazy initialization, reduction in header dependencies, and control over the lifetime of the object.
The are also disadvantages. When you have a pointer data member, you probably have to write your own copy constructor and assignment operator, to make sure that a copy of the object is created properly. Of course, you also must remember to delete the object in the destructor. Also, if you add a pointer data member to an existing class, you must remember to update the copy constructor and operator=. In short, having a pointer data member is more work for you.
Another disadvantage is really the flip side of the control over the lifetime of the object pointed to by the pointer. Non-pointer data members are destroyed automagically when the object is destroyed, meaning that you can always be sure that they exist as long as the object exists. With the pointer, you have to check for it being <code>nullptr</code>, meaning also that you have to make sure to set it to <code>nullptr</code> whenever it doesn't point to anything. Having to deal with all this may easily lead to bugs.
Finally, accessing non-pointer members is likely to be faster, because they are contiguous in memory. On the other hand, accessing pointer data member pointing to an object allocated on the heap is likely to cause a cache miss, making it slower.
There is no single answer to your question. You have to look at your design, and decide whether the advantages of pointer data members outweigh the additional headache. If reducing compile time and header dependencies is important, use the <a href="http://c2.com/cgi/wiki?PimplIdiom" rel="nofollow noreferrer">pimpl idiom</a>. If your data member may not be necessary for your object in certain cases, use a pointer, and allocate it when needed. If these do not sound like compelling reasons, and you do not want to do extra work, then do not use a pointer.
If lazy initialization and the reduction of header dependencies are important, then you should first consider using a smart pointer, like <code>std::unique_ptr</code> or <code>std::shared_ptr</code>, instead of a raw pointer. Smart pointers save you from many of the headaches of using raw pointers described above.
Of course, there are still caveats. <code>std::unique_ptr</code> cleans up after itself, so you do not need to add or modify the destructor of your class. However, it is non-copiable, so having a unique pointer as a data member makes your class non-copiable as well.
With <code>std::shared_ptr</code>, you do not have to worry about the destructor or copying or assignment. However, the shared pointer incurs a performance penalty for reference counting.

blocks|key|1496239|text|使用指针的另一个原因是动态绑定。如果您有一个具有虚方法的基类和一些派生类，则只能使用指针获取动态绑定。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1496240|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|$]]

Another reason to use pointers would be dynamic binding. If you have a base class with a virtual method and some derived classes, you can only get dynamic binding using pointers.

One of the thing that has been confusing for me while learning C++ (and Direct3D, but that some time ago) is when you should use a pointer member in a class. For example, I can use a non-pointer declaration:

<pre><code>private:
 SomeClass instance_;
</code></pre>

Or I could use a pointer declaration

<pre><code>private:
 Someclass * instance_
</code></pre>

And then use new() on it in the constructor. 

I understand that if SomeClass could be derived from another class, a COM object or is an ABC then it should be a pointer. Are there any other guidelines that I should be aware of?

C++ - when should I use a pointer member in a class

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在学习C++ (和Direct3D，但那是在一段时间以前)的时候，有一件事让我感到困惑，那就是什么时候应该在类中使用指针成员。例如，我可以使用非指针声明：private:    SomeClass instance_;或者我可以使用指针声明private:   Someclass * instance_然后在构造函数中...

问C++ -什么时候应该在类中使用指针成员
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++ -什么时候应该在类中使用指针成员EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C++ -什么时候应该在类中使用指针成员
EN