C语言学习专栏 on My_blog

C语言的分支与循环上

Tue, 18 Aug 2026 00:00:00 +0000

if语句

在if语句中他的语法是if(表达式)

语句

表达式成立那么语句执行，不成立那么语句不执行。

在if语句中只要是true就执行，false不执行。

那么true通常是1，而false则是0，比如nun%2==1，它执行的是判断num是否是奇数，其实这样写也可以，但是不是更很直观

没有前者更加直观一些。

在if语句中if语句只可以跟着一条语句，但是如果过于多的话可以调整为大括号

由此我们可以知道这样的道理，else是在一些情况可以省略的，不必再写像

if(num%2)

printf("%d 是奇数"，num);

printf("%d 是偶数",num);

C语言之操作符（上）

Tue, 18 Aug 2026 00:00:00 +0000

C语言之操作符（上）

在C语言之中，操作符也是极其重要的，不不仅仅C语言会用到，同时最为关键的是学会操作符，会对于我们学习单片机起到奠基石的作用，对于单片机的学习起到引领的作用，会非常有助于我们学习单片机的，会让我们对于单片机的一些基础操作可以看的懂。

一.二进制，八进制，十六进制

在计算机当中信息是以二进制的形式存储的，而我们在日常生活当中使用的最为多的，其实就是十进制，然而我们对于十进制的转化可以说是手到擒来。但是对于二进制相信一些伙伴，连听都没有听过，更不要说二进制之间的转化，不同进制之间的转化。由于二进制表达的数字太过于庞大了，我们不习惯使用二进制，因此我们需要学习八进制，十六进制，在接下来的讲解中我将为大家娓娓道来，并力求做到，看过我写的便学会，懂得了。

`1.二进制`

1.首先，需要注意的是，二进制是什么。二进制是是计算机在存储信息之中时以1，0对信息加以存储和表达，满2进1对的。 2.其次我们需要注意的是，二进制的转化： 1.二进制同十进制之间的转化：首先需要明确一下的是权重，求值，以十进制数字：123为例。

10进制的位	1	2	3
权重	10^2	10^1	10^0
权重值	100	10	1
求值	1*100	2*10	3*1 =	123

1.由此可以看出，权重，权重值,的关系，对这个概念可以运用到二进制·之上，对于二进制数如：110.

二进制的位	1	1	0
权重	2^2	2^1	2^0
权重值	4	2	1
求值	4*1	2*1	0*1=	6

2.这样我们就完成了对二进制与十进制数相互进行转化。而对于十进制数转化为二进制数字，比如说一个十进制数字125将他转化成二进制数字，可以采用短除法，具体操作如下：

C语言之操作符【下】

Tue, 18 Aug 2026 00:00:00 +0000

在上一节中，我们已经学习了操作符的一些相关知识，我们对C语言的操作符有了新的认识与理解，那么在本节C语言中，我们将继续上一次的讲解，为大家呈现更加有趣并且深刻的讲解，来开启我们的操作符之旅吧！

一.下标访问[],函数调用()

1.下标访问[]

1.什么是下标访问[]

1.在C语言学习中，我们会经常用到下标访问操作符，那么相信在屏幕前的你们一定很想知道什么是下标访问操作符吧？下面我就为大家详细的道来：其实下标访问操作符，是数组里面的一个知识点，下标访问操作符是数组遍历当中经常使用的，数组在遍历[]里面会有一些数字，而那些数字其实就可以表示数组的内容，因此就可以对数组进行遍历了。 2.形式是[]里面的数字从数字0开始，到最后的数字结束。

2.下标访问操作符[]的应用与举例

1.下标访问操作符的应用：下标访问操作符，应用到数组当中，对于数组内容的访问有着极其重要的意义。 2.下标访问操作符的举例：如在下面的函数当中，我们就用到了下标访问操作符。

#include<stdio.h>
int main()
{
int a[5]={1,2,3,4,5};
for(int i=0; i<5;i++)
printf("%d",a[i]);
return 0;
}

3.在上例当中，a[i]里面的i其实就是数组里面的内容，它的意思是说数组里面的的i-1个元素，因此我们通过这个方法对其进行遍历。

2.函数调用()

1.函数调用操作符是小括号。 2.形式如下：

int add(int x,int y);

在上例之中，小括号之前的是，函数名；在小括号之后的是形参，可以看出该函数有两个形参：一个是int x，另一个是int y，该函数的返回类型是int形。

二.操作符的属性：优先级、结合性

1.优先级

1.每种同类型的运算符都有内部的运算符优先级，不同类型的运算符之间也有相应的优先级顺序。一个表达式中既可以包括相同类型的运算符，也可以包括不同类型的运算符或者函数。当多种运算符出现在同一个表达式中时，应该先按照不同类型运算符间的优先级进行运算。各种运算符间的优先级如下：数值运算符、字符串运算符、关系运算符、逻辑运算符。可以用括号改变优先级顺序，使得括号内的运算优先于括号外的运算。对于多重括号，总是由内到外强制表达式的某些部分优先运行。括号内的运算总是最优先计算。 2.操作符的优先级如下：

2.结合性

结合性是，对于多个优先级是一样的操作符的一个表达式，此时他们的就需要用到，结合性，如下：

2*3/5

此时他们的优先级是一样的，因此我们选择使用结合性，因为，乘法和除法的结合性是做结合的因此该表达式是从左到右计算的。

3.俩者之间的应用

因为在上文的优先级表格中，小括号的优先级是最高的，使用小括号可以提高算术的优先级。因此呢，当有一些表达式的优先级是一样的时候，我们就可以使用小括号，这样小括号括起来的地方，优先级是比较高的，可以达到我们想要的结果

三.整型提升

1.整型提升

C语言中整型算术运算总是至少以缺省整型类型的精度来进行的。为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型,这种转换称为整型提升。

2.整形提升的意义

整型提升的意义是在表达式中，各种长度可能小于int长度的整型值，都必须先转换为int或unsigned int，然后才能送入CPU去执行运算12。C的整型算术运算总是至少以缺省整型类型的精度来进行的。为了获得这个精度，表达式中的字符和短整型操作数在使用之前被转换为普通整型，这种转换称为整型提升。比如：即使两个char类型（1个字节==8个比特字节）的相加，在CPU执行时实际上也要先转换为CPU内整型操作数的标准长度.

C语言之讲解篇

Tue, 18 Aug 2026 00:00:00 +0000

例题：

下面代码的结果是：
#include <stdio.h>
int i;
int main()
{
i--;
if (i > sizeof(i))
{
printf(">\n");
}
else
{
printf("<\n");
}
return 0;
}

A.>

B.<

C.不输出

D.程序有问题

首先，我可以明确一点的是，这道题不选择D和C，在本函数中，由于int i 是一个全局变量，它存放的是静态区，

C标准是要求全局变量要被初始化为零值，因此即使你没有初始化该值那么依然会被系统初始化为0，然而，sizeof类型是属于unsigned int 类型，也就是说，-1需要进行一拨转换，然而-1转换为无符号整形数字是比较大的，那么的话，明显是>,那么就选则的是A

C语言之讲解篇2

Tue, 18 Aug 2026 00:00:00 +0000

例题：获取一个整数二进制序列中所有的偶数位和奇数位，分别打印出二进制序列。

对于这个题我想的是，由于1&二进制的数字，他的意思是判断最低位是否为1，是的话那么就是1，否则就不是1而是0，这样如果我在进行一番右移操做，那么的话，就可以把这个二进制打印出来。

若是需要奇偶位打印的话，那么可能是在每次右移奇数个位或者是偶数个位，就可以求出二进制的奇数位，以及偶数位，下面我就为大家展示一番。

#include<stdio.h>
int main() {
int num = 0;
printf("请输入一个数:");
scanf("%d", &num);
printf("奇数位：");
for (int i = 31; i >= 1; i -= 2) {
printf("%d ", (num >> i) & 1);
}
printf("\n");
printf("偶数位：");
for (int i = 30; i >= 0; i -= 2) {
printf("%d ", (num >> i) & 1);
}
printf("\n");
return 0;
}

这个是运行结果：

因此这就是本题的代码。

C语言之讲解篇3

Tue, 18 Aug 2026 00:00:00 +0000

例题：求两个数二进制中不同位的个数，写出C代码。

在我的讲解篇2中可以看到：由于每次右移1位并对1按位与那么就可以将二进制位分离出来，得出与原来一样二进制位。

思路一样，那么我们可以用上一篇中提到的方法，那么接下来我们就需要对每个二进制位进行比较就可以了，以此类推，若是不同的话统计其个数并将其统计的个数，返回，所求的便是其值，我所写的代码，如下：

#include<stdio.h>
int main()
{
int x = 0;
int y = 0;
int count = 0;
printf("输入两个整数:");
scanf("%d %d", &x, &y);
for (int i = 0; i < 32; i++)
{
if (((x >> i) & 1) != ((y >> i) & 1))
{
count++;
}
}
printf("有:%d位数不同", count);
return 0;
}

下面是我的代码的运行结果：

C语言之讲解篇4

Tue, 18 Aug 2026 00:00:00 +0000

例题：

下面代码的结果是：（ ）
#include <stdio.h>
int main()
{
int arr[] = {1,2,3,4,5};
short *p = (short*)arr;
int i = 0;
for(i=0; i<4; i++)
{
*(p+i) = 0;
}
for(i=0; i<5; i++)
{
printf("%d ", arr[i]);
}
return 0;
}

由于short是短整型的，那么其，因此p每次只能得到两个字节，而由于原来是4次循环那么其实是相当于4/2=2个数，也就是说对原来的前两个数赋值为0，那么打印出来得话，自然是：0,0，3,4，5

C语言之讲解篇5

Tue, 18 Aug 2026 00:00:00 +0000

例题：

下列程序段的输出结果为（ ）
unsigned long pulArray[] = {6,7,8,9,10};
unsigned long *pulPtr;
pulPtr = pulArray;
*(pulPtr + 3) += 3;
printf("%d,%d\n",*pulPtr, *(pulPtr + 3));

解释：pulPtr已经是数组的首元素6，而*(pulPtr + 3)是指针向后移动3位所得到的结果，同时把该结果再加上3所得的值是12，接下来再把12赋值给*(pulPtr + 3)，然后由于指针是数组的首地址那么的话，*pulPtr就是6，而(pulPtr + 3)自然就是12，接下来我们就可以选择6 12了，本题11就这样结束了。

C语言之讲解篇6

Tue, 18 Aug 2026 00:00:00 +0000

例题：实现一个函数，可以左旋字符串中的k个字符，用C语言写出。

每次可以把第一个字符存下来，接下来可以以此把每个字符向前移动一个位置，最后把最后一个字符赋值为刚开始存下的值，这样每次做到的就是翻转就是一个字符，那么将总共的大循环，设定为翻转得个数，那么就可以轻轻松松解决问题了，下面是我的代码示例：

#include<stdio.h>
#include<string.h>
void programming(char * a,int n,int num);
int main()
{
char num[50];
int n,a;
printf("请输入一些内容：\n");
gets(num);
a=strlen(num);
printf("请输入你n的数值\n");
scanf("%d",&n);
printf("左旋字符串中的n个字符\n");
programming(num,n,a);
printf("%s\n",num);
return 0;
}
void programming(char * a,int n,int num)
{
int i=0;
char temp;
for(i=0;i<n;i++)
{
temp=*a;
for(int j=0;j<num-1;j++)
*(a+j)=*(a+1+j);
*(a+num-1)=temp;
}
}

该代码的运行结果，是如下：

C语言之讲解篇7

Tue, 18 Aug 2026 00:00:00 +0000

例题：写一个函数，可以逆序一个字符串的内容。

#include <stdio.h>
void reverse(char * letter);
int main()
{
char num[50];
int i;
while(num[i]!='\0')
{
scanf("%c",&num[i]);
i++;
}
reverse(num);
return 0;
}
void reverse(char * letter)
{
char * start=letter;
while(*letter!='\0')
{
letter++;
}
while(letter>=start)
{
printf("%c",*letter);
letter--;
}
}

在这里我们看到用循环设定指针的最大者似乎效率不是很高，那么我们可以使用这个语句：strlen()用他求出字符串的最大值，最后再赋值给指针似乎就完美了：

/*
思路：该题比较简单，请参考代码
*/
#include<stdio.h>
void Reverse(char* str)
{
char* left = str;
char* right = str + strlen(str)-1;
while(left < right)
{
char temp = *left;
*left = *right;
*right = temp;
++left;
--right;
}
}
int main()
{
char str[] = "hello bit";
//在这里完成下面函数，参数自己设计，要求：使用指针
Reverse(str);
return 0;
}
// 注意：如果是在线OJ时，必须要考虑循环输入，因为每个算法可能有多组测试用例进行验证，参考以下main函数写法，
int main()
{
char str[101] = {0};
while(gets(str))
{
Reverse(str);
printf("%s\n", str);
memset(str, 0, sizeof(str)/sizeof(str[0]));
}
return 0;
}

接下来本题就宣告结束了。

C语言之讲解篇8

Tue, 18 Aug 2026 00:00:00 +0000

例题：

输入一个整数数组，实现一个函数，来调整该数组中数字的顺序使得数组中所有的奇数位于数组的前半部分,所有偶数位于数组的后半部分。

1.首先设置一个逆序输出的函数。

由于他们是没有任何返回值的因此呢，我们可以设定一个没有一个返回值的函数，同时还需要做到，对原来的函数进行修改，因此我们考虑使用数组或者指针。所以结合以上，所设置的函数可以是：

void swap_arr(int arr[], int sz);

2.其次呢再设定两个变量，left,right.

1.left,right的初始化

在这里，我们首先可以假定left是数组的最小者，而right是数组的最大者，由于数组的小标是从0开始的那么最大者就是数组的长度减去1，而求数组的长度就可以使用sz，那么的话，最大者就是：sz-1

left 0;
right sz-1;

2.left与right的具体实现

1.left的具体实现

是通过遇到偶数时停止循环造成的。

1.left的的执行功能

left首先是定义为寻找奇数，而遇到偶数时就停止循环，并将那个偶数带回到left身上。

2.实现操作与基本逻辑

我们可以通过循环来实现，在众多的循环当中我们可以选择的是，while循环而循环条件就是小标为left的数组，是奇数并且保证left<=right，当其为偶数时就跳出循环。

基本语句如下：

while(left<right)
{
// 从前往后，找到一个偶数，找到后停止
while((left<right)&&(arr[left]%2==1))
{
left++;
}
}

2.right的具体实现

是通过遇到奇数时停止循环造成的。

1.right的的执行功能

right首先是定义为寻找偶数数，而遇到奇数时就停止循环，并将那个偶数带回到right身上。

2.实现操作与基本逻辑

我们可以通过循环来实现，在众多的循环当中我们可以选择的是，while循环而循环条件就是下标为right的数组，是偶数并且保证left<=right，当其为奇数时就跳出循环。

基本语句如下：

while((left<right)&& (arr[right]%2==0))
{
right--;
}

3.最后是left,ritht的交换与现实

最后我们将这些整合在一起，得到了函数并将left,right进行交换，由于left是偶数，right是奇数俩者交换，求出则为奇数在前偶数在后，函数完整的代码如下：

void swap_arr(int arr[], int sz)
{
int left = 0;
int right = sz-1;
int tmp = 0;
while(left<right)
{
// 从前往后，找到一个偶数，找到后停止
while((left<right)&&(arr[left]%2==1))
{
left++;
}
// 从后往前找，找一个奇数，找到后停止
while((left<right)&& (arr[right]%2==0))
{
right--;
}
// 如果偶数和奇数都找到，交换这两个数据的位置
// 然后继续找，直到两个指针相遇
if(left<right)
{
tmp = arr[left];
arr[left] = arr[right];
arr[right] = tmp;
}
}
}

3.最后就可完成函数了。

将函数部分搞定之后我们就可以，把整个代码搞定了，如下：

C语言之扫雷游戏

Tue, 18 Aug 2026 00:00:00 +0000

C语言之扫雷游戏

1.扫雷游戏的准备工作

在进行扫雷工作时，我们需要做的是需要一个编译环境，在市面上有众多的编译器，在这里作为使用过VS的我来说，它简直太适合我们这样的初学者了，里面支持自动换行对于初学者非常友好，同时，最为关键的是，在这款编译器当中，我们使用调试功能，是极其的容易，并且它的调试功能也是极其强大的。写到最后，我推荐大家观看B站鹏哥的视频，在那里鹏哥会给我们最为直观的讲解，会非常详细的指导大家的。

2.扫雷游戏的基本逻辑

一.扫雷的基本框架

在扫雷游戏中时，首先需要我们在VS编译器当中准备三个文件，二个C文件一个头文件： 在这里大家可以参考一下我准备的文件

二. 扫雷游戏的基本逻辑

1.在C语言扫雷游戏之中，需要注意的是扫雷游戏时在选定的区域的附近八个点位统计雷的个数并输出在选定的区域之上，但是若果选定的区域是边上亦或是角上，那么就会导致无法遍历，超出应有的范围，这个问题我们可以假设棋盘的大小是9x9然而总共数组的大小可以设定11x11那么，就不是解决了问题吗？ 2.扫雷的基本思路是首先需要准备2个字符数组，一个数组存放排查出的雷的数量信息记录存储，并打印出来，而另一个数组则存放布置好雷的信息，这样就互不干扰了 3.同时为了保持神秘，show数组开始时初始化为字符 ‘*’，为了保持两个数组的类型一致，可以使用同一套函数处理，mine数组最开始也初始化为字符’0’，布置雷改成’1’。如下如：

三.扫雷需要的所有函数

对于扫雷的实现需要用到，大量的函数，在这里我将为大家呈现出应当使用的具体函数：

1.定义初始化函数

首先我们需要一个初始化棋盘的函数，而对于二个棋盘,一个接受‘0’的初始化，而另一个则接受‘*’的初始化，像这样的函数：

void InitBoard(char board[ROWS][COLS], int rows, int cols, char set)
{
int i = 0;
for (i = 0; i < rows; i++)
{
int j = 0;
for (j = 0; j < cols; j++)
{
board[i][j] = set;
}
}
}

2.定义打印棋盘函数

1.在使用中，我们需要看到棋盘显示在电脑上，那么显而易见的是我们可以使用打印棋盘这个函数。

C语言之指针篇第五

Tue, 18 Aug 2026 00:00:00 +0000

在本讲中，我们将会详细的学习sizeof以及strlen的区别，同时呢我也会为大家讲一些经典面试题，相信大家在看过我的本讲之后，一定会对指针有更加深刻的认识与了解，下面就开启我们的指针之旅吧。

C语言之指针篇第五

一.sizeof和strlen的对⽐

首先在学习中时，我们通常会经常遇到sizeof，以及strlen函数，我们在使用时经常会分不清sizeof以及strlen，我们经常会用着用着，将两个函数用颠倒，大家对此简直是苦不堪言，因此呢，我将用这节为大家详细介绍两者区别，相信大家在听过我的讲解之后，一定会在今后的学习中，对两者运用的更加之熟练。

1.sizeof

1.sizeof含义

sizeof 主要计算的是变量所占内存内存空间⼤⼩的，单位是字节，如果操作数是类型的话，计算的是使⽤类型创建的变量所占内存空间的⼤小，sizeof 只关注占⽤内存空间的⼤⼩，不在乎内存中存放什么数据。

2.例子：

int a=1;
sizeof(a);//因此呢，算出的数值是4.

又有例子：

int a=4;
int * s=&a;
sizeof(s);//可以看出由于地址的存储在内存中是64根地址线或者是32根地址线因此地址无论是整形或者是字符型亦或者是数组型
//它们其实都是4或者8

2.strlen

1.strlen的含义

它的功能是，求字符的长度，遇到‘\0’则停止，否则会在内存中找到‘\0’,这样才会停下来，如此一番，求出的则是随机值。

2.例子

char a="hello bit";
int a=strlen(a);//由于“”省略了\0，因此求出的是8
又有例子：
char a[]={'hello','bit'};
int a=strlen(a);//在这里，由于没有设置‘\0’,那么的话，结果就有可能是随机值。

二.数组指针笔试题解析

例题1：

int a[] = {1,2,3,4};
printf("%d\n",sizeof(a));//sizeof加数组名指的是整个数组的大小，也就是说打印出来的是16.
printf("%d\n",sizeof(a+0));//在这里的意思是，数组的首元素的地址而地址的大小则是4或者8，因此打印出来的是4或者是8
printf("%d\n",sizeof(*a));//在这里指的是数组的首元素，因此答案也就是4
printf("%d\n",sizeof(a+1));//在这里的意思是数组的第二个元素的地址也就是说答案是4或者是8.
printf("%d\n",sizeof(a[1]));//这里是数组的第二个元素，也就是说答案是4
printf("%d\n",sizeof(&a));//这里是数组的地址，也就是说是4或者是8.
printf("%d\n",sizeof(*&a));//注意*&相当于没有因此该式子也就是sizeof(a)，注意是16
12345678
printf("%d\n",sizeof(&a+1));//在这里的意思是指向数组的后面的地址，也就是4或者是8
printf("%d\n",sizeof(&a[0]));//这里是首元素的地址，是4或者是8
printf("%d\n",sizeof(&a[0]+1));//是第二个元素的地址是4或者是8.

例题2：

char arr[] = {'a','b','c','d','e'};
printf("%d\n", sizeof(arr));//由于没有‘\0’那么的话，就是5
printf("%d\n", sizeof(arr+0));//这里是首元素的地址，那么是4或者是8
printf("%d\n", sizeof(*arr));//是首元素那么就是1
printf("%d\n", sizeof(arr[1]));//在这里也是首元素，那么是1
printf("%d\n", sizeof(&arr));//这里是数组的地址是4或者是8
printf("%d\n", sizeof(&arr+1));//这里是在数组之后的地址，也就是4或者是8
printf("%d\n", sizeof(&arr[0]+1));//是第二个元素地址是4或者是8

char arr[]="abcdef”；
printf("%d\n",strlen(arr));//这里是说字符串的长度是6
printf("%d\n",strlen(*arr);//在这里会出错。
printf("%d\n",strlen(arr[1]));//在这里也会出错
printf("%d\n",strlen(&arr));//是6
printf("%d\n",strlen(&arr+1));//这会跳出这个数组，应该是0
printf("%d\n",strlen(&arr[0]+1));//这里第二个元素的地址是5

完（。）

C语言指针篇第一

Tue, 18 Aug 2026 00:00:00 +0000

从这一节开始，我们就要开启学习指针之旅，我将此次指针的学习分为5次，今天是第一次学习，在学习指针的时候我们必定会遇到许多困难与挑战，我们会遇到一些比较抽象的概念，也会遇到一些复杂的代码，不管如何，我们能做的只有坚持，坚持只有这样，我们才可以真正搞懂所谓的指针，明白指针的确实含义，来开启我们今天的指针学习吧，亲爱的同学们！

C语言指针篇第一

首先呢，我将为大家介绍有关地址的知识点，接下来我们会学习到指针的运算，以及使用。

1. 内存和地址

1.内存与地址的介绍

1.在宾馆当中，我们若果需要寻找需要的人时，在不知道对方的房间号时，我们能够做的是，一个房间一个房间挨着寻找，虽然这样可以找到我们需要的人，但是需要注意的是。这样寻找，注定了它的效率是不高的，是低效率的，因此呢，若果我们知道对方的房间号时，那么找到对方是一瞬间的事情。 2.在计算机中，信息也是按照宾馆，按照宿舍存储的，在计算机中信息是以字节为单位，这个字节就有点像宿舍，一个宿舍存储8个人，而一个字节有八个比特位，这样只要我们知道信息的房间号，在计算机中我们常说的是地址—-指针—内存单元的编号，我们就可以迅速的找到这个信息。 3.若果在32为环境下，地址是按照32位地址线发出电信号，进行编码的，此时地址拥有32个比特位，也就是说地址有4个字节 4.但是，若果在64位的环境下，那么就是地址按照64个地址线编码的，此时地址拥有64个比特位，也就是说地址现在拥有，8个字节。

2.地址的一些性质

1.首先，在相同环境之下，地址的大小都是一样，要么是4个字节，要么是8个字节，这个同地址（指针）的类型是无关的。 2. 指针是有类型的，有字符型，整型，数组类型。 3. 在计算机存储当中时，是按照字节进行存储的，整型的话是4个字节，字符型是一个字节。

2. 指针变量和地址

以下我们即将学到，操作符&，以及解引用操作符*，以及我们会学习到，指针的大小如何比较，下面就开启我们的学习之旅吧！

1.取地址操作符（&）

首先呢，我们举一个例子：

int a=12;
int * pr=&a;

在上例中，我们可以看到，按位与操作符加在变量之前就变成了，取地址操作符，通过以上代码，我们可以发现，我们使用了指针变量加以接收，a的地址，现在把a的地址就存储到pr当中了，通过上例的举出，大家对于取地址操作符，有新的了解与认识吗？似乎，没有非常的困难的样子，下面我就为大家开启以下的重头戏，上面只是本个知识点的开胃菜，下面才是真正的硬菜。

2.指针变量和解引⽤操作符（*）

在下面我即将会学习到，解引用操作符以及指针变量，这个我希望大家可以认真，听我的讲解，来开启这个知识点的学习吧！

数据结构链表当中的头结点问题

Tue, 18 Aug 2026 00:00:00 +0000

数据结构链表当中的头结点问题

1. 示例举证

出现的什么例子（单链表的表头节点）

首先呢，我是在牛客网上做关于反转链表的操作，然后呢，做完之后，自己又把里面的具体的代码都写了一下，有打印，输入都有，这就是背景摘要。

给出自己原来写的代码及源码

下面我将给出大家我首先第一次写的代码如下：

#include <stdio.h>
#include <stdlib.h>
// 定义链表节点结构
struct ListNode {
int value;
struct ListNode* next;
};
// 反转链表函数
struct ListNode* reverseList(struct ListNode* head) {
struct ListNode* prev = NULL;
struct ListNode* current = head;
struct ListNode* nextNode = NULL;
while (current != NULL) {
nextNode = current->next; // 暂存下一个节点
current->next = prev; // 反转当前节点的指针
prev = current; // 前移 prev
current = nextNode; // 前移 current
}
return prev; // 返回新的头节点
}
// 辅助函数，用于创建新节点
struct ListNode* createNode() {
struct ListNode* head; // 初始化头节点为空
head=(struct ListNode*)malloc(sizeof(struct ListNode));
head->next=NULL; // 用于记录链表的尾节点
int x; // x为链表数据域中的数据
while (scanf("%d", &x) != EOF) {
struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
newNode->value = x;
newNode->next =head->next; // 将新节点链接到尾节点之后
head->next=newNode; // 更新尾节点
}
return head;
}
// 辅助函数，用于打印链表
void printList(struct ListNode* head) {
struct ListNode* current = head;
while (current != NULL) {
printf("%d -> ", current->value);
current = current->next;
}
printf("NULL\n");
}
// 辅助函数，用于释放链表内存
void freeList(struct ListNode* head) {
struct ListNode* current = head;
while (current != NULL) {
struct ListNode* next = current->next;
free(current);
current = next;
}
}
// 主函数，用于测试反转链表
int main() {
// 创建链表
printf("请输入链表节点值，以EOF结束：\n");
struct ListNode* head = createNode();
printf("原链表: ");
printList(head);
// 反转链表
struct ListNode* reversedHead = reverseList(head);
printf("反转后的链表: ");
printList(reversedHead);
// 释放内存
freeList(reversedHead);
return 0;
}

2.出现的问题

出现的问题呢就是在运行的时候，会在尾结点多出一个异常节点，当时我很懵逼，不知道，究竟错在什么地方了，然后，我以为我自己抄错了代码，然后有检验了一番，发现依旧是如此的，当时我真的很崩溃，不知道如何是好，我想到我是否可以在淘宝上面，问一下上面的大佬，花个10元，但是又觉得不值得，下面就是我的解决的经过之路

整数和浮点数在内存中存储

Tue, 18 Aug 2026 00:00:00 +0000

大家好，今天我为大家介绍关于整数与浮点数在内存中的存储，我们通过今天的讲解一定会更加理解浮点数的储存模式，更好修炼大家的内功，来开启我们的学习之旅吧！

整数和浮点数在内存中存储

1.整数与浮点数在内存中存储是否一样

首先我们大家都有一个疑问，在内存中数据的存储不都是以二进制形式存储的吗？还有什么不同呢？其实我在学习本节课之前我和大家的认知是一样的，都是认为他们的存储都是一样的，但是今天我可以告诉给大家，在内存中存储其实并不一样，下面我为大家详细的介绍一下。

整数与浮点数在内存中存储的例子

下面我为大家举出一个关于他们在内存存储的例子，如下：


int main()
{
int n = 9;//整型的存储方式，补码
//00000000000000000000000000001001 9的补码
//
float* pFloat = (float*)&n;
printf("n的值为：%d\n", n);//9
printf("*pFloat的值为：%f\n", *pFloat);
//0 00000000 00000000000000000001001
//E 为全0
//(-1)^0 * 0.00000000000000000001001 * 2^-126
//1*
//0.000000
*pFloat = 9.0;
//1001.0
//(-1)^0 * 1.001*2^3
//S=0
//M=1.001
//E = 3
//01000001000100000000000000000000
//
printf("num的值为：%d\n", n);
printf("*pFloat的值为：%f\n", *pFloat);//9.0
return 0;
}

大家觉得这个会是多少呢？我想大家所想的可能会和标准运行结果会有差距，那么的话，下面我就为大家介绍一下，这个程序的运行结果：是9,0，1091567616，9.0 因此我们可以知道，浮点数在内存中的存储与整数是不一样的，存储原理是不同的，那么为何会造成这种不同呢？下面我就为大家介绍一下，他们存储的具体实现。

字符串中删除后导星号的问题

Tue, 18 Aug 2026 00:00:00 +0000

字符串中删除后导星号的问题

一.题目分析

二.我所犯的错误

2.1我的代码

#include <stdio.h>
void fun( char *a )
{
int count=0,count_a=0,i,j=0;
while(*a!='\0')
{
a++;
count++;
}
a=a-1;
while(*a=='*')
{
a--;
count_a++;
}
for(i=0;i<count-count_a;i++)
{
a[j++]=a[i];
}
a[j]='\0';
}
main()
{ char s[81];void NONO ();
printf("Enter a string:\n");gets(s);
fun( s );
printf("The string after deleted:\n");puts(s);
NONO();
getchar();
}
void NONO ()
{/* 本函数用于打开文件，输入数据，调用函数，输出数据，关闭文件。 */
FILE *in, *out ;
int i ; char s[81] ;
in = fopen("in.dat","r") ;
out = fopen("out.dat","w") ;
for(i = 0 ; i < 10 ; i++) {
fscanf(in, "%s", s) ;
fun(s) ;
fprintf(out, "%s\n", s) ;
}
fclose(in) ;
fclose(out) ;
}

2.1我的错误的代码运行的结果

字符函数和字符串函数

Tue, 18 Aug 2026 00:00:00 +0000

在本节中我将为大家介绍一些关于字符函数以及字符串函数，在本节中我将为大家详细介绍某些重要函数的模拟实现，使大家更好的了解这些函数的具体逻辑，下面就开启了本次的学习之旅，希望大家都有所收获。

字符函数和字符串函数

一.字符函数

字符是组成字符串的根本，那么学好字符函数对我们今后的学习起到了重要的作用，而在众多的字符函数当中有两种类型一个是判断的那种函数也就是字符分类函数，另一种则是转化大小写的那种，下面就为大家具体的诠释其中的奥妙。

1.字符分类函数

1.字符分类函种类及作用

iscntrl	判断是否输入控制字符
isspace	输入空白字符返回真
isdigit	输入数字字符返回真
isxdigit	输入16进制数字字符返回真
islower	输入小写字符返回真
isupper	输入大写字符返回真
isalpha	输入字母字符返回真
isalnum	输入数字或者字母字符返回真
ispunct	输入标点字符返回真
isgraph	输入图形字符返回真
isprint	输入可打印字符返回真

2.字符转换函数

字符转化函数具体有，大写字符转化成小写字符，另有小写字符转化为大写字符，当然这些都是针对的是输入的是字母字符时方可使用的，但是若果使用的是非字母字符那么的话可能会导致错误，从而程序无法运行。

1.字符转换函数包括哪些

1.大写字符转化为小写字符

1.大写字符转化为小写字符函数的具体诠释

形如以下形式：

int tolower ( int c );

给大家举出一下例子，我们一起看一下：

#include <stdio.h>
#include <ctype.h>
int main ()
{
int i=0;
char str[]="Test String.\n";
char c;
while (str[i])
{
c=str[i];
putchar (tolower(c));
i++;
}
return 0;
}

当然这样写没有什么问题，但是我们也可以这样子写如下：