这个问题有很多很好的答案，包括前向声明、多态性等重要用例，但我觉得你的问题的“灵魂”部分没有得到回答，即Java和C++中不同的语法意味着什么。

让我们来比较一下这两种语言的情况：

Java语言：

Object object1 = new Object(); //A new object is allocated by Java
Object object2 = new Object(); //Another new object is allocated by Java

object1 = object2; 
//object1 now points to the object originally allocated for object2
//The object originally allocated for object1 is now "dead" - nothing points to it, so it
//will be reclaimed by the Garbage Collector.
//If either object1 or object2 is changed, the change will be reflected to the other

与此最接近的等效值为：

C++:

Object * object1 = new Object(); //A new object is allocated on the heap
Object * object2 = new Object(); //Another new object is allocated on the heap
delete object1;
//Since C++ does not have a garbage collector, if we don't do that, the next line would 
//cause a "memory leak", i.e. a piece of claimed memory that the app cannot use 
//and that we have no way to reclaim...

object1 = object2; //Same as Java, object1 points to object2.

让我们看看另一种C++方式：

Object object1; //A new object is allocated on the STACK
Object object2; //Another new object is allocated on the STACK
object1 = object2;//!!!! This is different! The CONTENTS of object2 are COPIED onto object1,
//using the "copy assignment operator", the definition of operator =.
//But, the two objects are still different. Change one, the other remains unchanged.
//Also, the objects get automatically destroyed once the function returns...

最好的方法是——或多或少——Java（隐式）处理指向对象的指针，而C++可以处理指向对象或对象本身的指针。这是有例外的——例如，如果您声明Java“原始”类型，它们是复制的实际值，而不是指针。所以

Java语言：

int object1; //An integer is allocated on the stack.
int object2; //Another integer is allocated on the stack.
object1 = object2; //The value of object2 is copied to object1.

也就是说，使用指针不一定是正确或错误的处理方式；然而，其他答案已经令人满意地涵盖了这一点。不过，总的想法是，在C++中，您可以对对象的生存期以及它们将生存的位置进行更多的控制。

重点是——Object*Object=newObject（）构造实际上最接近典型的Java（或C#）语义。

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

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

Class Base1 {
};

Class Derived1 : public Base1 {
};


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

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

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

非常不幸的是，您经常看到动态分配。这正好说明有多少糟糕的C++程序员。

从某种意义上说，你有两个问题合并在一起。第一个问题是什么时候应该使用动态分配（使用新的）？第二个问题是我们什么时候应该使用指针？

重要的信息是，你应该始终使用合适的工具来完成工作。在几乎所有情况下，都有比执行手动动态分配和/或使用原始指针更合适和更安全的方法。

动态分配

在您的问题中，您演示了创建对象的两种方法。主要区别是对象的存储持续时间。执行Object myObject时；在一个块中，创建的对象具有自动存储持续时间，这意味着当它超出范围时将自动销毁。当您执行new Object（）时，对象具有动态存储持续时间，这意味着它将保持活动状态，直到您显式删除它。您只应在需要时使用动态存储持续。也就是说，在可能的情况下，您应该始终倾向于创建具有自动存储持续时间的对象。

您可能需要动态分配的主要两种情况：

您需要该对象比当前作用域（即位于特定内存位置的特定对象，而不是其副本）更长寿。如果您可以复制/移动该对象（大多数情况下您应该这样做），则应该选择自动对象。您需要分配大量内存，这可能很容易填满堆栈。如果我们不必担心这一点（大多数时候你不必担心），那将是很好的，因为这确实超出了C++的权限，但不幸的是，我们必须处理我们正在开发的系统的现实。

当您确实需要动态分配时，应该将其封装在智能指针或执行RAII的其他类型（如标准容器）中。智能指针提供动态分配对象的所有权语义。例如，看看std:：unique_ptr和std:：shared_ptr。如果使用得当，几乎可以完全避免执行自己的内存管理（请参阅零规则）。

指针

然而，除了动态分配之外，原始指针还有其他更一般的用途，但大多数都有您应该更喜欢的替代方法。如前所述，除非你真的需要指针，否则总是倾向于选择其他选项。

您需要引用语义。有时，您希望使用指针传递对象（无论它是如何分配的），因为您希望传递对象的函数能够访问该特定对象（而不是其副本）。然而，在大多数情况下，您应该更喜欢引用类型而不是指针，因为这正是它们的设计目的。注意，这不一定是关于将对象的寿命延长到当前范围之外，如上面的情况1所示。如前所述，如果可以传递对象的副本，则不需要引用语义。你需要多态性。您只能通过指向对象的指针或引用以多态方式（即，根据对象的动态类型）调用函数。如果这是您需要的行为，那么您需要使用指针或引用。同样，应首选参考文献。您希望通过在省略对象时允许传递nullptr来表示对象是可选的。如果它是一个参数，您应该更喜欢使用默认参数或函数重载。否则，您最好使用封装此行为的类型，例如std:：optional（在C++17中引入-对于早期的C++标准，使用boost:：option）。您希望分离编译单元以提高编译时间。指针的有用特性是只需要指向类型的前向声明（要实际使用对象，需要定义）。这允许您分离部分编译过程，这可能会显著缩短编译时间。参见Pimpl成语。您需要与C库或C样式库交互。此时，您必须使用原始指针。你能做的最好的事情就是确保你只在最后一刻放松你的原始指针。例如，通过使用智能指针的get成员函数，可以从智能指针获取原始指针。如果库为您执行了一些分配，它希望您通过句柄解除分配，则通常可以使用自定义删除器将句柄包装在智能指针中，以适当地解除分配对象。

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

“需要是发明之母。”我想指出的最重要的区别是我自己编码经验的结果。有时需要将对象传递给函数。在这种情况下，如果您的对象是一个非常大的类，那么将其作为对象传递将复制其状态（您可能不希望..AND可以是big OVERHEAD），从而导致复制对象的开销。而指针是固定的4字节大小（假设为32位）。上面已经提到了其他原因。。。