Object *myObject = new Object;

这样做将创建对对象（堆上）的引用，必须显式删除该对象以避免内存泄漏。

Object myObject;

这样做将创建一个自动类型的对象（myObject）（在堆栈上），当对象（myObject）超出范围时，该对象将被自动删除。

Object *myObject = new Object;

这样做将创建对对象（堆上）的引用，必须显式删除该对象以避免内存泄漏。

Object myObject;

这样做将创建一个自动类型的对象（myObject）（在堆栈上），当对象（myObject）超出范围时，该对象将被自动删除。

主要问题是为什么我应该使用指针而不是对象本身？我的回答是，你应该（几乎）永远不要使用指针而不是对象，因为C++有引用，它比指针更安全，并且保证了与指针相同的性能。

你在问题中提到的另一件事：

Object *myObject = new Object;

它是如何工作的？它创建Object类型的指针，分配内存以适应一个对象，并调用默认构造函数，听起来不错，对吧？但实际上，如果你动态分配内存（使用关键字new），你还必须手动释放内存，这意味着在代码中你应该：

delete myObject;

这调用析构函数并释放内存，看起来很简单，但在大型项目中，可能很难检测一个线程是否释放了内存，但为此，您可以尝试共享指针，这会稍微降低性能，但使用它们要容易得多。

现在一些介绍已经结束，回到问题上来。

在函数之间传输数据时，可以使用指针而不是对象来获得更好的性能。

看看，你有std：：string（它也是对象），它包含了很多数据，例如大XML，现在你需要解析它，但为此你有一个函数void foo（…），它可以用不同的方式声明：

void foo（std:：string xml）；在这种情况下，您将把变量中的所有数据复制到函数堆栈中，这需要一些时间，因此性能会很低。void foo（std:：string*xml）；在这种情况下，您将以与传递size_t变量相同的速度将指针传递给对象，但这种声明容易出错，因为您可以传递NULL指针或无效指针。指针通常在C中使用，因为它没有引用。void foo（std:：string&xml）；这里传递引用，基本上和传递指针一样，但编译器做了一些事情，不能传递无效引用（实际上，可能会使用无效引用创建情况，但这会使编译器感到棘手）。void foo（const std:：string*xml）；这里与第二个相同，只是指针值不能更改。void foo（const std:：string&xml）；这里与第三个相同，但对象值不能更改。

我还想提的是，无论您选择了哪种分配方式（新的还是常规的），您都可以使用这5种方式传递数据。

另一件事要提的是，当您以常规方式创建对象时，您会在堆栈中分配内存，但当您使用新对象创建对象时会分配堆。分配堆栈要快得多，但对于真正大的数据数组来说，它有点小，所以如果你需要大对象，你应该使用堆，因为你可能会遇到堆栈溢出，但通常这个问题是使用STL容器解决的，记住std:：string也是容器，有些人忘记了：）

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

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

从技术上讲，这是一个内存分配问题，但这里有两个更实际的方面。这与两件事有关：1） 作用域，当您定义一个没有指针的对象时，在代码块中定义该对象后，您将无法再访问该对象，而如果您使用“new”定义指针，则您可以从具有指向该内存的指针的任何位置访问它，直到您对同一指针调用“delete”。2） 如果要向函数传递参数，则需要传递指针或引用以提高效率。当您传递一个对象时，该对象将被复制，如果这是一个使用大量内存的对象，这可能会占用CPU（例如，您复制了一个充满数据的向量）。当您传递一个指针时，您传递的是一个int（取决于实现，但大多数是一个整数）。

除此之外，您还需要了解“new”在堆上分配了需要在某个时候释放的内存。当您不必使用“new”时，我建议您使用“堆栈上”的常规对象定义。