使用指针的一个原因是与C函数接口。另一个原因是节省内存；例如：不要将包含大量数据且具有处理器密集型复制构造函数的对象传递给函数，只需将指针传递给该对象即可节省内存和速度，尤其是在循环中，但在这种情况下引用会更好，除非您使用的是C样式数组。

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

使用指针的一个原因是与C函数接口。另一个原因是节省内存；例如：不要将包含大量数据且具有处理器密集型复制构造函数的对象传递给函数，只需将指针传递给该对象即可节省内存和速度，尤其是在循环中，但在这种情况下引用会更好，除非您使用的是C样式数组。

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

但要小心动态对象

我将包括指针的一个重要用例。当您在基类中存储一些对象时，但它可能是多态的。

Class Base1 {
};

Class Derived1 : public Base1 {
};


Class Base2 {
  Base *bObj;
  virtual void createMemerObects() = 0;
};

Class Derived2 {
  virtual void createMemerObects() {
    bObj = new Derived1();
  }
};

因此，在这种情况下，不能将bObj声明为直接对象，必须有指针。

对于指针，

可以直接与存储器对话。可以通过操纵指针防止程序的大量内存泄漏。