第六章 类、结构体、指针、引用

1 类和结构体

1.1 类的定义

类中的变量和函数被统一称为类的成员变量。
private后面的内容是私有成员变量，在类的外部不能访问；public后面的内容是公有成员变量，在类的外部可以访问。

1.2 类的使用

#include <iostream>

using namespace std;

const int N = 1000010;

class Person
{
    private:
        int age, height;
        double money;
        string books[100];
    
    public:
        string name;
        
        void say()
        {
            cout << "I'm " << name << endl;
        }
        
        int set_age(int a)
        {
            age = a;
        }
        
        int get_age()
        {
            return age;
        }
    
        void add_money(double x)
        {
            money += x;
        }
} person_a, person_b, persons[100];

int main()
{
    Person c;
    
    c.name = "yxc";      // 正确！访问公有变量
    c.age = 18;          // 错误！访问私有变量
    c.set_age(18);       // 正确！set_age()是共有成员变量
    c.add_money(100);
    
    c.say();
    cout << c.get_age() << endl;
    
    return 0;
}

1.3 结构体与类的联系与区别

结构体和类的作用是一样的。不同点在于类默认是private，结构体默认是public。

1.4 结构体的用途

结构体多用来封装一组数据

2 指针和引用

2.1 指针

指针指向存放变量的值的地址。因此我们可以通过指针来修改变量的值。

数组名是一种特殊的指针。指针可以做运算：

2.2 引用

引用和指针类似，相当于给变量起了个别名

3 链表（结构体、指针）

3.1 链表基本操作

头结点：第一个节点的地址

#include <iostream>
#include <cstdio>

using namespace std;

struct Node{
    int val;
    Node* next;
    
    Node(int n_val):val(n_val),next(NULL){}
};

int main()
{
    Node* p = new Node(1);
    Node* q = new Node(2);
    Node* o = new Node(3);
    
    Node* head = p; //头指针，第一个节点
    p->next = q;
    q->next = o;
    
    //插入节点
    Node* u = new Node(4);
    u->next = head;
    head = u;
    
    //删除1节点
    head->next = head->next->next;
    
    //链表的遍历
    for(Node* i = head; i != NULL; i = i->next){
        cout<<i->val<<endl;
    }
    
    return 0;
}

3.2 链表习题

1 合并两个排序的链表

输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按照递增排序的。

样例
输入：1->3->5 , 2->4->5

输出：1->2->3->4->5->5

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* l1, ListNode* l2) {
        ListNode* l3 = new ListNode(-1);//建立一个头结点
        ListNode* tail = l3; //指向链表的尾结点，尾插法插入结点
        
        while(l1 && l2)
        {
            if(l1->val <= l2->val)
            {
                //插入l1的节点
                tail->next = l1;
                l1 = l1->next;
                tail = tail->next;//指向当前链表尾结点
            }else{
                //插入l2的节点
                tail->next = l2;
                l2 = l2->next;
                tail = tail->next;
            }
        }
        
        //当某个链表移动到结尾如l1 = l1->next == NULL，接上l2剩下的全部即可，反之
        if(l1 == NULL){
            tail->next = l2;
        }else{
            tail->next = l1;
        }
        
        return l3->next;
    }
};