【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 重要是为了简化链表的操纵。详细来说：

• 简化链表操纵：
  
  
  
  • dummy 是一个虚拟头节点，它的存在使得我们不必处理链表头部的特殊情况（好比在空链表上插入第一个节点，或者在链表头部插入新节点）。
    
  • 通过利用 dummy，所有插入操纵都可以统一处理，不必要额外的条件判断。
    
  
  
• 指针操纵：
  
  
  
  • cur 是一个指针，用于遍历和构建新链表。
    
  • 将 cur 初始化为 dummy 的地址，这样在向链表中添加第一个节点时，dummy.next 可以直接指向新节点，而且后续操纵都可以通过更新 cur 来进行。
    
  
  

区别

• 内存分配方式：
  
  
  
  • ListNode dummy(0); 是在栈上分配的内存。栈上的内存会在超出作用域时自动开释。
    
  • ListNode* dummy = new ListNode(0); 是在堆上分配的内存。堆上的内存不会自动开释，必要手动调用 delete 来开释，防止内存泄漏。
    
  
  
• 指针的利用：
  
  
  
  • ListNode dummy(0); ListNode* cur = &dummy; 这里 dummy 是一个对象，cur 是指向 dummy 的指针。
    
  • ListNode* dummy = new ListNode(0); ListNode* cur = dummy; 这里 dummy 本身就是一个指针，指向堆上的 ListNode 对象，cur 也指向同一个对象。
    
  
  

优缺点

在栈上分配内存

优点：

• 自动管理内存：函数退出时，栈上的内存会自动开释，无需手动管理。
  
• 更快的内存分配和开释：栈上的内存操纵通常比堆上的快。
  

缺点：

• 生命周期受限：栈上的对象在函数返回后就被开释，不适合必要在函数外部长期利用的对象。
  

在堆上分配内存

优点：

• 生命周期灵活：可以手动控制对象的生命周期，适合必要在函数外部长期利用的对象。
  

缺点：

• 手动管理内存：必要手动开释内存，否则会导致内存泄漏。
  
• 相对较慢的内存分配和开释：堆上的内存操纵通常比栈上的慢。
  

在 C++ 中，. 和 -> 操纵符用于访问对象的成员：

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

区别

• dummy.next：dummy 是一个对象，通过 . 操纵符直接访问 dummy 的成员 next。
  
• dummy->next：dummy 是一个指向对象的指针，通过 -> 操纵符访问指针指向的对象的成员 next。
  

详细示例

栈上分配对象

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

复制代码

在这个例子中：

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

堆上分配对象

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

复制代码

在这个例子中：

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

总结

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。