C语言基础之指针

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量811 收藏 15
点赞数 23
分类专栏： C语言学习 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52154565/article/details/136511802
版权

文章目录

指针

系统为内存的每一个字节 分配一个32位的地址编号

指针 就是内存的编号

指针变量：本质是变量 只是该变量 保存的是内存的地址编号（不是普通的数值）

**&**为变量取地址

在这里插入图片描述

1、指针变量的定义

（1）指针的定义

在这里插入图片描述

int num = 20;

p为20的内存地址即**&num**

*p = 20

p = &num

注意：如果对num的地址取地址，即**q == *p == 20，那么 * q == p == &num

（2）定义步骤

*修饰指针变量名（ * p）

保存谁的地址 就先定义谁。

1 定义一个指针变量p 保存 int num的地址； int *p;

2 定义一个指针变量p 保存数组int arr[5]首地址； int (*p)[5]

3 定义一个指针变量p 保存函数的入口地址 int fun(int,int); int (*p)(int,int);

4 定义一个指针变量p 保存结构体变量的地址 struct stu lucy; struct stu *p;

5 定义一个指针变量p 保存指针变量int *p的地址 int **p

（3）指针变量的详解

在32位平台任何类型的指针变量 都是4字节

在64位平台任何类型的指针变量 都是8字节

​ p等价于&num

​ *p等价于num的值 表示取p保存的地址编号的内容

（4）指针使用

	int num = 10;
	int *p = NULL;//定义一个指针
	p = & num；

（5）指针的指针

int num = 10;
int *p = #
int **q = &p;

n级指针变量 可以保存 n-1级的地址

*p---->num

**q---->num

2、指针变量的初始化

（1）指针变量在操作之前必须指向合法地址空间，指针变量如果不初始化 立即操作 会出现段错误

（2）指针变量如果没有指向合法空间 建议初始化为NULL

	int *p = NULL;

（3）将指针地址变量初始化为合法地址（变量地址、动态申请的地址、函数入口地址）

​ int num = 10；

​ int *p = & num；

​ 等价于

​ int num = 10, *p = & num；

3、指针变量类型

（1）指针变量自身的类型

​ 指针变量自身的类型 一般用于赋值语句的判断

​ char *p ---->char *

​ int *p ---->int *

​ short *p ---->short *

​ float *p ---->float *

​ double *p ---->double *

​ long *p ---->long *

void test() 
{ 
int num = 10; 
int *p = # 

//在使用中 
//num 为int &num 为int * ‐‐‐‐>对变量名 取地址 整体类型加一个* 
//p 为int * *p 为int ‐‐‐‐>对指针变量 取* 整体类型减一个* 

 //在使用中 &和*相遇 从右往左 依次抵消 
 *&p == p 
 }

（2）指针变量指向的类型

​ 指针类型指向类型决定取值宽度

​ char *p ----->char 1B

​ int *p ----->int 4B

​ short *p ---->short 2B

​ float *p ---->float 4B

​ double *p ---->double 8B

​ long *p ---->long 4B

案例：

定义一个变量 num = 0x01020304 ，取出其中的02（内容的存取是倒着存倒着取）

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num = 0x01020304;
    char *p = (char *)&num;
    printf(“%#x\n”,*(p+2));
    return 0;
}

取出0203

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num = 0x01020304;
    char *p = (char *)&num;
    printf(“%#x\n”,*(short *)(p+1));
    return 0;
}

（3）*p等价于num

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num = 0;
    int *p = &num;
    
    scanf("%d",p);
    printf("num=%d\n",num);
    *p = 10;
    printf("num=%d\n",num);
    (*p)++;
    printf("num=%d\n",num);
    return 0;
}

（4）指针变量的注意事项

①void不能定义普通变量

​ void num；错误

②void *可以定义指针
	void *p；//可以定义

p自身类型为void *，在32为平台任意类型的指针 为4B那么系统知道P开辟4B空间，所以定义成功

​ p就是万能的一级指针变量，可保存任何一级指针地址

​ 万能指针一般用于函数的形参 达到算法操作多种数据类型的目的

​ 注：不要直接对void p的指针变量 取

​ int num = 10;

​ void *p = & num；

​ *p;//错误 p指向的类型为void 无法确定p的取值宽度

​ 对p取*之前对p先进行指针类型强转

​ 强转*(int *)p

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int num = 10;
    void *p = &num;
    //*p;错误
    printf("%d",*(int *)p);//使用前进行强转
}
③指针变量 未初始化 不要取*
	int *p = NULL;
	*p；错误
④指针变量不要越界访问
#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[5] = {1,2,3,4,5};
    int *p = arr;
    printf(“%d\n”,*(p+6));//越界
    return 0;
}
⑤数组元素的指针变量

p = &arr[0];取第0个元素地址

p = arr；取数组首地址 等价于第0个元素地址

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[5] = {1,2,3,4,5};
    int n = sizeof(arr)/sizeof(arr[0]);
    int i = 0;
    for(i=0;i<n;i++)//遍历数组
    {
        printf("%d",arr[i]);
    }
    int *p = arr;
    
    for(i=0;i<n;i++)//遍历数组
    {
        printf("%d",*(p+i));
    }
    for(i=0;i<n;i++)//遍历数组
    {
        printf("%d",*(arr+i));
    }
    return 0;
}
⑥在使用中 [] 就是 *() 的缩写

​ []是* （）的缩写 []左边的值放在+的左边 []里面的值 放在+右边 整体取*

arr[6] == *(arr+6)

arr[ 5 ] [ 6 ] == * (arr[5] + 6) ==* ( * (arr + 5 ) + 6)

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[5] = {1,2,3,4,5,7,8,9};
    int n = sizeof(arr)/sizeof(arr[0]);
    
    printf("%d\n",arr[6]);
    printf("%d\n",*(arr+6));
}

& arr[0] == & *(arr+0) == arr+0 == arr

⑦扩展

​ 指向同一数组，两指针变量相减 等于他们间的元素个数

		int *p1 =arr;  int *p2 = arr+4;
		p2-p1=4;

​ 两指针变量赋值= p2=p1它们指向同一处

​ 两指针变量判断相等 == p2==p1 他们是否相等

​ 两指针变量判断大小 > < >= <= !=

​ p1>p2 p1!=p2判断位置关系

​ 两指针不能相加（重要）

4、指针数组

指针数组：本质是数组 只是数组的每个元素为 指针。

（1）数值的指针数组

#include <stdio.h>

int main(int argc, char const *argv[])
{
    int num1 = 1;
    int num2 = 2;
    int num3 = 3;
    int num4 = 4;

    int *arr[5] = {&num1, &num2, &num3, &num4};
    int n = sizeof(arr)/sizeof(arr[0]);

    int i = 0;
    for (i = 0; i < n; i++)
    {
        printf("%d\n",*arr[i]);
    }
    return 0;
}

（2）字符的指针数组

#include <stdio.h>

int main(int argc, char const *argv[])
{
    char *str[] = {"haha","lala","xixi","hehe"};
    int n = sizeof(str)/sizeof(str[0]);
    int i = 0;
    for (i = 0; i < n; i++)
    {
        printf("%s\n",str[i]);
    }
    return 0;
}

字符串存放在文字常量区，数组内是每个字符串的地址，存放在栈区或全局区

（3）二维字符数组

char *arr1[4]={"hehe", "xixi", "lala", "haha"};
char arr2[4][128]={"hehe", "xixi", "lala", "haha"};

arr1是在指针数组 存放的是每个字符串的首元素的地址

arr2是二维字符数组 存放的是每个字符串

5、数组指针

数组指针本质是指针变量保存的是数组的首地址。

（1）数组元素地址 和 数组首地址

​ 数组首元素地址：&arr[0] == arr ，+1跳过一个元素

​ 数组的首地址：&arr ，+1跳过整个数组

​ 数组元素地址与数组首地址相等

（2）int (*p)[5] = NULL; 数组指针

	int arr[5] = {1,2,3,4,5};
	int (*p)[5] = &arr;

​ 访问第3个元素

​ arr[2] == (arr+2) == * ( * p+2) == * ( * (p+0)+2) ==(p[0]+2) ==p [ 0 ] [ 2 ]

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[5] = {1,2,3,4,5};
    int (*p)[5] = &arr;
    printf("%d\n",arr[2]);
    printf("%d\n",*(arr+2));
    printf("%d\n",*(*p+2));
    printf("%d\n",*(*(p+0)+2));
    printf("%d\n",*(p[0]+2));
    printf("%d\n",p [0][2]);
    return 0;
}

（6）总结

int *arr[5];//指针数组 本质是数组 每个元素为int *

int (*arr)[5];//数组指针 本质是指针变量 保存的是数组的首地址（该数组必须5个元素

每个元素为int）

6、二维数组和数组指针的关系

int arr[5][5] = 
	{{1,2,3,4,5},{6,7.8,9,10},{11,12,13,14,15},{16,17,18,19,20},{21,22,23,24,25}};

在这里插入图片描述

arr既是数组的地址也是数组首元素地址

arr+1表示第二行地址

示例：

arr[1] => *(arr+1) 第一行第0列的列地址
&arr[1] => &*（arr+1）=>arr+1 第1行的行地址
*arr+1 => 第0行第1列的列地址
arr[1]+2 =>*(arr+1)+2 =>第1行第2列的列地址
**arr ==*(*(arr+0)+0) == arr[0][0]

案例：访问第19个元素

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[5][5] = {{1,2,3,4,5},{6,7.8,9,10},{11,12,13,14,15},					{16,17,18,19,20},{21,22,23,24,25}};
    printf("%d\n",arr[3][4]);
    printf("%d\n",*(*(arr+3)+4));
    printf("%d\n",*(arr[3]+4));
    return 0;
}

7、多维数组的物理存储

不管几维数组在物理上 都是一维存储

将二维数组当成一维数组访问

#include <stdio.h>
int main(int argc, char const *argv[])
{
    int arr[5][5] = {{1,2,3,4,5},{6,7.8,9,10},{11,12,13,14,15},						{16,17,18,19,20},{21,22,23,24,25}};
    int row = sizeof(arr)/sizeof(arr[0]);
    int col = sizeof(arr[0])/sizeof(arr[0][0]);

    int *p = &arr[0][0];
    int i = 0;
    for (i = 0; i < row * col; i++)
    {
        printf("%d ",p[i]);
    }
    printf("\n");
    return 0;
}

8、指针作为函数参数

（1）指针变量作为函数的参数

如果直接将变量的值传递到函数内部修改不能改变变量的值。

int a = 1;
int b = 2;
void my_swap(int x, int y)
{
    int tmp = a;
    a = b;
    b = tmp;
}
my_swap(a,b);//此代码不能交换a,b的值

如果想在函数内部修改外部变量的值 需要将外部变量的地址 传递给函数。

#include <stdio.h>
void set_num(int *d)
{
    *d=100;
    return;
}
int main(int argc, char const *argv[])
{
    int num = 0;
    set_num(&num);
    printf("num = %d\n",num);
    return 0;
}

（2）数组作为函数的参数

函数内部想操作外部数组元素，将数组名传递给函数。

#include <stdio.h>
void printf_int_array(int *p,int n)
{
    printf("sizeof(arr)=%lu\n",sizeof(p));//首元素地址大小8B
    printf("arr[2]=%d\n",p[2]);
}
int main(int argc, char const *argv[])
{
    int arr[4] = {2,3,4,5};
    int n = sizeof(arr)/sizeof(arr[0]);

    printf("sizeof(arr)=%lu\n",sizeof(arr));//数组大小4*4B
    printf_int_array(arr,n);
    return 0;
}

**案例：**键盘输入数组，输出最大值最小值（指针数组作为函数）

#include <stdio.h>
void input_int_array(int *p,int n)
{
    printf("请输入%d个int数据:",n);
    int i = 0;
    for ( i = 0; i < n; i++)
    {
        scanf("%d",p+i);
    }
}
void get_max_min(int *p,int *max_array,int *min_array,int n)
{
    int max= p[0],min = p[0];
    int i = 0;
    for ( i = 0; i < n; i++)
    {
        if (max < p[i])
        {
            max = p[i];
        }
        if (min > p[i])
        {
            min = p[i];
        }
        *max_array = max;
        *min_array = min;
    }
    return;
}
int main(int argc, char const *argv[])
{
    int arr[5] = {0};
    int n = sizeof(arr)/sizeof(arr[0]);
    int max=0,min=0;
    input_int_array(arr,n);//键盘输入
    get_max_min(arr,&max,&min,n);
    printf("max=%d \nmin=%d\n",max,min);
    return 0;
}

（3）二维数组作为函数的参数

函数内部 想操作 函数外部的二维数组 需要将二维数组名 传递给函数。

#include <stdio.h>
void look_array(int (*p)[4],int row,int col)
{
    int i=0,j=0;
    for ( i = 0; i < row; i++)
    {
        for ( j = 0; j < col; j++)
        {
            printf("%d ",p[i][j]);
        }
        printf("\n");
    } 
}
int main(int argc, char const *argv[])
{
    int arr[3][4] = {{1,2,3,4},{2,5,6,34},{4,8,9,2}};
    int row = sizeof(arr)/sizeof(arr[0]);

    int col = sizeof(arr[0])/sizeof(arr[0][0]); 
    look_array(arr,row,col);
    return 0;
}

（4）函数的返回值类型为指针类型

将函数内部的合法地址 通过返回值 返回给函数外部使用

​ 注意：函数不要返回 普通局部变量的地址

#include <stdio.h>
int* get_add(void)
{
    static int data = 10;//静态局部变量，作用于整个进程

    return &data;
}
int main(int argc, char const *argv[])
{
  	int *p;
    p = get_add();
    printf("%d\n",*p);
    return 0;
}

（5）函数指针作为指针类型

​ 函数名 代表函数的入口地址；

​ 函数指针：本质是一个指针变量 只是该变量 保存的是函数的入口地址

​ 函数指针p只能保存 有两个int形参以及int返回值 的函数入口地址

​ int (*p)(int ,int) = NULL;

#include <stdio.h>
int my_add(int x,int y)
{
    return x + y;
}
int main(int argc, char const *argv[])
{
    int (*p)(int ,int);
    p = my_add;

    printf("%d\n",p(10,20));
    return 0;
}

9、总结

数值指针：

  int num = 10;
  int *p = NULL;

p = &num;

​ p = #

​ *p = num;

​ *p + 1 ==num + 1

一维指针数组：

  int arr[4] = {1,6,9,3};
  int *p = NULL;
  p = arr;

p = arr; //数组名等价于元素首地址

*p =arr =(arr+0)= arr[0];

​ *p+1 =*arr+1==arr[0]+1;

​ (p+1) =(arr+1)==arr[1];

​ arr+1 //第1个元素地址

一维数组指针：

  int arr[4] = {12,45,2,78};
  int (*p)[4] = NULL;
  p = &arr;

​ p = &arr;

​ p //第0个元素地址，数组首地址

​ p+1 //跳过整个数组，跳过的地址为数组元素个数*一个数组所占字节

​ arr //第0个元素地址

​ arr+1 //第1个元素地址

​ *(arr+1) //第1个元素

二位指针数组：

  int arr[3][4] = {{2,6,3,8},{0,12,6,89},{12,35,98,36}};
  int *p = NULL;
  p = &arr[0][0];

​ p //首元素地址

​ p+1 //第1个元素地址

​ (p+1) //第0行第1个元素(*(p+0)+1)

​ arr //首元素地址

​ *arr //首元素地址

​ *arr+1 //第1个元素地址

​ (arr+1)//跳到下一行，跳过的地址为第一行元素个数一个元素所占字节

​ arr+1 //跳到下一行，跳过的地址为第一行元素个数*一个元素所占字节

​ arr[1] //第1行元素首地址

​ arr[1]+3 //第1行第3列地址

二位数组指针：

 int arr[3][4] = {{2,6,3,8},{0,12,6,89},{12,35,98,36}};
  int (*p)[4] = NULL;
  p = arr;

p , arr //首行地址

​ p+1 , arr+1 //第1行地址

​ *p+1 , *arr+1 //第1个元素地址

​ *(p+1) , *(arr+1) //第1行地址

​ arr[1] , p[1] //第1行地址

​ arr[1]+1 , p[1]+1 //第1行第1列地址

​ *arr[1] , * p[1] //第1行第0列元素

​ *arr[1]+1 , *p[1]+1 //第1行第0列元素+1

​ *(arr[1]+1) , *(p[1]+1) //第1行第1列元素

10、如有错误欢迎指正

（王子变青蛙）
关注
专栏目录
C语言基础之指针练习题
aw的博客
09-01 4795
分享一个关于指针的小题 #include<stdio.h> void foobar(int a, int* b, int** c) { int* p = &a; *p = 101; *c = b; b = p; } int main() { int a = 1; int b = 2; int c = 3; int* p = &c; foobar(a, &b, &p); printf(“a=%d, b=%d, c=%d, *p=%d\n”, a, b, c, *p)
c语言允许用一个变量来存放指针,C语言基础之指针变量
weixin_36469726的博客
05-17 1329
指针变量是什么呢？它的作用又是什么呢？相信很多在学习C语言的同学都会对此抱有很多的疑惑不解。下面课课家笔者就为大家详细介绍C语言中的指针变量，让大家对此不再疑惑！指针变量是指存放地址的变量，因地址的改变而做出指定性质的衡量变法。换个更详细的说法来说就是数据在内存中的地址也称为指针，如果一个变量存储了一份数据的指针，我们就称它为指针变量。在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。指...
C语言之指针总结（1）
Poem_coder的博客
12-25 4235
前言 指针是C语言的灵魂，本文是对指针的一个总结。 一、指针简介 1.什么是指针 从根本上来看，指针是一个值为内存地址的变量 2.指针变量的定义 （1）定义指针变量的一般形式为：类型名* 指针变量名 ①指针声明符*表明声明的变量时指针 ②类型声明符表明指针所指向对象的类型 例如：int* pi; //定义了一个指针变量pi，指向整型变量。char* cp; //定义了一个指针变量cp，指向字符型变量 注意：①°无论何种类型的指针变量，它们都是用来存放地址的，因此指针变量自身所占内存的大小
C语言基础之指针3（字符串篇）
miniplay的专栏
01-03 1621
有时候小伙伴们在使用数组的时候，习惯的把数组当成了变量，然后就把一个新的数组赋值给了当前的数组，这在C语言里面是不允许的。1. 数组采用一串连续的地址存放数据，首先是考虑取数据的时候比较方便，表面看起来使用 []下标方式，程序元只需要记住下标即可，背后取数据可以使用指针经过偏移即可到达下一个元素的位置，其次分配内存的时候不会随意放置，对内存管理有的放失。虽然上面的数组式的字符串写法不允许直接修改成一个新的字符串，但是令我们始料不及的是，字符串指针的写法允许我们直接把一个新的字符串赋值给它。
C语言基础之指针入门
bit_xwg的博客
11-19 3945
C语言基础之指针入门一.指针简介1.什么是指针2.指针的大小二.指针的类型指针类型的意义三.指针的运算指针+- 整数指针-指针 一.指针简介 1.什么是指针 指针全称为指针变量，是用来存放内存地址的变量，地址是唯一标示一块地址空间的。 用&（取地址操作符） 取出变量的地址存放在一个变量中，这个变量即为指针变量。 2.指针的大小 指针是用来存放地址的，故指针的大小与内存的地址有关，故： 在32位机器上，一共有32根地址线，所以地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以
C语言基础之函数指针
魂影魔宅
04-20 908
函数指针定义 //无参数 void(*pFunc)(); //带参数 void(*pFunc)(int a); //带返回值 int(*pFunc)(int a,int b); 自定义函数指针类型 void add(int a, int b){ printf("a+b=%d\n", a+b); } void sub(int a, int b){ printf("a-b=%d\n", a-b); } int main() { // 先定义函数类型，再通过类型定义指针
C语言基础知识入门大全
热门推荐
weixin_55305220的博客
05-11 60万+
C语言一经出现就以其功能丰富、表达能力强、灵活方便、应用面广等特点迅速在全世界普及和推广。C语言不但执行效率高而且可移植性好，可以用来开发应用软件、驱动、操作系统等。C语言也是其它众多高级语言的鼻祖语言，所以说学习C语言是进入编程世界的必修课！简单来说，一个C程序就是由若干和组成。就是一条预处理命令, 它的作用是通知C语言编译系统在对C程序进行正式编译之前需做一些预处理工作。就是实现代码逻辑的一个小的单元。一个C程序有且只有一个主函数，即main函数。注释是写给程序员看的，不是写给电脑看的。C语言注释方法有
C语言基础：指针的使用
u013288925的博客
06-24 4500
本文中列举了C语言中指针使用的一些常见场景。
【C语言基础之指针初阶】(1)
m0_62547912的博客
08-13 510
C语言基础之初始指针
C语言基础 —— 指针
ArtoriaLili的博客
01-18 3125
前言 学习 STM32 需要一些 C语言基础，其中 结构体 和 指针尤其重要，我们接下来我们就来学习一下 指针 ——————————————————————————————————————————
C语言基础及指针系列源码.zip
01-14
《C语言基础与指针应用解析》 C语言，一种强大的、通用的编程语言，以其简洁的语法和高效性能在软件开发领域占据了重要的地位。它为程序员提供了底层硬件控制的能力，是学习计算机科学和系统编程的基石。"C语言基础...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 888
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2051
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
基于Java语言的店小二服务平台数字玛丽设计源码
最新发布
10-05
该项目为店小二服务平台提供的数字玛丽设计源码，采用Java语言开发，共包含20个文件，其中10个XML配置文件、7个Java源文件以及2个Git忽略文件。该平台旨在提供高效便捷的服务，适用于相关业务场景。
基于Python、HTML、JavaScript和CSS的豆瓣TOP250电影可视化设计源码
10-05
本项目是一款利用Python、HTML、JavaScript和CSS技术构建的豆瓣TOP250电影可视化设计源码，共包含59个文件，涵盖16个Python脚本、13个JavaScript脚本、13个HTML页面、4个CSS样式表、2个JSON数据文件、2个图片文件以及其他辅助文件。该项目旨在以直观的方式展示豆瓣TOP250电影的详细信息，适用于对电影数据进行分析和展示的用户。
基于Java的商城微服务框架设计源码，集成platform中台基础组件库，一键式接入微服务
10-05
本项目为基于Java的商城微服务框架设计源码，集成了platform中台基础组件库，实现一键式接入微服务功能。项目包含236个文件，涵盖154个Java源文件、41个XML配置文件、10个属性文件、7个YAML配置文件、5个SQL脚本文件以及少量HTML、Shell脚本、文本和Git忽略文件等，旨在为商城业务提供高效、灵活的微服务架构支持。
数据手册-74HC02-datasheet.zip
10-05
数据手册-74HC02-datasheet.zip
mmexport1728042361260.mp4
10-05
mmexport1728042361260.mp4
云南农业大学在辽宁2020-2024各专业最低录取分数及位次表.pdf
10-05
那些年，与你同分同位次的同学都去了哪里？全国各大学在辽宁2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
C语言基础：指针在函数参数中的应用
这个资源提供了C语言基础的概述，包括程序结构、数据类型、基本运算符、控制结构、数组、函数以及指针的使用，这些都是C语言编程的基础知识。通过示例代码，学习者可以更好地理解这些概念在实际编程中的应用。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值