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

Object *myObject = new Object;

而不是:

Object myObject;

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

myObject.testFunc();

我们必须写下:

myObject->testFunc();

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


当前回答

指针有很多用例。

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

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创建的,直接由您创建或在资源类中创建)在超出范围时被销毁。

其他回答

C++提供了三种传递对象的方法:通过指针、引用和值。Java限制您使用后一种类型(唯一的例外是int、boolean等原始类型)。如果你想使用C++而不仅仅是一个奇怪的玩具,那么你最好了解这三种方式之间的区别。

Java假装不存在“谁和什么时候应该销毁这个?”这样的问题。答案是:《垃圾收集器》,棒极了。然而,它不能提供100%的内存泄漏保护(是的,java可以泄漏内存)。实际上,GC给你一种错误的安全感。你的SUV越大,离撤离者的距离就越长。

C++让您面对面地了解对象的生命周期管理。好吧,有一些方法可以解决这个问题(智能指针家族、Qt中的QObject等等),但它们都不能像GC那样以“火即忘”的方式使用:您应该始终记住内存处理。你不仅应该关心破坏一个物体,还必须避免多次破坏同一个物体。

还不害怕吗?好的:循环引用——你自己处理,人类。记住:每一个对象都要被精确地杀死一次,我们C++运行时不喜欢那些处理尸体的人,只留下死去的人。

所以,回到你的问题。

当您通过值(而不是指针或引用)传递对象时,每次执行“=”操作时,都会复制对象(整个对象,无论是几个字节还是一个巨大的数据库转储-您足够聪明,可以避免后者,不是吗?)。要访问对象的成员,请使用“”(点)。

当通过指针传递对象时,只复制几个字节(32位系统为4个,64位系统为8个),即该对象的地址。为了向所有人展示这一点,当您访问成员时,可以使用这个花哨的“->”运算符。或者可以使用“*”和“.”的组合。

当你使用引用时,你会得到一个伪装成值的指针。这是一个指针,但您可以通过“.”访问成员。

还有,再一次让你大跌眼镜:当你声明几个用逗号分隔的变量时,然后(注意指针):

每个人都有类型值/指针/引用修饰符是单独的

例子:

struct MyStruct
{
    int* someIntPointer, someInt; //here comes the surprise
    MyStruct *somePointer;
    MyStruct &someReference;
};

MyStruct s1; //we allocated an object on stack, not in heap

s1.someInt = 1; //someInt is of type 'int', not 'int*' - value/pointer modifier is individual
s1.someIntPointer = &s1.someInt;
*s1.someIntPointer = 2; //now s1.someInt has value '2'
s1.somePointer = &s1;
s1.someReference = s1; //note there is no '&' operator: reference tries to look like value
s1.somePointer->someInt = 3; //now s1.someInt has value '3'
*(s1.somePointer).someInt = 3; //same as above line
*s1.somePointer->someIntPointer = 4; //now s1.someInt has value '4'

s1.someReference.someInt = 5; //now s1.someInt has value '5'
                              //although someReference is not value, it's members are accessed through '.'

MyStruct s2 = s1; //'NO WAY' the compiler will say. Go define your '=' operator and come back.

//OK, assume we have '=' defined in MyStruct

s2.someInt = 0; //s2.someInt == 0, but s1.someInt is still 5 - it's two completely different objects, not the references to the same one

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

tl;dr:不要“使用指针而不是对象本身”(通常)

你问为什么你更喜欢指针而不是对象本身。一般来说,你不应该。

现在,这条规则确实有多个例外,其他答案已经阐明了这些例外。问题是,这些天来,许多这些例外不再有效!让我们考虑一下公认答案中列出的例外情况:

您需要引用语义。

如果需要引用语义,请使用引用,而不是指针;参见@ST3的答案。事实上,有人会认为,在Java中,传递的通常是引用。

你需要多态性。

如果您知道要使用的一组类,通常可以使用std::variant<ClassA,ClassB,ClassC>(请参阅此处的描述),并使用访问者模式对它们进行操作。当然,C++的变体实现并不是最漂亮的;但我通常更喜欢它,而不是用指针弄脏。

您希望表示对象是可选的

绝对不要为此使用指针。您有std::可选的,与std::变体不同,它非常方便。请改用它。nullopt是空(或“null”)可选项。而且-这不是指针。

您希望分离编译单元以提高编译时间。

您也可以使用引用而不是指针来实现这一点。要在一段代码中使用Object&,只要说class Object;,即使用转发声明。

您需要与C库或C样式库交互。

是的,好吧,如果你使用已经使用指针的代码,那么-你必须自己使用指针,不能绕过这一点:-(而且C没有引用。


此外,有些人可能会告诉您使用指针来避免复制对象。由于返回值和命名的返回值优化(RVO和NRVO),这对于返回值来说并不是一个真正的问题。在其他情况下,参考文献可以很好地避免复制。

底线规则仍然与公认的答案相同:只有在有充分理由需要指针时才使用指针。


PS-如果你确实需要一个指针,你仍然应该避免直接使用new和delete。智能指针可能会更好地为您服务,它会自动释放(不像Java那样,但仍然如此)。

前言

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

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