我来自Java背景，已经开始使用C++中的对象。但我想到的一件事是，人们经常使用指向对象的指针，而不是对象本身，例如这样的声明：
Object *myObject = new Object;
而不是：
Object myObject;
或者不用函数，让我们说testFunc（），如下所示：
myObject.testFunc();
我们必须写下：
myObject->testFunc();
但我不明白我们为什么要这样做。我认为这与效率和速度有关，因为我们可以直接访问内存地址。我说得对吗？
当前回答
已经有很多很好的答案，但让我举一个例子：
我有一个简单的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倍，这仍然很可观。
其他回答
“需要是发明之母。”我想指出的最重要的区别是我自己编码经验的结果。有时需要将对象传递给函数。在这种情况下，如果您的对象是一个非常大的类，那么将其作为对象传递将复制其状态（您可能不希望..AND可以是big OVERHEAD），从而导致复制对象的开销。而指针是固定的4字节大小（假设为32位）。上面已经提到了其他原因。。。
对于指针，
可以直接与存储器对话。可以通过操纵指针防止程序的大量内存泄漏。
指针直接引用对象的内存位置。Java没有这样的东西。Java具有通过哈希表引用对象位置的引用。使用这些引用，您无法在Java中执行类似指针算术的操作。
回答你的问题，这只是你的喜好。我更喜欢使用类似Java的语法。
Object *myObject = new Object;
这样做将创建对对象（堆上）的引用，必须显式删除该对象以避免内存泄漏。
Object myObject;
这样做将创建一个自动类型的对象（myObject）（在堆栈上），当对象（myObject）超出范围时，该对象将被自动删除。
这个问题有很多很好的答案，包括前向声明、多态性等重要用例，但我觉得你的问题的“灵魂”部分没有得到回答，即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#）语义。
