假设你有一个包含类B的类A。当你想在类A之外调用类B的某个函数时，你只需要获得一个指向这个类的指针，你可以做任何你想做的事情，它也会改变类A中类B的上下文

但要小心动态对象

在内存利用率很高的领域，指针很方便。例如，考虑一个极大极小算法，其中将使用递归例程生成数千个节点，然后使用它们来评估游戏中的下一个最佳移动，解除分配或重置（如智能指针）的能力显著减少了内存消耗。而非指针变量继续占用空间，直到其递归调用返回值。

指针有很多用例。

多态行为。对于多态类型，指针（或引用）用于避免切片：

class Base { ... };
class Derived : public Base { ... };

void fun(Base b) { ... }
void gun(Base* b) { ... }
void hun(Base& b) { ... }

Derived d;
fun(d);    // oops, all Derived parts silently "sliced" off
gun(&d);   // OK, a Derived object IS-A Base object
hun(d);    // also OK, reference also doesn't slice

引用语义和避免复制。对于非多态类型，指针（或引用）将避免复制可能昂贵的对象

Base b;
fun(b);  // copies b, potentially expensive 
gun(&b); // takes a pointer to b, no copying
hun(b);  // regular syntax, behaves as a pointer

注意，C++11具有移动语义，可以避免将昂贵的对象复制到函数参数中并作为返回值。但是使用一个指针肯定会避免这些问题，并且允许在同一个对象上使用多个指针（而一个对象只能从一次移动）。

资源获取。在现代C++中，使用新运算符创建指向资源的指针是一种反模式。使用特殊的资源类（标准容器之一）或智能指针（std:：unique_ptr<>或std:：shared_ptr<>）。考虑：

{
    auto b = new Base;
    ...       // oops, if an exception is thrown, destructor not called!
    delete b;
}

vs.

{
    auto b = std::make_unique<Base>();
    ...       // OK, now exception safe
}

原始指针只能用作“视图”，而不能以任何方式涉及所有权，无论是通过直接创建还是通过返回值隐式创建。另请参阅C++常见问题解答中的问答。

更细粒度的生命周期控制每次复制共享指针（例如作为函数参数）时，它指向的资源都保持活动状态。常规对象（不是由new创建的，直接由您创建或在资源类中创建）在超出范围时被销毁。

C++提供了三种传递对象的方法：通过指针、引用和值。Java限制您使用后一种类型（唯一的例外是int、boolean等原始类型）。如果你想使用C++而不仅仅是一个奇怪的玩具，那么你最好了解这三种方式之间的区别。

Java假装不存在“谁和什么时候应该销毁这个？”这样的问题。答案是：《垃圾收集器》，棒极了。然而，它不能提供100%的内存泄漏保护（是的，java可以泄漏内存）。实际上，GC给你一种错误的安全感。你的SUV越大，离撤离者的距离就越长。

C++让您面对面地了解对象的生命周期管理。好吧，有一些方法可以解决这个问题（智能指针家族、Qt中的QObject等等），但它们都不能像GC那样以“火即忘”的方式使用：您应该始终记住内存处理。你不仅应该关心破坏一个物体，还必须避免多次破坏同一个物体。

还不害怕吗？好的：循环引用——你自己处理，人类。记住：每一个对象都要被精确地杀死一次，我们C++运行时不喜欢那些处理尸体的人，只留下死去的人。

所以，回到你的问题。

当您通过值（而不是指针或引用）传递对象时，每次执行“=”操作时，都会复制对象（整个对象，无论是几个字节还是一个巨大的数据库转储-您足够聪明，可以避免后者，不是吗？）。要访问对象的成员，请使用“”（点）。

当通过指针传递对象时，只复制几个字节（32位系统为4个，64位系统为8个），即该对象的地址。为了向所有人展示这一点，当您访问成员时，可以使用这个花哨的“->”运算符。或者可以使用“*”和“.”的组合。

当你使用引用时，你会得到一个伪装成值的指针。这是一个指针，但您可以通过“.”访问成员。

还有，再一次让你大跌眼镜：当你声明几个用逗号分隔的变量时，然后（注意指针）：

每个人都有类型值/指针/引用修饰符是单独的

例子：

struct MyStruct
{
    int* someIntPointer, someInt; //here comes the surprise
    MyStruct *somePointer;
    MyStruct &someReference;
};

MyStruct s1; //we allocated an object on stack, not in heap

s1.someInt = 1; //someInt is of type 'int', not 'int*' - value/pointer modifier is individual
s1.someIntPointer = &s1.someInt;
*s1.someIntPointer = 2; //now s1.someInt has value '2'
s1.somePointer = &s1;
s1.someReference = s1; //note there is no '&' operator: reference tries to look like value
s1.somePointer->someInt = 3; //now s1.someInt has value '3'
*(s1.somePointer).someInt = 3; //same as above line
*s1.somePointer->someIntPointer = 4; //now s1.someInt has value '4'

s1.someReference.someInt = 5; //now s1.someInt has value '5'
                              //although someReference is not value, it's members are accessed through '.'

MyStruct s2 = s1; //'NO WAY' the compiler will say. Go define your '=' operator and come back.

//OK, assume we have '=' defined in MyStruct

s2.someInt = 0; //s2.someInt == 0, but s1.someInt is still 5 - it's two completely different objects, not the references to the same one

使用指针的另一个好理由是用于前向声明。在一个足够大的项目中，它们确实可以加快编译时间。

tl；dr：不要“使用指针而不是对象本身”（通常）

你问为什么你更喜欢指针而不是对象本身。一般来说，你不应该。

现在，这条规则确实有多个例外，其他答案已经阐明了这些例外。问题是，这些天来，许多这些例外不再有效！让我们考虑一下公认答案中列出的例外情况：

您需要引用语义。

如果需要引用语义，请使用引用，而不是指针；参见@ST3的答案。事实上，有人会认为，在Java中，传递的通常是引用。

你需要多态性。

如果您知道要使用的一组类，通常可以使用std:：variant＜ClassA，ClassB，ClassC＞（请参阅此处的描述），并使用访问者模式对它们进行操作。当然，C++的变体实现并不是最漂亮的；但我通常更喜欢它，而不是用指针弄脏。

您希望表示对象是可选的

绝对不要为此使用指针。您有std:：可选的，与std:：变体不同，它非常方便。请改用它。nullopt是空（或“null”）可选项。而且-这不是指针。

您希望分离编译单元以提高编译时间。

您也可以使用引用而不是指针来实现这一点。要在一段代码中使用Object&，只要说class Object；，即使用转发声明。

您需要与C库或C样式库交互。

是的，好吧，如果你使用已经使用指针的代码，那么-你必须自己使用指针，不能绕过这一点：-（而且C没有引用。

此外，有些人可能会告诉您使用指针来避免复制对象。由于返回值和命名的返回值优化（RVO和NRVO），这对于返回值来说并不是一个真正的问题。在其他情况下，参考文献可以很好地避免复制。

底线规则仍然与公认的答案相同：只有在有充分理由需要指针时才使用指针。

PS-如果你确实需要一个指针，你仍然应该避免直接使用new和delete。智能指针可能会更好地为您服务，它会自动释放（不像Java那样，但仍然如此）。