类，指针，结构体，引用（算法方面）

1.类与结构体

二者用法差不多，一般习惯庞大数据体定义为类，一些简单数据组合定义为结构体；

class 默认私有 /  struct 默认共有

1.1类的定义

class 类名

{

    private：                   //私有成员，只能在内部调用，main中不能访问

        类型名  变量名 ；

    public：                    //共有成员

        类型名  变量名；

        返回值类型  函数名（）//成员函数

            {

             }

         函数名（参数）{}         //构造函数，可以定义多个，函数名必须与类名一样

}；

 1.2定义成员函数：

  返回类型：：类名（）

1. 可以加{}在class里面定义
2. 可以在类外面定义：返回类型：：类名（）

//写法一
class Time
{
private:
	int hour,minute,second;
public:
	Time(int h, int m, int s); //构造函数，可以有多个

    Time() {}                //加{}表示已经完成定义，下面不用再定义

	void showtime();          //成员函数，有返回类型
};

Time::Time(int h, int m, int s)//定义构造函数 
{
	hour=h; minute=m; second=s;
}

void Time::showtime()
{
	cout<<hour<<":"<<minute<<":"<<second<<endl;
}


//写法二
class Time
{
private:
	int hour,minute,second;
public:
	Time(int h, int m, int s):hour(h),minute(m),second(s){} //定义构造函数
	
    void showtime() //声明并定义成员函数
    {
         cout<<hour<<":"<<minute<<":"<<second<<endl;
     }
};

1.3类的调用

1. 类名  对象名      //这个变量可以自己定义

    对象名 . 成员名 

2. 指针 -> 成员名

Time c;
Time * p = &c;
p ->showtime();//作用在p指向的对象c上

3. 引用名 . 成员名

调用构造函数，必须把参数加上，可以初始化私有成员。

class Time
{
private:
	int hour,minute,second;
public:
	Time(int h, int m, int s); //构造函数
	void showtime();          //成员函数，有返回类型
};

Time::Time(int h, int m, int s)//定义构造函数 
{
	hour=h; minute=m; second=s;
}

void Time::showtime()
{
	cout<<hour<<":"<<minute<<":"<<second<<endl;
}

//类的实现
int main()
{
	Time t(10,10,10); //构造函数参数必须都加上
	t.showtime();
}

2.指针与引用

2.1指针

指针指向存放变量的地址，通过指针来修改变量的值。

可以理解为指针就是以变量地址为数组下标的那个数组

int*  p //定义int类型的指针---p的类型是 int*

int* p = &a  //p指向a的地址

cout<< *p <<endl; //指向a的地址的值

cout<< p  <<endl;  //输出a的地址

#include<iostream>
using namespace std;

int main()
{
    int a=10;
    int* p = &a;  //定义指针p指向a的地址
   
    cout<<*p<<endl;  // 输出a的值
    *p=12;          //通过指针更改a的值

    cout<<*p<<endl;
    cout<<a<<endl;
}

输出：10
      12
      12

2.2指针的运算

数组本质也是指针，指针也可以运算。

int a[5]={1,2,3};

int* p=a;

cout<<*(p+2)<<endl;//输出a[2]的值  *（p+2）等价于*（a+2）

cout<<p+1<<endl;  //输出a[1]的地址 等价于a+1

char*  默认输出字符串，若要输出地址 用（void*）

char a[5] ={1,2,3,4,5};

char* p = a;

cout<<(void*)p<<endl;

//输出a[0]的地址

指针地址的减法：

不允许不同类型的指针相减。

int a[5] = {0};

int* p = &a[0], *q = &a[2];//指针是int类型

cout<< q - p <<endl;   //地址的减法，得到的是两个地址间隔几个int。

输出：2

2.3 指针的指针（算法少用）

存放指针的地址

int a = 10;

int*  p = &a; //p的值是a的地址

int** q = &p;//q指向*p的地址

2.4 引用

与指针类似，相当于变量的别名。

int& p = a；//定义p，p和a在一个地址，二者共同，p改变a也变，a改变p也变

int a=10;
int& p=a;

p++;

cout<<a<<endl;//a=11,p=11

3.链表

定义一个结构体：struct  结构名{ };

结构体内定义指针：结构名*  变量名；

定义一个链表结点：Node node = Node (1); //链表结点是1

Node* p = Node(1);//Node类型变量，值是1

Node* p = new Node (1);  

struct Node  //定义结构体
{
    int val;
    Node* next;//定义指针

    Node(int_val):(val(_val),next(NULL){}  //构造函数，指针为空
};
int main()
{
    Node node = Node(1);//定义Node类型的变量，返回的是值 ，把1赋给val

    Node* p = new Node(1);//返回的是地址

    p->next = p;//next指向自己 
}

1. 定义变量来调用成员 用 " . "

Node a = Node (1);

a.next, a.val;

2. 定义指针来调用成员 用 " -> "

Node* p = new Node(1) ;

p-> next = p ;

p -> val ;

链表的使用：

删除链表：要知道前一个才可以。在遍历的时候，遍历不到即删除。（跳过去这个点）

struct Node  //定义结构体
{
    int val;
    Node* next;//定义指针

    Node(int_val):(val(_val),next(NULL){}  //构造函数
};
int main()
{
    Node* p = new Node(1);  //Node*可以写成auto
    Node* q = new Node(2);
    Node* o = new Node(3);

    p->next = q; //头结点，第一个结点的地址，不是值。p的指针指向q
    q->next = o; //q指针指向o,o指向空

    Node* head = p;  //头结点

    //添加节点
    head* u = new Node(4);
    u->next = head;
    head = u;

    //删除节点
    head->next = head->next->next;
    
    //遍历链表
    for(Node* i = head;i;i = i->next)
     cout<< i->val <<endl;

}

会输出：1 \n 2\n 3\n