C语言——指针

已于 2024-01-03 21:32:56 修改
阅读量981 收藏 20
点赞数 21
分类专栏： 初级C语言 文章标签： c语言 开发语言
于 2023-11-30 09:41:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wx2023_10_15/article/details/134700206
版权

1. 指针的概念

在计算机中我们把内存单元的编号也称为地址。C语言中给地址起了新的名字叫：指针。
简单来说，指针就是地址，不过我们口头说的指针其实是指针变量，指针变量是一个存放地址的变量；
指针变量除了可以存放变量的地址外，还可以存放其他数据的地址，例如可以存放数组和函数的地址。

2 指针变量的初始化与使用

2.1 取地址操作符（&）

上面我们已经知道了指针是存放地址的，所以我们得先得到变量的地址。
如何能得到地址呢？那这里就要学习一下取地址操作符（&）了。
直接上代码：

#include<stdio.h>
int main()
{
int a = 10;
printf(“%p\n”, &a);
return 0;
}

运行结果为：
image.png
看到这可能有人会说：“一个字节有一个地址，那整型（int）是四个字节，那应该打印四个地址呀，怎么只打印一个呢？”
其实很简单，&a取出的是a所占4个字节中地址较小的字节的地址。虽然整型变量占一 4个字节，我们只要知道了第⼀个字节地址，顺藤摸瓜访问到4个字节的数据也是可行的。

2.2 指针变量的初始化

其形式如下：
image.png
这里 pa左边写的是 int* ， * 是在说明pa是指针变量，而前面的 int 是在说明pa指向的是整型(int)
类型的对象。
以此类推：
image.png

2.3 解引用操作符（*）

得到地址的下一步，就是使用它了，而我们要想使用地址就需要学习一下解引用操作符（*）。
同样的直接上代码：

#include<stdio.h>
int main()
{
int a = 10;
int pa = &a;
printf(“%d\n”, a);
printf(“%d\n”, *pa);
return 0;

}
运行结果为：
image.png
*pa 的意思就是通过pa中存放的地址，找到指向的空间, pa其实就是a变量了,所以我们看到打印的 a 和pa
的值是一样的。

2.4 指针变量的使用

  1. 通过指针变量引用所指向的变量
    我们可以通过改变指针指向的变量的值来修改变量。
    代码如下：
int main()
{
int a = 10;
int* pa = &a;
*pa = 20;
printf(“%d\n”, a);
return 0;
}

运行结果如下：
image.png

使用指针变量
需要使用地址时，可以直接引用指针变量名。
来一波代码吧：

#include<stdio.h>
int add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
int(*p)(int, int) = add;
printf(“%d\n”, (*p)(a, b));
printf(“%d\n”,add(a,b));
return 0;
}


运行结果如下：
image.png
可能有的伙伴对这个代码还有疑问，但这里不过多解释，只是为了让大家对使用指针变量能有一个概念，关于函数指针我们后面会讲到的。

2.5 指针的大小

32位平台下地址是32个bit位，指针变量大小是4个字节 ；
64位平台下地址是64个bit位，指针变量大小是8个字节。
在 VS2022 X86 环境下：
image.png
在 VS2022 X64 环境下：
image.png

注意：注意指针变量的大小和类型是无关的，只要指针类型的变量，在相同的平台下，大小都是相同的。

3.指针类型的作用

虽然指针变量的大小与类型无关，但是指针的类型有其他特殊的意义，我们接下来继续学习。

3.1 指针的解引用

首先，通过代码来直观感受下不同类型指针的功能吧。
代码 1：

#include<stdio.h>
int main()
{
int a = 0x11223344;
int* pa = &a;
*pa = 0;
return 0;
}


调试内存变化为：
变化前：


image.png
变化后：
image.png
代码 2：

#include<stdio.h>
int main()
{
int a = 0x11223344;
char* pa = (char*) & a;
pa = 0;
return 0;
}


调试内存变化为：
变化前：
image.png
变化后：
image.png
通过调试我们可以看到，代码1会将 a 的4个字节全部改为0，但是代码2只是将 a 的第⼀个字节改为0。
结论：指针的类型决定了，对指针解引用的时候有多大的权限（一次能操作几个字节）。
比如： char* 的指针解引用就只能访问⼀个字节，而 int* 的指针的解引用就能访问四个字节。

3.2 指针±整数

同样的先看一段代码，观察其运行结果。

#include <stdio.h>
int main()
{
int n = 10;
char pc = (char)&n;
int pi = &n;
printf(“%p\n”, &n);
printf(“%p\n”, pc);
printf(“%p\n”, pc+1);
printf(“%p\n”, pi);
printf(“%p\n”, pi+1);
return0;
}


运行结果如下：
image.png
我们可以看出， char* 类型的指针变量+1跳过1个字节， int* 类型的指针变量+1跳过了4个字节。
这就是指针变量的类型差异带来的变化。
结论：指针的类型决定了指针向前或者向后走一步有多大（距离）。

3.3 void*指针

在指针类型中有⼀种特殊的类型是 void* 类型的，可以理解为无具体类型的指针（或者叫泛型指针），这种类型的指针可以用来接受任意类型地址。但是也有局限性， void* 类型的指针不能直接进 行指针的±整数和解引用的运算。
通俗来讲，void* 指针像一个垃圾桶，你可以往里面丢任何东西，它都可以接收，但就像你不会翻垃圾桶取东西一样，void * 指针无法取出地址进行运算。
来个图吧：
image.png
在上面的代码中，将⼀个int类型的变量的地址赋值给⼀个char * 类型的指针变量。编译器给出了⼀个警告（如下图），是因为类型不兼容。而使用 void * 类型就不会有这样的问题。
image.png
通过上面代码我们发现，void* 类型的指针可以接收不同类型的地址，但是无法直接进行指针运算。
void * 指针的作用是使用在函数参数的部分，用来接收不同类型数据的地址，这样的设计可以 实现泛型编程的效果。使得⼀个函数来处理多种类型的数据。

4. 指针的运算

指针的运算分为三种：

  • 指针±整数
  • 指针-指针
  • 指针的关系运算

4.1 指针±整数

这个运算方法前面我们已经说过了如何使用了，现在我们讲一下具体的运用吧。
用指针打印数组：
因为数组在内存中是连续存放的，只要知道第一个元素的地址，顺藤摸瓜就能找到后面的所有元素。
代码如下：

#include<stdio.h>
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int* p1 = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
int i = 0;
for (i = 0; i < sz; i++)
{
printf(“%d “, arr[i]);
}
printf(”\n”);
for (i = 0; i < sz; i++)
{
printf("%d ", *(p1 + i));
}
return 0;
}


运行结果为：
image.png

4.2 指针-指针

两指针相减所得的绝对值为两指针之间的元素个数。
前提条件：两指针指向同一块空间。
代码如下：

#include<stdio.h>
int my_strlen(char* str1)
{
char* str2 = str1;
while (*str2)
{
str2++;
}
return str2 - str1;
}
int main()
{
char ch1[] = “abcdef”;
int ret = my_strlen(ch1);
printf(“%d\n”, ret);
return 0;
}

运行结果如下：
image.png

4.3 指针的关系运算

简单来说就是比较两指针的大小（地址比较大小）。
代码如下：

#include<stdio.h>
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int sz = sizeof(arr) / sizeof(arr[0]);
int* p = arr;
while (p < arr + sz)
{
printf("%d ", *p);
p++;
}
return 0;
}


运行结果如下：
image.png

5.野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）。

5.1 野指针成因

5.1.1 指针未初始化

#include <stdio.h>
int main()
{
int* p;//局部变量指针未初始化，默认为随机值
*p = 20;
return 0;
}

5.1.2 指针越界访问

代码如下：

#include <stdio.h>
int main()
{
int arr[10] = { 0 };
int* p = &arr[0];
int i = 0;
for (i = 0; i <= 11; i++)
{
//当指针指向的范围超出数组arr的范围时，p就是野指针
*(p++) = i;
}
return 0;
}

5.1.3 指针指向的空间释放

#include <stdio.h>
int* test()
{
int n = 100;
return &n;
}
int main()
{
int* p = test();
printf(“%d\n”, *p);
return 0;
}

5.2 如何规避野指针

  • 指针初始化
  • 小心指针越界
  • 指针变量不使用时，及时置 NULL，使用指针前检查有效性
  • 避免返回局部变量的地址

6.二级指针

指针变量也是变量，是变量就有地址，那么指针的地址存放在哪呢？
答案是：二级指针。
代码如下：

#include<stdio.h>
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
return 0;
}


这样不能太直观的对它进行理解，那么我们绘图来感受一下吧。
image.png
二级指针的运算：
**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a .
image.png

7.数组与指针

7.1 数组名的理解

#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf(“&arr[0] = %p\n”, &arr[0]);
printf(“arr = %p\n”, arr);
return 0;
}


运行结果如下：
image.png
通过上面的代码我们可以发现数组名和数组首元素的打印结果一模一样，所以数组名就是数组首元素（第一个元素）的地址。
那如果数组名就是数组首元素地址的话，下面的代码又该如何理解呢？

#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf(“%d”, sizeof(arr));
return 0;
}


运行结果如下：
image.png

如果 arr 是数组首元素地址的话，那结果应是 4/8 呀！
其实数组名是数组首元素地址没错，不过有两个例外：

  • sizeof(数组名)，sizeof中单独放数组名，这里的数组名表示整个数组，计算的是整个数组的大小， 单位是字节
  • &数组名，这里的数组名表示整个数组，取出的是整个数组的地址（整个数组的地址和数组首元素的地址是有区别的）

除此之外，任何地方使用数组名，数组名都表示首元素的地址。
我们再来看看数组名和 &数组名的区别吧：

#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
printf(“&arr[0] = %p\n”, &arr[0]);
printf(“arr = %p\n”, arr);
printf(“&arr = %p\n”, &arr);
printf(“&arr[0]+1 = %p\n”, &arr[0]+1);
printf(“arr+1 = %p\n”, arr+1);
printf(“&arr+1 = %p\n”, &arr+1);
return 0;
}


运行结果如下：
image.png
通过上面的代码，我们可以看出 arr 与&arr 都是 arr[0] 的地址，不过&arr[0] 和 arr 加 1 都是跳过 4 个字节，即一个元素；而&arr+1 跳过 40 个字节，即跳过了整个数组。

7.2 指针数组

7.2.1 指针数组的概念

我们来类比一下：整型数组是存放整型的数组；字符数组是存放字符的数字；那么指针数组就是存放指针的数组。
其格式如下
image.png
int* 表示数组的类型 ；
arr 表示数组名；
[ ] 中的常量值表示数组的元素个数。

7.2.2 指针数组的使用

用指针数组模拟二维数组
代码如下：

#include <stdio.h>
int main()
{
int arr1[] = { 1,2,3,4,5 };
int arr2[] = { 2,3,4,5,6 };
int arr3[] = { 3,4,5,6,7 };
int* parr[3] = { arr1, arr2, arr3 };
int i = 0;
int j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 5; j++)
{
printf(“%d “, parr[i][j]);
}
printf(”\n”);
}
return 0;
}


运行结果如下：
image.png
parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型一维数组，parr[i][j]就是整型一维数组中的元素。
上述的代码模拟出二维数组的效果，实际上并非完全是二维数组，因为每一行并非是连续的。

7.3 数组指针变量

7.3.1 数组指针变量的概念

数组指针变量存放的是数组的地址，能够指向数组的指针变量。类似整型指针变量存放整型数据的地址，能够指向整型数据。
其格式如下：
image.png
p 先和 * 结合，说明 p 是⼀个指针变量，然后指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
注意：[ ]的优先级要高于 * 号的，所以必须加上（ ）来保证 p 先和 * 结合。

7.3.2 数组指针的初始化

数组指针存放数组地址，完成初始化。如下：
image.png
image.png
通过调试我们可以看出 p 与 &arr 的类型是一样的。
指针类型解析：
image.png

7.3.3 数组指针的使用

代码如下：

#include <stdio.h>
int main()
{
int arr[3][5] = {1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7};
int(*p)[5] = &arr;
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf(“%d “, p[i][j]);
}
printf(”\n”);
}
return 0;
}


运行结果如下：
image.png

8.函数指针变量

8.1 函数指针的概念

函数指针变量是用来存放函数地址的，未来通过地址能够调用函数的。
那么函数是否有地址呢？我们写个代码看看吧。

#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
int ret = Add(a, b);
printf(“%p\n”, Add);
printf(“%p\n”, &Add);
return 0;
}


运行结果如下：
image.png
从上面我们可以看出函数是有地址的，而且函数名就是函数的地址。
其格式如下：
image.png
我们来写个代码看看函数指针变量如果创建吧。如下：

#include<stdio.h>
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
int ret = Add(a, b);
int(*p)(int, int) = Add;
printf(“%p\n”, Add);
printf(“%p\n”, p);
return 0;
}


运行结果如下：
image.png

8.2 函数指针变量的使用

通过函数指针调用指针指向的函数。
代码如下：

#include<stdio.h>
int add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
add(a, b);
int(*p)(int, int) = add;
printf(“%d\n”, (*p)(a, b));
printf(“%d\n”, p(a,b));
return 0;
}


运行结果如下：
image.png

9.函数指针数组

9.1 函数指针数组的概念

函数指针数组就是存放函数指针类型数据的数组。
其格式如下：
image.png
parr 先与 [ ] 结合，说明 parr 是数组，数组的内容是 int (*parr) ( ）类型的函数指针

9.2 函数指针数组的使用（转移表）

函数指针数组的用途：转移表
举例：用函数指针数组实现计算机的简单功能

#include <stdio.h>
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
int mul(int a, int b)
{
return a * b;
}
int div(int a, int b)
{
return a / b;
}
int main()
{
int x, y;
int input = 1;
int ret = 0;
int(p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
do
{
printf("******************\n");
printf("    1:add   2:sub \n");
printf("    3:mul   4:div \n");
printf("       0:exit     \n");
printf("******************\n");
printf(“请选择：”);
scanf(“%d”, &input);
if ((input <= 4 && input >= 1))
{
printf(“输入操作数：”);
scanf(“%d %d”, &x, &y);
ret = (*p[input])(x, y);
printf(“ret = %d\n”, ret);
}
else if (input == 0)
{
printf(“退出计算器\n”);
}
else
{
printf(“输⼊有误\n”);
}
} while (input);
return 0;
}


运行结果如下：
image.png

* 10.const 修饰指针

10.1 const 修饰变量

变量是可以修改的，如果把变量的地址交给一个指针变量，通过指针变量的也可以修改这个变量。const 的作用就是对变量加上限制，使其不能修改。
如下：
image.png
上述代码中 b 是不能被修改的，其实 b 本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对 b 进行修改，就不符合语法规则，就报错，致使没法直接修改 b。
但是如果我们绕过变量 b，直接使用变量 b 的地址，就可以修改变量 b.
代码如下：

#include<stdio.h>
int main()
{
const int m = 0;
printf(“%d\n”, m);
int* p1 = &m;
*p1 = 20;
printf(“%d\n”, m);
return 0;
}


运行结果如下：
image.png
从上面我们可以看到 m 被修改了，cosnt 的作用就是是变量不被修改， 但是如果p1 拿到 m 的地址就能修改 m，这样就打破了 const 的限制，这是不合理的，所以应该让 p1 拿到 m 的地址也不能修改 m。

10.2 const 修饰指针变量

既然 const 修饰变量，仍然可以通过地址修改变量，那我们就直接 const 修饰指针变量试试。
代码如下：

#include <stdio.h>
//代码1
void test1()
{
int n = 10;
int m = 20;
int* p = &n;
p = 20;//ok?
p = &m; //ok?
}
void test2()
{
//代码2
int n = 10;
int m = 20;
const int p = &n;
p = 20;//ok?
p = &m; //ok?
}
void test3()
{
int n = 10;
int m = 20;
int const p = &n;
p = 20; //ok?
p = &m; //ok?
}
void test4()
{
int n = 10;
int m = 20;
int const const p = &n;
p = 20; //ok?
p = &m; //ok?
}
int main()
{
//测试⽆const修饰的情况
test1();
//测试const放在的左边情况
test2();
//测试const放在的右边情况
test3();
//测试的左右两边都有const
test4();
return 0;
}


结论：当 const 修饰指针变量时

  • const如果放在 * 的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。 但是指针变量本身的内容可变。

  • const 如果放在 * 的右边，修饰的是指针变量本身，保证了指针变量的内容不能修改，但是指针指向的内容，可以通过指针改变。

  • const 如果同时放在 * 的左右两端，那么指针指向的内容和指针变量的内容都不会被改变。

* 11.assert 断言

assert.h 头文件定义了宏 assert( ) ，用于在运行时确保程序符合指定条件，如果不符合，就报错终止运行。这个宏常常被称为“断言”。
其形式为：
image.png
上面代码在程序运行到这一行语句时，验证变量 p 是否等于 NULL 。如果确实不等于 NULL ，程序继续运行，否则就会终止运行，并且给出报错信息提示。
使用 assert( ) 有几个好处：它不仅能自动标识文件和出问题的行号，还有一种无需更改代码就能开启或关闭 assert( ) 的机制。如果已经确认程序没有问题，不需要再做断言，就在 #include <assert.h> 语句的前面，定义⼀个宏 NDEBUG 。
其形式如下：
image.png
然后，重新编译程序，编译器就会禁用文件中所有的 assert( ) 语句。如果程序又出现问题，可以移除这条 #define NDBUG 指令（或者把它注释掉），再次编译，这样就重新启用了 assert( ) 语句。
assert () 的缺点是，因为引入了额外的检查，增加了程序的运行时间。
⼀般我们可以在 Debug 中使用，在 Release 版本中选择禁用 assert 就行，在 VS 这样的集成开发环境中，在 Release 版本中，直接就是优化掉了。这样在debug版本写有利于程序员排查问题，在 Release 版本不影响用户使用时程序的效率。

* 12.typedef 关键字

typedef 是用来类型重命名的，可以将复杂的类型，简单化。
比如，如果我们觉得 unsigned int 太麻烦，想重命名成 uint,那我们可以使用：
image.png
对于指针类型我们也可以重命名，如 int* 重命名成 ptr_t :
image.png
但是对于数组指针和函数指针稍微有点区别：
比如我们有数组指针类型 int()[5] ,需要重命名为 parr_t ，那可以这样写：
image.png
函数指针类型的重命名也是一样的，比如，将 void()(int) 类型重命名为 pf_t ,就可以这样写：
image.png
举例说明：

#include <stdio.h>
int main()
{
int arr[3][5] = { 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7 };
//int(p)[5] = &arr;
typedef int( parr_t)[5];
parr_t p = &arr;
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf(“%d “, p[i][j]);
}
printf(”\n”);
}
return 0;
}


运行结果为：
image.png


本文为作者学习后的感悟与总结，如果有哪些知识点讲述的不全面，欢迎各位大佬指正。

未梦来
关注
  • 21
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言——借助指针实现数组元素的逆序.zip
07-13
C语言——借助指针实现数组元素的逆序.zip
C语言——指针详解（必收藏）
热门推荐
weixin_59174190的博客
04-04 7万+
1.什么是指针？ 1.1概念 简单的来说，指针就是地址。我们口头上说的指针其实指的是指针变量。指针变量就是一个存放地址的变量。 1.2指针的大小 指针在32位机器下是4个字节，在64位机器下是8个字节。注：（指针的大小与类型无关） 1.3指针类型的作用 上面涉及到指针的大小与指针类型无关，那么指针类型的作用是什么呢？ 指针解引用访问，使用的访问权限是多少 话不多说，上图！ 当一个int* 的指针+1，跳过4个字节；当一个char* 的指针+1，跳过1...
c语言——指针
最新发布
m0_59247951的博客
03-06 379
指针：通俗的讲就是运用存储单元的地址，来找储存单元的内容。
C语言——指针（进阶版）
weixin_59796310的博客
02-01 1万+
C语言——指针（进阶版）
C语言——指针和数组
Li27的博客
04-11 4381
理解指针的含义；掌握数组的使用；理解指针和数组的联系
C语言——指针移位4
weixin_65063745的博客
04-28 2930
指针的移位跟指向对象的数据类型有关 //例 int a = 10; //定义一个int类型的变量a，并且赋值10； int *p; //定义一个指针变量p，可以指向int类型的变量 char *q; //定义一个指针变量q，可以指向char类型的变量 p = &a; //p指向了a == 将a的地址赋值给了p q = p; //q也存了a的地址编号 printf("p = %d\n",p); //2017 printf("q = %d
C语言——指针运算
DSTBP的博客
12-13 2908
1. 赋值运算 2. 算术运算 3. 关系运算
C语言——指针之间的传递
weixin_45813589的博客
10-24 1414
C语言——指针之间的传递 基本概念 指针：一个变量的地址 指针变量：专门存放地址的变量 实验代码 int main() { int a = 10; int *p; int *q; p = &a; q = p; printf("p:%d q:%d \n",*p,*q); *q = 250; printf("p:%d q:%d \n", *p, *q); return 0; } 运行结果如下： 调试图如下： 由此可以看出，当更改q地址中存放的值时，p中的值也会改变，因为p、q均储
C语言——指针变量3
weixin_65063745的博客
04-26 2603
指针变量3
C语言——指针与函数
DSTBP的博客
12-14 2733
1. 传递指针给函数 2. 从函数返回指针 3. 指向函数的指针 4. 回调函数
C语言提高之——指针表达式
07-29
本文主要介绍C语言中指针表达式的内容，感性趣的朋友可以参考下。
C语言——数组与指针
07-07
一個關於C语言——数组与指针的基本教程，簡單而實用
C语言——例题
08-25
例1-写一个函数，输入一行字符，将此字符串中最长的单词输出。 例2-建立一个对象数组，内放5个学生的数据（学号、成绩），用指针指向数组首元素，输出第一、三、五个学生的数据。
C语言笔记——文件指针.docx
11-29
C语言笔记——文件指针
彻底搞定C语言指针————
03-19
详细的讲述了C语言指针指针的用法 彻底搞定C语言指针————————————
C语言——我眼中的指针
08-29
该电子书摘自网上文章整理完成，有关C指针的一些心得，适合初学者，值得一看。
由浅入深学C语言——基础、进阶与必做430题.崔久,蒋欣(带详细书签)
04-01
第2篇是C语言技术进阶，包括数组、指针、函数、结构型、共用型、枚举型和用户自定义类型；第3篇是C语言高级应用，包括算法、预编译命令、文件和图形，以及预处理命令等内容；第4篇是C语言开发案例，详细讲解了C语言...
嵌入式C语言——sscanf函数使用技巧
05-17
sscanf函数是C语言中一个非常常用的函数，它可以将一个字符串按照指定的格式转换成相应的数据类型。在嵌入式开发中，sscanf函数也是非常常见的，因为很多时候需要从串口或者其他外部设备中读取数据，并将其转换成...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值