指针

基础指针使用

    int num = 99;
    int *p;//定义一个整型指针变量p
    p = #//指针变量p指向num的地址空间（两个指向同一个地址）

指针大小

32位操作系统指针占4个字节； 64位操作系统占8个字节

void PointerSize(){
    int *p;
    double *q;
    char *c;
    cout << "整型指针所占的内存大小" << sizeof(p) << endl;//8字节
    cout << "浮点型指针所占的内存大小" << sizeof(q) << endl;//8字节
    cout << "char指针所占的内存大小" << sizeof(c) << endl;//8字节
}

空指针与野指针

空指针和野指针都不是自主申请的空间，访问会出现异常

/// Description 空指针和野指针
void NullPointer(){
    //对于未初始化的指针，可以指向NULL,即指向内存地址为0的地址，
    //内存地址0~255是系统占用的，不允许被访问
    //强行访问，会抛空指针异常
    int *p = NULL;
    
    //p指向一个系统随机分配内存空间的地址，其内容为100
    //但是仅语法上通过，但不能通过编译
    int *q = (int *)100;
}

const修饰的指针

const修饰指针：常量指针

语法：const 类型* p;

     int num = 100;
    //常量指针特点
    //1.不允许修改指向的值，例如：*p = 100;（error）
    //2.允许修改指向的地址，例如：*p = &a;（ok）
    const int *p = #//定义一个整型常量指针

const修饰常量：指针常量

语法： 类型* const p;

    // 指针常量特点
    //1.允许修改指向的值，例如：*p = 100;（ok）
    //2.不允许修改指向的地址，例如：*p = &a;（error）
    //注：因为指针常量以及指向了一个地址，为常量，所有不能修改地址，但可以修改地址的值。
    int * const q = #//定义一个指针常量

const修饰指针和常量

语法： const 类型* const p;

     //const同时修饰指针和常量
    //一担初始化之后，既不允许修改地址，也不允许修改内容
    const int * const w = #

指针与数组

void ArrayAndPointer(){
    int array[] = {0,1,2,3,4};
    int *p = array;//定义一个整型指针变量p，指向数组array首元素地址
    cout << "当前p指向数组首元素的值=" << *p << endl;
    p++;//指针变量p指向第二个数组元素地址&array[1],因为数组在内存当中的地址是连续的
    cout << "当前p指向数组第二个元素的值=" << *p << endl;
    
    //1.使用循环的方式遍历数组
    cout << "数组内容为:";
    for(p = array;p <= &array[4];p++)
        cout << *p;
    cout << '\n' << endl;
    
    //2.使用循环的方式遍历数组
    p = array;
    cout << "数组内容为:";
    for(int i= 0;i < 5;i++)
        cout << *p++;
    cout << '\n' << endl;
}

值传递与地址传递

值传递

/// Description 值传递
/// 实参不会随着形参的改变而改变
/// - Parameters:
///   - a: 参数1
///   - b: 参数2
void ValueSwap(int a,int b){
    int temp = a;
    a = b;
    b = temp;
}

地址传递

/// Description 地址传递
/// 因为形参和实参指向同一地址，所以实参会随着形参的改变而改变
/// - Parameters:
///   - a: 参数1
///   - b: 参数2
void AddressSwap(int *a,int *b){
    int temp = *a;
    *a = *b;
    *b = temp;
}

冒泡排序

/// Description 通过将指针指向的数组进行排序
/// - Parameters:
///   - array: 数组内容
///   - size: 数组元素个数
void BubbleSort(int *array,int size){
    for(int i = 0;i< size-1;i++){
        for(int j=i+1;j< size;j++){
            if(*(array+i) > *(array+j)){
                int temp = *(array+i);
                *(array+i) = *(array+j);
                *(array+j) = temp;
            }
        }
    }
}

结构体与指针

/// 使用struct关键字建立一个结构体
/// 可以包容不同数据类型或成员类型作为结构体成员
/// 如果使用了typedef声明的struct结构体，则Admit为Student的一个别名
/// 若不使用typedef进行声明，则Admit为Student的一个对象，可以直接进行使用
typedef struct Student{
    string name;
    int age;
    char sex[4];
    int score;
}Admit;

//结构体嵌套
typedef struct Leader{
    Student stu;
    string position;
};

结构体的三种初始方式

void StructStudent(){
    /// 通过实例化对象之后，通过成员访问符.进行访问结构体成员并赋初始值
    Student zhangsan;
    zhangsan.name = "张三";
    zhangsan.age = 20;
    strcpy(zhangsan.sex, "男");
    zhangsan.score = 80;
    PrintfStudent(zhangsan);
    
    /// 在实例化的时候进行初始化赋值
    Student lisi = {"李四",21,"女",90};
    PrintfStudent(lisi);
    
    Admit wangwu = {"王五",28,"女",80};
    PrintfStudent(wangwu);
    
    /// 结构体指针，通过->操作符访问结构体成员
    Student *p = &zhangsan;
    p->name = "赵二";
    strcpy(p->sex, "女");
    p->score = 99;
    PrintfStudent(zhangsan);
    
    //嵌套结构体的使用,并通过调用嵌套结构体成员并修改其内容
    Leader *l = (Leader*)malloc(sizeof(Leader));
    l->stu = lisi;
    l->stu.name = "牛一";
    l->position = "班长";
    PrintfLeader(*l);
}