前言

Java与C++完全不同，这与大肆宣传相反。Java炒作机器希望您相信，因为Java具有类似C++的语法，所以语言是相似的。没有什么比事实更离谱了。这种错误信息是Java程序员在不理解代码含义的情况下使用C++并使用类似Java的语法的部分原因。

我们继续前进

但我不明白我们为什么要这样做。我想是吧与效率和速度有关，因为我们可以直接访问存储器地址。我说得对吗？

事实上恰恰相反。堆比堆栈慢得多，因为与堆相比，堆栈非常简单。自动存储变量（也称为堆栈变量）一旦超出作用域，就会调用其析构函数。例如：

{
    std::string s;
}
// s is destroyed here

另一方面，如果使用动态分配的指针，则必须手动调用其析构函数。delete为您调用这个析构函数。

{
    std::string* s = new std::string;
    delete s; // destructor called
}

这与C#和Java中流行的新语法无关。它们用于完全不同的目的。

动态分配的好处

1.您不必事先知道阵列的大小

许多C++程序员首先遇到的问题之一是，当他们接受用户的任意输入时，只能为堆栈变量分配固定大小。也不能更改数组的大小。例如：

char buffer[100];
std::cin >> buffer;
// bad input = buffer overflow

当然，如果改用std:：string，std:：字符串会在内部调整自身大小，这样就不会有问题。但本质上解决这个问题的方法是动态分配。您可以根据用户的输入分配动态内存，例如：

int * pointer;
std::cout << "How many items do you need?";
std::cin >> n;
pointer = new int[n];

附带说明：许多初学者犯的一个错误是可变长度数组。这是GNU扩展，也是Clang中的一个扩展因为它们反映了GCC的许多扩展。因此，以下内容不应依赖int arr[n]。

因为堆比堆栈大得多，所以可以任意分配/重新分配所需的内存，而堆栈有限制。

2.数组不是指针

你问这是什么好处？一旦您了解了数组和指针背后的困惑/迷思，答案就会变得清晰。人们通常认为它们是相同的，但事实并非如此。这个神话来自这样一个事实，即指针可以像数组一样下标，因为数组在函数声明中会衰减到顶层的指针。然而，一旦数组衰减为指针，指针就会丢失其大小信息。因此sizeof（指针）将以字节为单位给出指针的大小，在64位系统中通常为8字节。

不能分配给数组，只能初始化它们。例如：

int arr[5] = {1, 2, 3, 4, 5}; // initialization 
int arr[] = {1, 2, 3, 4, 5}; // The standard dictates that the size of the array
                             // be given by the amount of members in the initializer  
arr = { 1, 2, 3, 4, 5 }; // ERROR

另一方面，你可以用指针做任何你想做的事情。不幸的是，因为指针和数组之间的区别在Java和C#中是手动的，所以初学者不理解它们之间的区别。

3.多态性

Java和C#具有允许您将对象视为另一个对象的功能，例如使用as关键字。因此，如果有人想将实体对象视为Player对象，可以执行Playerplayer=EntityasPlayer；如果您打算在仅应应用于特定类型的同构容器上调用函数，这非常有用。功能可通过以下类似方式实现：

std::vector<Base*> vector;
vector.push_back(&square);
vector.push_back(&triangle);
for (auto& e : vector)
{
     auto test = dynamic_cast<Triangle*>(e); // I only care about triangles
     if (!test) // not a triangle
        e.GenericFunction();
     else
        e.TriangleOnlyMagic();
}

所以，假设只有Triangles有一个Rotate函数，那么如果您试图在类的所有对象上调用它，那么这将是一个编译器错误。使用dynamic_cast，可以模拟as关键字。要明确的是，如果强制转换失败，它将返回一个无效的指针。所以test本质上是检查测试是否为NULL或无效指针的简写，这意味着强制转换失败。

自动变量的优点

在看到了动态分配可以做的所有伟大的事情之后，您可能会想为什么没有人不一直使用动态分配？我已经告诉过你一个原因，堆很慢。如果你不需要所有的记忆，你就不应该滥用它。所以这里有一些不按特定顺序排列的缺点：

它容易出错。手动分配内存是危险的，并且容易发生泄漏。如果你不熟练使用调试器或valgrind（一种内存泄漏工具），你可能会抓狂。幸运的是，RAII习语和智能指针稍微缓解了这一点，但您必须熟悉诸如“三法则”和“五法则”之类的实践。这是一个需要学习的大量信息，初学者如果不知道或者不在乎，就会陷入这个陷阱。这是没有必要的。与Java和C#不同，在C++中，到处使用新关键字是一种习惯，只有在需要的时候才应该使用它。当初学者开始使用C++时，他们害怕指针，并习惯性地学习使用堆栈变量，而Java和C#程序员开始使用指针时却不懂它！这实际上是踩错了脚。你必须放弃你所知道的一切，因为语法是一回事，学习语言是另一回事。

1.（N）RVO-Aka，（命名）返回值优化

许多编译器进行的一种优化是省略和返回值优化。这些东西可以避免不必要的复制，这对于非常大的对象（例如包含许多元素的向量）非常有用。通常，通常的做法是使用指针来转移所有权，而不是复制大型对象来移动它们。这导致了移动语义和智能指针的出现。

如果使用指针，则不会发生（N）RVO。如果您担心优化，那么利用（N）RVO而不是返回或传递指针会更有益，也更不容易出错。如果函数的调用方负责删除动态分配的对象等，则可能发生错误泄漏。如果指针像烫手山芋一样四处传递，则很难跟踪对象的所有权。只需使用堆栈变量，因为它更简单、更好。

在C++中，堆栈上分配的对象（使用Object对象；块内的语句）将只存在于声明的范围内。当代码块完成执行时，声明的对象将被销毁。而如果使用Object*obj=new Object（）在堆上分配内存，则它们将继续驻留在堆中，直到调用delete obj。

如果我想在堆上创建一个对象，而不仅仅是在声明/分配该对象的代码块中使用该对象。

C++中对象指针的关键优势是允许同一超类的指针的多态数组和映射。例如，它允许将长尾鹦鹉、鸡、知更鸟、鸵鸟等放在鸟的阵列中。

此外，动态分配的对象更灵活，可以使用HEAP内存，而本地分配的对象将使用STACK内存，除非它是静态的。堆栈上有大型对象，尤其是使用递归时，无疑会导致堆栈溢出。

非常不幸的是，您经常看到动态分配。这正好说明有多少糟糕的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成员函数，可以从智能指针获取原始指针。如果库为您执行了一些分配，它希望您通过句柄解除分配，则通常可以使用自定义删除器将句柄包装在智能指针中，以适当地解除分配对象。

这个问题有很多很好的答案，包括前向声明、多态性等重要用例，但我觉得你的问题的“灵魂”部分没有得到回答，即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#）语义。

已经有很多很好的答案，但让我举一个例子：

我有一个简单的Item类：

 class Item
    {
    public: 
      std::string name;
      int weight;
      int price;
    };

我做了一个向量来容纳它们。

std:：vector<Item>库存；

我创建了一百万个Item对象，并将它们推回到向量上。我按名称对向量进行排序，然后对特定项目名称进行简单的迭代二进制搜索。我测试了程序，完成执行需要8分钟。然后我改变我的库存向量如下：

std:：vector<Item*>库存；

…并通过新建创建我的百万Item对象。我对代码所做的唯一更改是使用指向Items的指针，除了最后为清理内存而添加的循环。该程序运行时间不到40秒，或者比速度提高10倍还要快。编辑：代码位于http://pastebin.com/DK24SPeW通过编译器优化，在我刚刚测试过的机器上，它只增加了3.4倍，这仍然很可观。