使用指向对象的指针有很多好处-

效率（正如你已经指出的）。将对象传递到函数意味着创建对象的新副本。使用第三方库中的对象。如果您的对象属于第三方代码，作者打算仅通过指针（无复制构造函数等）使用其对象，这是唯一可以绕过此问题的方法对象正在使用指针。传递值可能会导致问题。（深拷贝/浅拷贝问题）。如果对象拥有资源，并且您希望该所有权不应与其他对象共享。

主要问题是为什么我应该使用指针而不是对象本身？我的回答是，你应该（几乎）永远不要使用指针而不是对象，因为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++中对象指针的关键优势是允许同一超类的指针的多态数组和映射。例如，它允许将长尾鹦鹉、鸡、知更鸟、鸵鸟等放在鸟的阵列中。

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

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

但要小心动态对象

使用指向对象的指针有很多好处-

效率（正如你已经指出的）。将对象传递到函数意味着创建对象的新副本。使用第三方库中的对象。如果您的对象属于第三方代码，作者打算仅通过指针（无复制构造函数等）使用其对象，这是唯一可以绕过此问题的方法对象正在使用指针。传递值可能会导致问题。（深拷贝/浅拷贝问题）。如果对象拥有资源，并且您希望该所有权不应与其他对象共享。

前言

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而不是返回或传递指针会更有益，也更不容易出错。如果函数的调用方负责删除动态分配的对象等，则可能发生错误泄漏。如果指针像烫手山芋一样四处传递，则很难跟踪对象的所有权。只需使用堆栈变量，因为它更简单、更好。