【一线教师总结】C语言学习--指针总结

一、如何声明指针
int *pInt /*类型* 指针变量名*/
在C或C++语言中，int *pInt; 是一个声明，它定义了一个名为 pInt 的指针变量，该变量可以指向整数（int）类型的内存地址。
这里，int 是指针所指向的数据类型，而 *pInt 表示 pInt 是一个指向整数的指针。但是，在声明中，我们通常省略星号（*）前的空格，所以更常见的写法是 int* pInt; 或者 int *pInt;（两者在C和C++中都是有效的）。
课件内容：
1、指针变量到底是谁？
指针变量 名字是pa pb 还是*pa *pb
【师说】通俗易懂讲，pa pb是指针变量（你想定义的）， 但是计算机要想知道必须是*pa, *pb才可被计算机知道
在C或C++中，指针变量是用于存储另一个变量（或内存位置）的地址的变量。下面我将解释指针变量命名的约定以及*在指针声明和定义中的作用。
.*在指针中的作用：
* 在声明或定义时，`*`表示这个变量是一个指针，它存储的是地址，而不是值本身。
* 在表达式或语句中，`*`用于解引用指针，也就是获取指针所指向的值。
【师说】你赋给指针啥样类型的地址，一般不能换

二、指针变量的初始化
【师说】任何一个变量完成申明后，一般的步骤都要跟着赋初值（C语言八股体）
如果指针不定义初始化值的话，计算机会随机分配一块内存空间给该指针，包括系统内存空间，错误占用会导致死机或者各种内存错误。
如果确实不知道写到哪里
int* pInt = NULL;
在前期备课中应讲述八股体结构，让学生从开始代码书写规范
误区
int *p=3; 
* 不同于 int *p; *p=3;(x)
int *p=&i,i=3; (x)

三、指针变量的值
“指针变量的值”是指针本身存储的数值。这个值被当作是一个地址。

四、取地址操作符&
#include<stdio.h>
main(){
 
int num=0;

int *p =&num;
printf("%p\n",&num);

printf("%p\n",p); 
}

【师说】指针变量的值与指针变量的地址有区分的
不管任何时候指针变量的内存空间都为4个，
由于指针变量也是一种变量，它本身也占用一定的内存空间，因此也可以用一个指针指向指向它
五、指向指针的指针
double num;
double *pN=&num;
double *ppN=&pN;
=====================定义指针结束===========================
六、指针的使用
#include<stdio.h>
#include<stdio.h>
main(){
 
int num=9;

int *p= &num;
printf("%d\n",*p); 
*p=10;
printf("%d\n",num);
}
七、指针的类型和指针所指向的类型
 

#include<stdio.h>
main(){
    int num=9;
    int *pInt=&num;
    printf("%d",num);
    int *pInt2=pInt;
    *pInt=11; 
     printf("%d",num);
}  
八、指针的运算
#include<stdio.h>
main(){    
    int sz[9]={1,2,3,4,5,6,7,8,9};
    
    int *p=&sz[0];
    for(int i=0;i<9;i++)
    {
        printf("%d ", *p);
        p++;
    }
    
    
}  
指针+整数=指针+sizeof(int)*整数
指针-指针=整数
#include<stdio.h>
main(){
    
    int sz[9]={1,2,3,4,5,6,7,8,9};
    int *p1=&sz[0];
    int *p2=&sz[4];
    int num=p1-p2;
    printf("%d",num);
    
    
}  
九、指针与左值
指针变量可以作左值，并不是因为它们是指针，而是因为是变量

十、malloc与free
int *p=(int *) malloc(5*sizeof(int));

#include<stdio.h>
#include <stdlib.h>
main(){
    /*声明int指针p,申请动态内存，并用首地址p初始化*/
    int *p=(int*)malloc(10*sizeof(int));
    
    if(p==NULL)
    {
        printf("falied");
        return 1;
    }
    int i=0;
    for(i=0;i<10;i++)
    {
        *(p+i)=i;
    }
     for(i=0;i<10;i++)
    {
        printf("%d",*(p+i));
    
    }
    free(p);
}  
十一、指针与数组
1、数组名指针
数组名是一种常指针（不能修改），其值等于数组占据内存单元的首地址，但其类型取决于数组维数。
A=&A[0];
A+1=&A[1];
2、指针数组
#include<stdio.h>
#include <stdlib.h>
main(){
    
    int A[2][3]={{2,3,4},{2,3,6}};
    //printf("%d",A[0][2]);
    int i,j;
    int* pa=&A[0][0];
    
    for(i=0;i<2;i++)
      for (j=0;j<3;j++)
        {
        printf("%d\n",*(pa+3*i+j));
        
        }
} 
十二、结构体与数组
1、结构体数组
（*指针）.成员 #（）不可以删掉// 结构变量名.xxx
指针->成员 //指向结构变量的指针->xxx

#include<stdio.h>
#include <stdlib.h>
main(){
    
    struct person
    {
        char name[20];
        int age;
        char emails[59];
        
    
    }zhangsan={"zhangsan",24,"zs@163.com"};
    struct person *pz=&zhangsan;
    printf("%s",(*pz).name);    
1    
    
} 
2、数组结构体
普通数组名可以看成是“指向数组元素首地址的常指针”
#include<stdio.h>
#include <stdlib.h>
struct person
    {
        char name[20];
        int age;
    
    };

main(){
    
    int i;
    struct person pz1[]={{"ZW",23},{"Zf",24},{"TRE",63}    };
    struct person *pz=pz1;
    for(i=0;i<3;i++)
    {
        printf("%s",(pz1+i)->name);
        printf("%s", (*pz).name);
        pz++;
        
        
        }    
    
    
} 
[师说]为什么第一个例子要用&，第二个不需要
1.普通结构体变量
- 如第一个例子所示，zhangsan是一个普通的结构体变量，不是数组。因此，我们需要使用取地址运算符&来获取zhangsan的内存地址，然后将这个地址赋值给指针pz。
2.结构体数组
- 在第二个例子中，pz1是一个结构体数组。使用数组名pz1本身就表示数组的首地址。因此，当你定义指针struct person *pz = pz1;时，直接使用数组名pz1就已有&效果，不需要再加&。
- 当你操作单个结构体变量时，你需要通过&取该变量的地址来给指针赋值。
- 而当操作结构体数组时，数组名本身就代表数组的首地址，所以不需要再使用&。
十三、函数与指针
int * fun(int);/*前者是返回一个int型指针类型。*/
//函数指针的声明方式
int (*fun)(int); /*后者是函数指针*/
1、函数指针的声明和调用（无参数）
#include <stdio.h>
// 示例函数
void sayHello() {
    printf("Hello, World!\n");
}

int main() {
    // 声明函数指针
    void (*funcPtr)();
    
    // 将函数地址赋值给指针
    funcPtr = sayHello;
    
    // 通过函数指针调用函数 (两种形式)
    (*funcPtr)();
    funcPtr();
    
    return 0;
}
2、函数指针的声明和调用（有参数）
#include <stdio.h>

// 示例函数
int add(int a, int b) {
    return a + b;
}

int main() {
    // 声明指向带有参数和返回值的函数的指针
    int (*funcPtr)(int, int);
    
    // 将函数地址赋值给指针
    funcPtr = add;
    
    // 通过函数指针调用函数并获取返回值
    int result = funcPtr(2, 3);
    printf("Result: %d\n", result);
    
    return 0;
}

3、典型例题
1. 非指针方法（值传递）
这种方法直接传递值，但在C语言中无法直接交换主函数中的变量值。
#include <stdio.h>

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    printf("Inside swap function: a = %d, b = %d\n", a, b);
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    swap(x, y);
    
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

输出：
Before swap: x = 5, y = 10
Inside swap function: a = 10, b = 5
After swap: x = 5, y = 10

注意：这种方法实际上并没有交换主函数中 x 和 y 的值，因为 C 语言使用值传递。函数 swap 只交换了局部副本的值。
2. 指针方法（引用传递）
使用指针可以实际交换主函数中变量的值。
#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 5, y = 10;
    printf("Before swap: x = %d, y = %d\n", x, y);
    
    swap(&x, &y);
    
    printf("After swap: x = %d, y = %d\n", x, y);
    return 0;
}

输出：
Before swap: x = 5, y = 10
After swap: x = 10, y = 5
【师说】指针会改变两个数字在内存的位置，因此要谨慎使用！切记！