5.C语言指针

基础知识

定义和使用

1. 指针也是一种数据类型，指针变量也是一种变量
2. 指针变量指向谁，就把谁的地址赋值给指针变量
3. “*”操作符操作的是指针变量指向的内存空间

void test14(){
    int a = 10;
    char b = 20;

    //int *代表是一种数据类型，int*指针类型，p才是变量名
    //定义了一个指针类型的变量，可以指向一个int类型变量的地址
    int *p;
    p = &a;//将a的地址赋值给变量p，p也是一个变量，值是一个内存地址编号
    //或者 int* p = &a;

    char* p2 = &b;
}

通过指针间接修改变量的值

void test15(){
    int a = 20;
    int *p = &a;
    *p = 30;
    printf("a = %d \n", a);
}

指针大小

void test16(){

    //测试环境Mac系统64位
    printf("int类型的指针所占的空间大小为：%d\n", sizeof(int *)); // 8
    printf("char类型的指针所占的空间大小为：%d\n", sizeof(char *)); // 8
    //在32位平台，所有的指针（地址）都是32位(4字节)
    //在64位平台，所有的指针（地址）都是64位(8字节)

}

万能指针void *

可以指向任意变量的内存空间,并进行强转

//void *可以指向任意变量的内存空间
void test17(){
    void *p = NULL;
    int a = 30;
    p = &a;
    *((int *)p) = 20; //使用指针变量指向的内存时，先转换为int *
    printf("a = %d\n", a);
}

const修饰的指针变量

void test18(){
    int a = 100;
    int b = 200;

    //指向常量的指针  const修饰的是指针
    //修饰*，指针指向内存区域不能修改，指针指向可以变
    const int *p1 = &a;//等价于int const *p1 = &a;

    //*p1 = 111; //error 因为const修饰的是指针，所以*p1不能被修改
    p1 = &b; //ok p1并没有被const修饰

    //指针常量 const修饰的是变量
    //修饰p1，指针指向不能变，指针指向的内存可以修改
    int * const p2 = &a;

    //p2 = &b; //error 因为const修饰的是变量，所以变量p2不能被修改
    *p2 = 222; //ok *p2并没有被const修饰
}

多级指针

1. C语言允许有多级指针存在，在实际的程序中一级指针最常用，其次是二级指针
2. 二级指针就是指向一个一级指针变量地址的指针
3. 三级指针基本用不着

指针和函数

void swap1(int x, int y){
    int tmp;
    tmp = x;
    x = y;
    y = tmp;
    printf("x = %d, y = %d\n", x, y);
}

//函数形参改变实参的值
void swap2(int *x, int *y){
    int tmp;
    tmp = *x;
    *x = *y;
    *y = tmp;
}

int main(){
    int a = 3;
    int b = 5;
    swap1(a, b); //值传递
    printf("a = %d, b = %d\n", a, b);

    a = 3;
    b = 5;
    swap2(&a, &b); //地址传递
    printf("a2 = %d, b2 = %d\n", a, b);
    return 0;
}

数组名做函数参数

//数组名做函数参数，函数的形参会退化为指针
//void printArrary(int a[10], int n)
//void printArrary(int a[], int n)
void printArrary(int *a, int n){
    int i = 0;
    for (i = 0; i < n; i++){
        printf("%d, ", a[i]);
    }
    printf("\n");
}

int main(){
    int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int n = sizeof(a) / sizeof(a[0]);
    //数组名做函数参数
    printArrary(a, n); 
    return 0;
}

指针做为函数的返回值

int a = 10;

int *getA(){
    return &a;
}

int main(){
    *(getA()) = 111;
    printf("a = %d\n", a);
    return 0;
}

指针和字符串

//字符指针
void test19(){
    char str[] = "hello world";
    char *p = str; //将str对应的地址赋值给指针p
    *p = 'm'; //修改str的str[0]值为m
    p++; //指针后移一位
    *p = 'i'; //修改str的str[1]值为i
    printf("%s\n", str); //str的内容变为millo world

    p = "haha";
    //可以看成如下
//    char ha[] = "haha";
//    p = &ha[0];
    //or
//    p = ha;
    printf("%s\n", p);

    char *q = "test";
    printf("%s\n", q);
}

说明

定义	说明
int i	定义整形变量
int *p	定义一个指向int的指针变量
int a[10]	定义一个有10个元素的数组，每个元素类型为int
int *p[10]	定义一个有10个元素的数组，每个元素类型为int*
int func()	定义一个函数，返回值为int型
int *func()	定义一个函数，返回值为int *型
int **p	定义一个指向int的指针的指针，二级指针