C++中的.和::和：和-＞的区别_c++中::与.的区别

目录

1、 A.B A为对象或者结构体

2、 A->B A为指针，->是成员提取符号，A->B是提取A中的B,A只能是指向类、结构、联合的指针

3、 ::是作用域运算符， A::B表示作用域A中的名称B,A可以是命名空间、类、结构

4、 : 表示继承，或者是构造函数

1、A.B  A为对象或者结构体；

此处，validationOptions是一个class对象，取他的成员。

 

 

2、A->B  A为指针，->是成员提取，A->B是提取A中的成员B，A只能是指向类、结构、联合的指针；

此处findServersRequest是一个指针，Header（）为成员函数。 

3、::是作用域运算符，A::B表示作用域A中的名称B，A可以是命名空间、类、结构；

此处为经常用到的std命名空间的的string对象。

    1)类作用域操作符。“::”指明了成员函数所属的类。
     2)表示引用成员函数及变量，作用域成员运算符。例如：System::Math::Sqrt() 相当于System.Math.Sqrt()

4、：表示继承

类ClientCertificateValidationOptions_t 继承自 Allocatable_t。

另一种是构造函数

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */

其实冒号后的内容是初始化成员列表，一般有三种情况：
1、对含有对象成员的对象进行初始化，例如，
类line有两个私有对象成员startpoint、endpoint,line的构造函数写成：
line（int sx,int sy,int ex,int ey）：startpoint（sx,sy），endpoint（ex,ey）{……}
初始化时按照类定义中对象成员的顺序分别调用各自对象的构造函数，再执行自己的构造函数
2、对于不含对象成员的对象，初始化时也可以套用上面的格式，例如，
类rectangle有两个数据成员length、width,其构造函数写成：
rectangle（）：length（1），width（2）{}
rectangle（int x,int y）：length（x），width（y）{}
3、对父类进行初始化，例如，
CDlgCalcDlg的父类是MFC类CDialog,其构造函数写为：
CDlgCalcDlg（CWnd* pParent ）： CDialog（CDlgCalcDlg::IDD, pParent）
其中IDD是一个枚举元素，标志对话框模板的ID
使用初始化成员列表对对象进行初始化，有时是必须的，有时是出于提高效率的考虑
 

另外今天做题：

力扣

23. 合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：

输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
  1->4->5,
  1->3->4,
  2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：

输入：lists = []
输出：[]

示例 3：

输入：lists = [[]]
输出：[]

提示：

• k == lists.length
• 0 <= k <= 10^4
• 0 <= lists[i].length <= 500
• -10^4 <= lists[i][j] <= 10^4
• lists[i] 按 升序 排列
• lists[i].length 的总和不超过 10^4

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    struct node{
        int val;
        ListNode* ptr;
        bool operator < (const node& b) const{
            return val > b.val;
        } 
    };
    priority_queue<node> que;
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        for (auto one : lists){
            if(one) que.push({one->val, one});
        }
        ListNode head, *fir = &head;
        while (!que.empty()){
            auto sec = que.top();
            que.pop();
            fir->next = sec.ptr;
            fir = fir->next;
            if (sec.ptr->next) que.push({sec.ptr->next->val, sec.ptr->next});
        }
        return head.next;
    }
};

里面涉及到一个不懂得地方

圈中的两个const无论删掉那个都会报错，这个语法后面需要继续补充了解

 

 参考博客：

C++中的.和::和：和->的区别_Robben.Han-CSDN博客_c++中->和.的区别