我来自Java背景，已经开始使用C++中的对象。但我想到的一件事是，人们经常使用指向对象的指针，而不是对象本身，例如这样的声明：
Object *myObject = new Object;
而不是：
Object myObject;
或者不用函数，让我们说testFunc（），如下所示：
myObject.testFunc();
我们必须写下：
myObject->testFunc();
但我不明白我们为什么要这样做。我认为这与效率和速度有关，因为我们可以直接访问内存地址。我说得对吗？
当前回答
假设你有一个包含类B的类A。当你想在类A之外调用类B的某个函数时，你只需要获得一个指向这个类的指针，你可以做任何你想做的事情，它也会改变类A中类B的上下文
但要小心动态对象
其他回答
这个问题有很多很好的答案，包括前向声明、多态性等重要用例，但我觉得你的问题的“灵魂”部分没有得到回答，即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#）语义。
对于指针，
可以直接与存储器对话。可以通过操纵指针防止程序的大量内存泄漏。
在内存利用率很高的领域，指针很方便。例如，考虑一个极大极小算法，其中将使用递归例程生成数千个节点，然后使用它们来评估游戏中的下一个最佳移动，解除分配或重置（如智能指针）的能力显著减少了内存消耗。而非指针变量继续占用空间，直到其递归调用返回值。
C++中对象指针的关键优势是允许同一超类的指针的多态数组和映射。例如，它允许将长尾鹦鹉、鸡、知更鸟、鸵鸟等放在鸟的阵列中。
此外，动态分配的对象更灵活，可以使用HEAP内存，而本地分配的对象将使用STACK内存，除非它是静态的。堆栈上有大型对象，尤其是使用递归时，无疑会导致堆栈溢出。
使用指向对象的指针有很多好处-
效率（正如你已经指出的）。将对象传递到函数意味着创建对象的新副本。使用第三方库中的对象。如果您的对象属于第三方代码，作者打算仅通过指针（无复制构造函数等）使用其对象，这是唯一可以绕过此问题的方法对象正在使用指针。传递值可能会导致问题。（深拷贝/浅拷贝问题）。如果对象拥有资源，并且您希望该所有权不应与其他对象共享。
