我来自Java背景,已经开始使用C++中的对象。但我想到的一件事是,人们经常使用指向对象的指针,而不是对象本身,例如这样的声明:

Object *myObject = new Object;

而不是:

Object myObject;

或者不用函数,让我们说testFunc(),如下所示:

myObject.testFunc();

我们必须写下:

myObject->testFunc();

但我不明白我们为什么要这样做。我认为这与效率和速度有关,因为我们可以直接访问内存地址。我说得对吗?


当前回答

从技术上讲,这是一个内存分配问题,但这里有两个更实际的方面。这与两件事有关:1) 作用域,当您定义一个没有指针的对象时,在代码块中定义该对象后,您将无法再访问该对象,而如果您使用“new”定义指针,则您可以从具有指向该内存的指针的任何位置访问它,直到您对同一指针调用“delete”。2) 如果要向函数传递参数,则需要传递指针或引用以提高效率。当您传递一个对象时,该对象将被复制,如果这是一个使用大量内存的对象,这可能会占用CPU(例如,您复制了一个充满数据的向量)。当您传递一个指针时,您传递的是一个int(取决于实现,但大多数是一个整数)。

除此之外,您还需要了解“new”在堆上分配了需要在某个时候释放的内存。当您不必使用“new”时,我建议您使用“堆栈上”的常规对象定义。

其他回答

Object *myObject = new Object;

这样做将创建对对象(堆上)的引用,必须显式删除该对象以避免内存泄漏。

Object myObject;

这样做将创建一个自动类型的对象(myObject)(在堆栈上),当对象(myObject)超出范围时,该对象将被自动删除。

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

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

指针有很多用例。

多态行为。对于多态类型,指针(或引用)用于避免切片:

class Base { ... };
class Derived : public Base { ... };

void fun(Base b) { ... }
void gun(Base* b) { ... }
void hun(Base& b) { ... }

Derived d;
fun(d);    // oops, all Derived parts silently "sliced" off
gun(&d);   // OK, a Derived object IS-A Base object
hun(d);    // also OK, reference also doesn't slice

引用语义和避免复制。对于非多态类型,指针(或引用)将避免复制可能昂贵的对象

Base b;
fun(b);  // copies b, potentially expensive 
gun(&b); // takes a pointer to b, no copying
hun(b);  // regular syntax, behaves as a pointer

注意,C++11具有移动语义,可以避免将昂贵的对象复制到函数参数中并作为返回值。但是使用一个指针肯定会避免这些问题,并且允许在同一个对象上使用多个指针(而一个对象只能从一次移动)。

资源获取。在现代C++中,使用新运算符创建指向资源的指针是一种反模式。使用特殊的资源类(标准容器之一)或智能指针(std::unique_ptr<>或std::shared_ptr<>)。考虑:

{
    auto b = new Base;
    ...       // oops, if an exception is thrown, destructor not called!
    delete b;
}

vs.

{
    auto b = std::make_unique<Base>();
    ...       // OK, now exception safe
}

原始指针只能用作“视图”,而不能以任何方式涉及所有权,无论是通过直接创建还是通过返回值隐式创建。另请参阅C++常见问题解答中的问答。

更细粒度的生命周期控制每次复制共享指针(例如作为函数参数)时,它指向的资源都保持活动状态。常规对象(不是由new创建的,直接由您创建或在资源类中创建)在超出范围时被销毁。

这已经详细讨论过了,但在Java中,一切都是指针。它不区分堆栈和堆分配(所有对象都在堆上分配),因此您不会意识到您正在使用指针。在C++中,可以根据内存需求将两者混合使用。C++中的性能和内存使用更具确定性(duh)。

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

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