前言
本周学习了c语言的数据类型、运算符、控制流和数组的部分知识，本文中通过很多程序举例来帮助我们更好的理解知识点。本周学习内容较多，一些点会简述，基本上通过程序举例说明都可以理解，如果有什么疑问或者发现了错误欢迎留言，我会积极回复并改正完善的。
数据类型
类型转换
#include <stdio.h>
int main(int argc, char const *argv[])
{
/*
int b = 65;
char a = (char)b;//强制类型转换，将b转换为字符
printf("%c\n",a);
*/
char a = 'a；//隐式类型转换
int b = 100;
float c = 3.14;
char d = a + b + c;// 内存越界
int e = a + b + c;// 丢精度
float f = a + b + c;// 正确
printf("%f\n",f);
return 0;
}
- 强制类型转换可能会丢精度
数据类型的本质
- 概念：各种不同的数据类型，本质上是用户与系统对某一刻内存数据解释，不一定有意义
整型数据尺寸
short不可比Int长
long不可比int短
long型数据长度对于系统字长（32位操作系统（232）4字节，64位操作系统占用（264）8字节）
可移植性数据类型
#include <stdio.h>
// 给变量取别名称为可移植数据类型
typedef char int8_t;
typedef unsigned char unit8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef int int32_t;
typedef unsigned int uint32_t;
int main(int argc, char const *argv[])
{
int8_t a = 'p';
printf("%c\n",a);
return 0;
}
- 有时候我们需要使用int32_t类型变量代替int类型变量的原因是什么?
使用int32_t类型变量代替int类型变量的原因有以下几点：
- 平台无关性：int类型在不同平台上的长度可能不同，而int32_t类型是一个固定长度的整数类型，保证了代码在不同平台上的可移植性。
- 数据精度：int类型的长度在不同平台上可能不同，可能会导致数据溢出或截断。而int32_t类型是一个32位的整数类型，可以确保数据的精度和范围。
- 代码清晰性：使用int32_t类型可以明确表达变量的长度和范围，使代码更加清晰易懂。
- 与特定硬件相关的操作：在一些特定的硬件操作中，需要使用特定长度的整数类型，使用int32_t类型可以确保与硬件的兼容性。
总之，使用int32_t类型可以提高代码的可移植性、数据精度和代码清晰性，适用于需要固定长度整数类型的场景。
- int是系统基本的数据类型，其长度在不同平台下的大小尺寸是有区别的，为了使用同一份代码能够在不同的操作系统下面运行，并且尺寸不发生改变，一般使用类似与int32_t这样的可移植类型来定义数据，这些类型是不同平台下的对基本数据类型的封装，然后统一发布，这些移植的数据类型一般是放在头文件中，比如/usr/include/stdin.h
运算符
目：目标操作数
双目运算符
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char const *argv[])
{
int a = 20;
int b = 5;
int e = b * a;
printf("sun = %d\n",e);
int f = b / a; //除
printf("sum = %d\n",f);
int g = b % a;// 取余，在限制一个范围内使用的场景较多
printf("sum = %d\n",g);
return 0;
}
取余的运用场景
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(int argc, char const *argv[])
{
//通过时间参数随机因子
srand(time(NULL));
//产生一个随机数
int ret = rand() % 10;// %10：控制在0~9
printf("%d\n",ret);
return 0;
}
取余时左右两边操作数必须是整数
单目运算符
int a = 10;
int b = ++a;// 先自加1--》a==11再赋值给b
int c = a++;// 先将a的值赋给c再自加1
#include <stdio.h>
int main(int argc, char const *argv[])
{
int a = 10;
int b = 20;
int c = ++a;// a先自加再赋值给c
int d = b++;//b先赋值给d再自加
printf("%d,%d,%d,%d\n",a,c,b,d);
int e = 2;
int x = (e++)+(e++);// 错误的写法，两个单目运算符不能进行双目运算
printf("x:%d,e:%d\n",x,e);
int b1 = 2;
int y = (b1++)+(++b1);//错误的写法
printf("y:%d,b1:%d\n",y,b1);
return 0;
}
printf("LINE:%d\n",__LINE__);//打印当前行号
关系运算符
| 运算符 | 功能 | 举例 | 说明 |
|---|---|---|---|
| > | 大于 | a > b | 判断a是否大于b |
| >= | 大于或等于 | a >= 5 | 判断a是否大于或等于5 |
| < | 小于 | 3 < x | 判断3是否小于x |
| <= | 小于或等于 | x <= (y+1) | 判断x是否小于或等于y+1 |
| == | 等于 | （x+1） == 0 | 判断x+1是否等于0 |
| != | 不等于 | c != ‘\0’ | 判断c是否不等于’\0’ |
#include <stdio.h>
#include <stdbool.h>
int main(int argc, char const *argv[])
{
int a = 10, b = 20;
bool ret = a > b;
bool ret1 = a < b;
bool ret2 = a >= b;// a大于或等于b？
bool ret3 = a <= b;//a小于或等于b？
bool ret4 = a == b;//a等于b？注意是两个=
bool ret5 = a != b;// a不等于b？
printf("%d\n",ret5);
return 0;
}
=:赋值
==:判断
逻辑运算符
| 运算符 | 功能说明 | 举例 |
|---|---|---|
| ！ | 逻辑反 | !(x==0) |
| && | 逻辑与 | x > 0 && x < 10 |
| || | 逻辑或 | y < 10 || x > 10 |
- 运算规则：
- 逻辑反：将逻辑真、假翻转，即真变假，假变真
- 逻辑与：将两个关系表达式串联起来，当且仅当左右两个表达式都为真时，结果为真。
- 逻辑或：将两个关系表达式并联起来，当且仅当左右两个表达式都为假时，结果为假。
#include <stdio.h>
#include <stdbool.h>
int main(int argc, char const *argv[])
{
int a = 10, b = 5, c = 6, d = 7;
//10大于5并且6小于7为真，结果为1
printf("%d\n",a > b && c < d);
//10小于5或者6小于7为真，结果为1
Printf（"%d\n",a <b || c < d);
//-1为真取反为假，结果为0
printf("%d\n",!-1);
//c语言为惰性语言，只要表达式1能确定整条预计结果，则表达式2不执行
printf("%d,%d\n",a < b && a++,a);
int x = 10,y = 20;
printf("%d\n",(x<100) || (y = 50),y);// y=20
return 0;
}
int x = 10,y = 20;
printf("%d\n",(x > 100) || (y = 50),y);// y=50
int a = 10, b = 20;
bool ret = a > 5 && b < 25;// 同时为真则真
ret = a > 5 || b < 25;// 同时为假则假
ret = !(a > 5 && b < 25);
printf("%d\n",ret);
算术运算符
| 运算符 | 功能说明 | 举例 |
|---|---|---|
| + | 加法，一目取正 | a+b |
| - | 减法，一目取负 | a-b |
| * | 乘法 | a*b |
| / | 除法 | a/b |
| % | 取模（求余） | a%b |
| ++ | 自加1 | a++, ++b |
| – | 自减1 | a–, --b |
- /与%在处理数据的时候可以进行提取低字节或者高字节数据比如0x123%10，或者0x123/10,应用场景比如温湿度的截取
位运算符（重点）
| 运算符 | 名称 | 举例 | 功能说明 |
|---|---|---|---|
| ~ | 位逻辑反 | ~a | 将变量 a 中的每一位取反 |
| & | 位逻辑与 | a & b | 将变量 a 和 b 逐位进行与操作 |
| | | 位逻辑或 | a | b | 将变量 a 和 b 逐位进行或操作 |
| ^ | 位逻辑异或 | a ^ b | 将变量 a 和 b 逐位进行异或操作 |
| << | 左移 | a << 4 | 将变量 a 中的每一位向左移动4位 |
| >> | 右移 | x >> n | 将变量 x 中的每一位向右移动4位 |
- ~ : 按位取反—单目运算符，数据将每一个bit位取反，1变0，0变1
%u:是以补码的方式存放
%d:是以补码还原成原码方式显示
#include <stdio.h>
int main(int argc, char const *argv[])
{
char a = 0x03;
printf("%d\n",~a);
char b = 0x09;
printf("%d,%d\n",b,~b);
return 0;
}
/* char b = 0x09;
printf("%d,%u\n",~b,~b);//-10,4294967286
*/
&：按位与，全1为1，有0为0
| ：按位或，有1为1，全0为0
^ : 按位异或 ，不同为1，相同为0
#include <stdio.h>
int main(int argc, char const *argv[])
{
unsigned char a1 = 0x3c;//60
unsigned char b1 = 0x47;//71
printf("%d\n",a1^b1);//123
return 0;
}
无符号左移
#include <stdio.h>
int main(int argc, char const *argv[])
{
unsigned int a = 3 <<5;
printf("%d\n",a);//不越界的情况下有公式：3*2^5=96
return 0;
}
number*2^n
对于正数来说 原码反码补码都是一样的
有符号左移
-3 << 3
1000 0011 原码
1111 1100 反码
1111 1101 补码 移位操作 <<3
1110 1000 移位后的数据，负数显示是以原码的方式显示
1110 0111 -1
10011000 取反
#include <stdio.h>
int main(int argc, char const *argv[])
{
int a = -9 <<3;
printf("%d\n",a);//-72
retun 0;
}
无符号右移
a 右移n位的结果为a/2^n
unsigned char a = 151 >> 5;
printf("%d\n",a);//4
有符号右移
char a = -96 >> 5;
printf("%d\n",a);
- 注意：
- 进行移位运算时，凡是移出去的位都丢弃，凡是空出来的都补0，移位运算是针对的五毒号整数。
- 有符号的移位运算，左移时空出来的补0，右移时，空出来的补符号位。
例题
将0x12ff0045第14,15位置为1，22,23位置为0
#include <stdio.h>
int main(int argc, char const *argv[])
{
unsigned int data = 0x12ff0045;
//将第14 15位置为1
data = data | 0x03 << 14;
//将第22 23 位置为0
data = data & ~(0x03 <<22);
printf("%#x\n",data);
return 0;
}
置1，左移/右移,位或
置0，左移/右移取反,再位与
特殊运算符
下划线开头是系统命名如_a
不能以数字开头
*a表示指针，不能用作变量名，不能int *a
可以用下划线或字母开头定义变量
条件运算符（三目运算符，重点）
语法：表达式1？表达式2：表达式3
释义：当表达式1为真时，取表达式2，否则取表达式3
int a = 200;
int b = 100;
int m = (a>b) ? a : b; //如果 a > b 为真，则 m 取 a 的值，否则取 b 的值
sizeof运算符
sizeof(100);//正确的
sizeof(a);//正确的
sizeof 100;//正确的
sizeof a;//正确的
sizeof int;//错误的，正确的sizeof (int);
逗号表达式
int a = 2, b = 3;
//逗号运算符的特点是取最后一个表达式作为结果
int ret = (a>b,a++,b++,a);
printf("%d\n",ret);
运算顺序从左往右，但取最后一个表达式作为结果
优先级与结合性
- 当表达式出现不同的运算符时，根据优先级来决定谁先执行，比如先乘除后加减
- 当表达式中出现多个相同优先级的运算符时，更具结合性决定谁先运行，比如从左到右
控制流
二路分支
if 语句:如果-则
if-else语句：如果-否则
{}是作用域 （）是条件
int main()
{
if(技术面试通过)
{
技术部上班
}
else
{
其他部门
}
return 0;
}
#include <stdio.h>
int main(int argc, char const *argv[])
{
int number;
scanf("%d",&number);
printf("%d\n",number%2==0);
if(number % 2 == 0) // 如果为真就执行以下语句
{
printf("偶数\n");
}
else // 否则执行以下内容
{
printf("奇数\n");
}
// 二路分支
// 如果if条件满足的情况下，只有一条语句，可以不用加{}
// 多于一条语句需要加{};
if(number % 2 == 0)
{
printf("我是");
printf("偶数\n");
}
else
printf("奇数\n");
return 0;
}
多路分支
// 多路分支,互斥关系，如果条件1和条件2成立，则只执行条件1
if(number > 0 && number <= 10)
{
printf("蛋炒饭\n");
}
else if(number > 10 && number <= 20)
{
printf("黄焖鸡\n");
}
else if(number > 20 && number <=30)
{
printf("kfc\n");
}
else
{
printf("食堂随便吃");
}
嵌套分支
// 嵌套分支
if(number > 400)
{
int score;
printf("面试成绩:");
scanf("%d",&score);
if(score > 80)
{
printf("欢迎来到xxx研究院\n");
}
else
{
printf("再接再厉\n");
}
}
练习1：
制作一个简单的打分系统(满分制：100)，使用if…else方法，分数需整数
60分以下：评级为D
60-80分 ： 评级为C
80-90分 ： 评级为B
90-100分： 评级为A
不在0-100范围内：错误
#include <stdio.h>
int main(int argc, char const *argv[])
{
float score;
printf("请输入成绩：");
scanf("%f",&score);
if(score >=0 && score < 60)
{
printf("D\n");
}
else if(score >= 60 && score < 80)
{
printf("C\n");
}
else if(score >= 80 && score <90)
{
printf("B\n");
}
else if(score >=90 && score < 100)
{
printf("A\n");
}
else
{
printf("错误");
}
return 0;
}
多路分支
switch 语句
#include <stdio.h>
int main(int argc, char const *argv[])
{
switch(4)
{
case 1:
printf("one\n");
break;
case 2:
printf("two\n");
break;
case 3:
printf("three\n");
break;
default:// 上面的语句不满足则执行此语句
printf("other\n");
break;
}
return 0;
#include <stdio.h>
int main(int argc, char const *argv[])
{
int score;
scanf("%d",&score);
switch (score)
{
case 0 ... 60:
printf("D\n");
break;
case 61 ... 80:
printf("C\n");
break;
case 81 ... 90:
printf("B\n");
break;
case 91 ... 100:
printf("A\n");
break;
default:
printf("输入错误，请重新输入\n");
break;
}
return 0;
}
练习2：
计算加盟费
小张加盟一家餐饮企业，在每个季度结束后，小张必须向总部缴纳加盟费，加盟费与营业额的提成关系如下：
营业额 提成系数
0<=n<10w 0.1
10<=n<20w 0.075
20<=n<40w 0.05
40<=n<60w 0.03
60<=n<100w 0.015
n >= 100w 0.01
请输入小张的营业额，然后求出它需要的提交的加盟费
/*
*解题思路：
1.使用二路分支来标记营业额
2.使用二路分支的标记作为多路分支的条件
*/
#include <stdio.h>
int main(int argc, char const *argv[])
{
float money; //营业额
float val; //提成
int flage; //记录营业额范围
printf("请输入营业额（万元）：");
scanf("%f",&money);
//营业额
if(money < 0)
{
printf("找个班上，别开了\n");
}
else if(0 <= money && money <=10)
{
flage = 1;
}
else if(10 < money && money <= 20)
{
flage = 2;
}
else if(20 < money && money <= 40)
{
flage = 3;
}
else if(40 < money && money <= 60)
{
flage = 4;
}
else if(60 < money && money <= 100)
{
flage = 5;
}
else if(money > 100)
{
flage = 6;
}
//提成
switch(flage)
{
case 1:
val = 0.1;
break;
case 2:
val = 0.075;
break;
case 3:
val = 0.05;
break;
case 4:
val = 0.03;
break;
case 5:
val = 0.015;
break;
case 6:
val = 0.01;
break;
default:
break;
}
//输出加盟费
printf("加盟费:%.2f万元\n",money * val);
return 0;
}
const
#include <stdio.h>
int main
{
const int a = 10;
//a = 20;//a被限制为常量，不可重新赋值
//const修饰变量的时候，必须要先初始化
//否则无意义
const int b;//int const b;这样写也可以
b = 10;
return 0;
}
while循环
#include <stdio.h>
int main(int argc, char const *argv[])
{
int number = 1;
int max = 0;
while (number <= 100)
{
max += number;
printf("%d\n",max);
number++;
}
while(1)
{
if(number > 100)
break;
max +=number;
printf("%d\n",max);
number++;
}
return 0;
}
//0~100的偶数
#include <stdio.h>
int main(int argc, char const *argv[])
{
int number = 101;
while (number--)
{
if(number%2==0)
{
printf("偶数%d\n",number);
}
}
return 0;
}
//0~100偶数求和
#include <stdio.h>
int main(int argc, char const *argv[])
{
int n = 1;
int max = 0;
while(1)
{
if(n > 100)
break;
if(n % 2 == 0)
{
max += n;
}
n++;
}
printf("%d\n",max);
return 0;
}
do while
do之后的语句至少执行一遍
#include <stdio.h>
int main(int argc, char const *argv[])
{
int n = 0;
do
{
printf("%d\n",++n);//n++到99，++n到100
} while (n != 100);
return 0;
}
//1~100的和
#include <stdio.h>
int main(int argc, char const *argv[])
{
int n = 0;
int max = 0;
do
{
max += n;
n++;
} while (n != 101);
printf("%d\n",max);
return 0;
}
//使用do...while实现1+2+...+100的和
#include <stdio.h>
int main(int argc, char const *argv[])
{
int a,b;
int max = 0;
//scanf("%d%d",&a,&b);
do
{
scanf("%d%d",&a,&b);
if(a > b)
{
max = a;
printf("%d\n",max);
}
else if (a < b)
{
max = b;
printf("%d\n",max);
}
} while (a != b);
return 0;
}
//不够严谨，当输入字符时会出错，以下截图为正确参考
getchar()的使用在上周的总结中有讲解，在写程序时要根据题目要求灵活使用getchar和scanf
for循环
逻辑：与while循环类似，但更加紧凑，for循环将控制循环的变量集中在一行
#include <stdio.h>
{
int main(int argc, char const *argv[])
{
int i = 1;//执行1遍
while(1)
{
if(i > 5)// 判断是否小于5
break;
printf("%d\t",i++);//输出i，i自加
}
return 0;
}
}
//第一句只执行一遍，第二句判断是否小于5，如果是就执行下面大括号里的语句，第三句i自加，
for(int i = 1;i <= 5;i++ )//不是所有编译器都可以在里面定义，c98编译器会报错
{
printf("%d\t",i);
}
/*
//还可以这样写
int i = 1;
for(;i <=5;i++)
{
printf("%d\t",i);
}
//或者
i = 1;
for(;i <= 5;)
{
printf("%d\t",i++);
}
printf("\n");
i = 1;
for(;;)
{
if(i <= 5)
{
printf("%d\t",i++);
}
else
{
break;
}
}
printf("\n");
return 0;
练习
//求1~100的和
#include <stdio.h>
int main(int argc, char const *argv[])
{
int sum = 0,i;
for(i = 1;i <= 100;i++)
{
sum = sum + i;
}
printf("%d\n",sum);
return 0;
}
//编写一个程序输出26个小写字母
#include <stdio.h>
int main(int argc, char const *argv[])
{
char i;
for(i = 'a';i < 'z';i++)
{
printf("%c",i);
}
return 0;
}
嵌套循环-for嵌套
int main(int argc, char const *argv[])
{
for(int i = 0; i < 5; i++)// 外循环
{
for(int j = 0; j < 4; j++)// 内循环
{
printf("i:%d j:%d\n",i,j);
}
}
return 0;
}
练习（循环控制）
编写一个程序，在用户输入某个大写字母后，产生一个金字塔图案。
例如输入字母E，则产生如下图案：
A
ABA
ABCBA
ABCDCBA
ABCDEDCBA
#include <stdio.h>
int main(int argc, char const *argv[])
{
char ch;
int i,j,line;
printf("请输入字母：");
scanf("%c", &ch);
if(ch < 'A' || ch > 'Z')
{
printf("输入出错，请重新输入大写字母\n");
return -1;
}
//计算总行
line = ch - 'A' + 1;
for(i=1; i<=line; i++)
{
for(j=0; j<line-i; j++)// 输出空格
{
printf(" ");
}
for(j=0; j<i; j++)//升序
{
printf("%c", 'A'+j);
}
for(j-=2; j>=0; j--)//降序
{
printf("%c", 'A'+j);
}
printf("\n");
}
return 0;
}
goto语句
#include <stdio.h>
int main(int argc, char const *argv[])
{
// 输出当前行号
printf("__%d__\n",__LINE__);
//跳转到定义的标签处
goto Label;
printf("__%d__\n",__LINE__);
//goto标签
Label:
printf("__%d__\n",__LINE__);
return 0;
}
goto运用场景
#include <stdio.h>
int main(int argc, char const *argv[])
{
printf("请输入分子与分母:");
int a, b;
scanf("%d/%d",&a,&b);
if(b == 0)
{
goto error;
}
printf("ret = %d\n",a/b);
error:
printf("process exit\n");
return 0;
}
练习（循环控制、多路分支）
编写一个程序，接收用户的输入信息，当用户输入完成后（#代表输入完成），自动统计用户输入的空格数、大小写字母数和其他字符数。
#include <stdio.h>
int main(int argc, char const *argv[])
{
char s;
int a=0,b=0,c=0,d=0;
printf("输入信息,输入完成后输入#\n");
while((s = getchar()) != '#')
{
if (s == ' ')
{
a++;
continue;
}
if(s >= 'A' && s <= 'Z')
{
b++;
continue;
}
if(s >= 'a' && s <= 'z')
{
c++;
continue;
}
d++;
}
printf("空格数：%d\t",a);
printf("大写字母数:%d\t",b);
printf("小写字母数:%d\t",c);
printf("其他字符数:%d\t",d);
return 0;
}
数组
从内存的角度思考问题（上周总结中变量的定义部分有对int a含义的相关解释）
#include <stdio.h>
int main(int argc, char const *argv[])
{
//申请4块连续的ch空间存放"ABC\0"
//把这4块空间称为数组
char ch[4] = "ABC";
printf("c[0]=%c\n",ch[0]);//将ch第0块空间的额内容输出
printf("c[1]=%c\n",ch[1]);//将ch第1块空间的额内容输出
printf("c[2]=%c\n",ch[2]);//将ch第2块空间的额内容输出
//将数组ch的第二块内存的数据给c
char c = ch[2];
printf("%c\n",c);
char buf[5];
//%p为输出地址
printf("buf addr : %p\n",buf);
buf[0] = 'r';
buf[1] = 'o';
buf[2] = 's';
buf[3] = 'e';
buf[4] = '\0';
// %s是输出字符串
printf("%s\n",buf);//%s贪婪模式，从里面找直到\0结束
return 0;
}
buf是部分【0】的地址，是整个数组的基地址
部分【0】是一块基地址空间，里面存了‘r’
buf == &buf[0]
总结：数组名相当于整个数组的首地址
数组的空间地址问题
#include <stdio.h>
int main(int argc, char const *argv[])
{
char c1[5] = "loki";
printf("%d\n",sizeof(c1));
//数组名是这个数组的首元素地址
printf("ca adde %p\n",c1);
printf("c1[0] addr %p\n",&c1[0]);
printf("c1[1] addr %p\n",&c1[1]);
printf("c1[2] addr %p\n",&c1[2]);
//*表示获取地址里面的内容，*表示解引用
printf("%c\n",*(c1+0));//&c1[0]==c1+0 ==> c1[0] == *(c1+0)
printf("%c\n",*(c1+1));//&c1[1]==c1+1 ==> c1[1] == *(c1+1)
printf("%c\n",*(c1+2));//&c1[2]==c1+2 ==> c1[2] == *(c1+2)
printf("%c\n",*(c1+3));//&c1[3]==c1+3 ==> c1[3] == *(c1+3)
return 0;
}
整型数组的定义并初始化(变长数组赋值清空等):
#include <stdio.h>
int main(int argc, char const *argv[])
{
//定义数组
int a[10];
int size = 10;
//变长数组
int a1[size];
//初始化数组
int a2[5] = {1,2,3,4,5};
printf("%d\n",a2[2]);
//溢出
//int a3[3] = {1,2,3,4};
//初始化单位时候[]内容可以为空
int a3[] = {1,2,3,4};
printf("%d\n",sizeof(a3));
//int a3[];//错误的，不知道分配多大的空间
//使用变长数组，定义的时候初始化，会报错
//int a3[size] = {1,2,3,4};
//将数据赋值到数组
a[0] = 1;
a[1] = 2;
for(int i =0;i <10;i++)
a[i] = i;
//变长数组赋值
a1[0] = 10;
a1[1] = 11;
//输出数组内容
for(int i = 0;i< 10;i++)
printf("%d\t",a[i]);
//数组清空
int a4[100] = {0};
for(int i = 0;i<100;i++)
printf("%d\n",a4[i]);
//计算数组的总大小
int a6[10];
printf("a6 size : %ld\n",sizeof(a6));
//计算数组元素个数
int a7[] = {1,2,3,4,5,6};
int num = sizeof(a7) / sizeof(a7[0]);
printf("%d\n",num);
return 0;
}
练习：十进制转十六进制（笔试题常见题）
#include <stdio.h>
int main(int argc, char const *argv[])
{
int n,count = 0;
char buf[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
scanf("%d",&n);
int index[16] = {0};
while(n != 0)
{
index[count++] = n % 16;
n = n / 16;
}
for(count = 15;count >= 0;count--)
printf("%c",buf[index[count]]);
return 0;
}
//完善的程序
#include <stdio.h>
int main(int argc, char const *argv[])
{
char ch[16] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
//存放取余的空间
int index[16] = {0};
//输入
int data,count = 0;
printf("请输入十进制整数: ");
scanf("%d",&data);
while(1)
{
index[count++] = data % 16;
data /= 16;
if(data==0)
break;
}
for(int i = count - 1; i >= 0; i --)
{
printf("%c",ch[index[i]]);//B
}
printf("\n");
return 0;
}
以上就是我本周学习内容的总结，经过本周的学习明显感觉到自己的薄弱点，对程序的分析、解题思路不是很清晰，对一些较长运算或较多循环的语句判断不明确，对于一些细节之处不够细心会被绕进去。这周也做了很多相关的试题练习，通过不断地练习总结完善，情况正在慢慢好转，一份努力一份收获，坚持!
197
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
