1. const修饰指针

（1）常量指针

    //const修饰指针,const后面跟*
    int a=10;
    const int *p=&a;
    
    //指针指向的值不可以修改，指针的指向可以修改
    *p=20;//错误
    p=&b;//正确

（2）指针常量

    //const修饰常量，const后面跟常量
    int a=10;
    int * const p;
	
    //指针指向的值可以该，指针的指向不可以改
    *p=20;//正确
    p=&b;//错误

（3）常量指针常量

    //const既修饰指针，又修饰常量
    //指针指向的值和指向都不可以改
    const int * const p=&a;

2. 指针访问数组

    int arr[4]={1,2,3,4};
    int *p=arr;
    
    cout<<*p<<endl;//1
    p++;
    cout<<*p<<endl;//2

3. 指针和函数

int a=10;
int b=20;
//（1）值传递
void swap(int a,int b){
	int temp=a;
    b=a;
    a=temp;
}
swap(a,b);
cout<<a<<' '<<b<<endl;
//10 20
//a和b的值并没有被改变

//(2)地址传递
void swap(int *a,int *b){
	int temp=*a;
    *b=*a;
    *a=temp;
}
swap(&a,&b);
cout<<a<<' '<<b<<endl;
//20 10
//a和b的值被改变了，地址传递可以改变实参

4. 指针、函数和数组的结合

    //对数组进行冒泡排序
    void bubbleSort(int *arr,int len){//注意加*
    	for(int i=0;i<len;i++){
        	for(int j=0;j<len-i-1;j++){
            	if(arr[j]>arr[i+1]) {
                	int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
    
    int main(){
    	int arr[10]={1,4,6,2,8,9,3,7,5,0};
        bubbleSort(arr,10);//arr就是数组的地址，相当于指针
    }

5. 结构体

	//定义一个结构体
    struct Student{
    	String name;
        int age;
    }
    
    //使用结构体
    //1.
    struct Student s1;
    s1.name="zerlina";
    s1.age=18;
    
    //2. 创建的同时赋初值
    struct Student s2={"zerlina",18};
    
    //3.定义结构体的时候创建结构体变量
    struct people{
    ...
    }s3;
    s3.name="xxx";
    s3.age=18;
    
    //4. 
    Student s4;//创建的时候struct关键字可以省略

6. 结构体数组

	//定义一个结构体
    struct Student{
    	String name;
        int age;
    }
    
    Student subArray[2]={
    	{"aa",20},
        {"bb",30}
    };
    //chang value
    subArray[1].name="cc";

7. 结构体指针

	//定义一个结构体
    struct Student{
    	String name;
        int age;
    }
    Student s1={"aa",12};
    Student *p=&s1;
    string name=p->name;
    int age=p->age;

8. 结构体做函数参数

	//1.值传递
    void fun1(struct student s){
    	cout<<s.name<<endl;
    }
    fun1(s);
    
    //2. 地址传递
    void fun2(struct student *s){
    	s->name="bb";//地址传递可以改数据
    	cout<<s->name<<endl;
    }
    fun2(&s);

9. const修饰结构体数据

在上面的值传递中，每次函数体内部都会复制一个副本来存放传进去的student结构体，为了节省空间我们可以传入指针，即使用地址传递，但地址传递有值被修改的隐患，为了保证数据不被修改，加入const。

	struct student{
      string name;
      int age;
    }
    
    void fun(const student *s){
    	cout<<s->name;
        //s->name=200;会报错
    }
    int main(){
    	student s={"aa",12};
        fun(&s);
    }