【C++系列】指针对象和对象指针的区别

ListNode dummy(0);ListNode* cur = &dummy; 中,& 是取地址运算符,用来获取变量 dummy 的地址。具体如下:

  • ListNode dummy(0);:创建了一个类型为 ListNode 的对象 dummy,其值初始化为 0
  • &dummy:取 dummy 对象的地址。& 运算符用于获取变量的内存地址。
  • ListNode* cur = &dummy;:声明了一个指向 ListNode 类型的指针 cur,并将其初始化为指向 dummy 的地址。

ListNode* dummy = new ListNode(0); ListNode* cur = dummy; 中,dummy 是链表指针。具体如下:

  • ListNode* dummy = new ListNode(0);:创建了一个类型为 ListNode* 的链表指针dummy,其值初始化为 ListNode(0)
  • new ListNode(0):实例化一个ListNode(0) 对象。
  • ListNode* cur = dummy;:声明了一个 ListNode 类型的指针 cur,并将其初始化为 dummy 指针。

为什么使用 &dummy

使用 &dummy 主要是为了简化链表的操作。具体来说:

  1. 简化链表操作

    • dummy 是一个虚拟头节点,它的存在使得我们不必处理链表头部的特殊情况(比如在空链表上插入第一个节点,或者在链表头部插入新节点)。
    • 通过使用 dummy,所有插入操作都可以统一处理,不需要额外的条件判断。
  2. 指针操作

    • cur 是一个指针,用于遍历和构建新链表。
    • cur 初始化为 dummy 的地址,这样在向链表中添加第一个节点时,dummy.next 可以直接指向新节点,并且后续操作都可以通过更新 cur 来进行。

区别

  1. 内存分配方式

    • ListNode dummy(0); 是在栈上分配的内存。栈上的内存会在超出作用域时自动释放。
    • ListNode* dummy = new ListNode(0); 是在堆上分配的内存。堆上的内存不会自动释放,需要手动调用 delete 来释放,防止内存泄漏。
  2. 指针的使用

    • ListNode dummy(0); ListNode* cur = &dummy; 这里 dummy 是一个对象,cur 是指向 dummy 的指针。
    • ListNode* dummy = new ListNode(0); ListNode* cur = dummy; 这里 dummy 本身就是一个指针,指向堆上的 ListNode 对象,cur 也指向同一个对象。

优缺点

在栈上分配内存

优点

  • 自动管理内存:函数退出时,栈上的内存会自动释放,无需手动管理。
  • 更快的内存分配和释放:栈上的内存操作通常比堆上的快。

缺点

  • 生命周期受限:栈上的对象在函数返回后就被释放,不适合需要在函数外部长期使用的对象。

在堆上分配内存

优点

  • 生命周期灵活:可以手动控制对象的生命周期,适合需要在函数外部长期使用的对象。

缺点

  • 手动管理内存:需要手动释放内存,否则会导致内存泄漏。
  • 相对较慢的内存分配和释放:堆上的内存操作通常比栈上的慢。

在 C++ 中,.-> 操作符用于访问对象的成员:

  • . 操作符用于直接访问对象的成员。
  • -> 操作符用于通过指针访问对象的成员。

区别

  • dummy.nextdummy 是一个对象,通过 . 操作符直接访问 dummy 的成员 next
  • dummy->nextdummy 是一个指向对象的指针,通过 -> 操作符访问指针指向的对象的成员 next

具体示例

栈上分配对象

ListNode dummy(0);       // dummy 是一个对象
ListNode* cur = &dummy;  // cur 是指向 dummy 的指针
cur->next = new ListNode(1);  // 通过 cur 指针访问 next 成员
ListNode* head = dummy.next;  // 直接通过对象 dummy 访问 next 成员

在这个例子中:

  • dummy 是一个 ListNode 对象,可以直接使用 dummy.next 访问其成员。
  • cur 是一个指向 dummy 的指针,使用 cur->next 访问 dummy 的成员。

堆上分配对象

ListNode* dummy = new ListNode(0);  // dummy 是一个指向 ListNode 对象的指针
ListNode* cur = dummy;  // cur 和 dummy 都是指向同一对象的指针
cur->next = new ListNode(1);  // 通过 cur 指针访问 next 成员
ListNode* head = dummy->next;  // 通过 dummy 指针访问 next 成员

在这个例子中:

  • dummy 是一个指向 ListNode 对象的指针,需要使用 dummy->next 访问其成员。
  • cur 同样是一个指向 ListNode 对象的指针,使用 cur->next 访问其成员。

总结

在使用栈上分配的对象时,使用 . 操作符访问成员,因为我们直接处理的是对象本身。而在使用堆上分配的对象时,使用 -> 操作符访问成员,因为我们处理的是指向对象的指针。

热门相关:我真是非洲酋长   逍遥小镇长   我的喵星女友   以权谋妻   完美隐婚