嵌入式（c）

##23.6.1（c学习）

#include <stdio.h>
/*

1. 常量和变量

/*
左值：可以被修改的值称为左值
等号左边的值称为左值
右值：不可以被修改的值称为右值
等号右边的值称为右值
*/

int main(void)
{
int a = 10;
a = 20;
//20 = a;
return 0;
}

2 数据类型

#include <stdio.h>
#if 0
基本数据类型：在内存中有固定的大小
整形数据: char 字符型 1个字节
short 短整型 2个字节
int 整形 4个字节
long 长整型 4个字节
long long 长整形 8个字节
实型（浮点型）：
float 单精度 4个字节 （精确到小数点后6位）
double 双精度 8个字节 （精确到小数点后10位）
枚举 ：
enum 枚举类型 4个字节
构造数据类型：在内存中大小不固定
数组//同种数据类型的集合
结构体//可以是任意数据类型的集合
联合体//可以是任意数据类型的集合
指针类型：复杂的指针类型 void*:万能指针
(根据指针存储地址类型的不同，需要定义不同数据类型的指针)
空类型：void
#endif

#if 0
计算机中的存储单位：
1字节（byte） = 8位
1千字节（kb） = 1024byte
1M = 1024kb
1G = 1024M
1T = 1024G
#endif
int main(void)
{

}

3.进制转换

#include <stdio.h>
/*
进制的分类：
二进制：逢2进1(以0b开头)(0和1)
八进制：逢8进1（以0开头）(0~7)
十进制:逢10进1(无)（0~9）
十六进制：逢16进1（以0x开头）（0_9和af）
/
/
进制的转换：
二进制转十进制：从低位开始累加
0b1011----> 2^01 +2^1*1+220+2^3*1 = 11
十进制转二进制：除2取余，倒着往上数
57---->0b111001

八进制转二进制：一位八进制可以用三位二进制来表示
0756—>0b111 101 110
二进制转八进制：从低位开始,三位为间隔分割
0b 10 011 110 111 000–>023670

十六进制转二进制：一位十六进制可以用四位二进制来表示
0xabcd---->0b1010 1011 1100 1101
二进制转十六进制：
0b 110 1110 0111 1010 1010—>0x6e7aa

总结：
八进制和十六进制转换：
先转成二进制，再转成十六进制或者八进制
十进制转成任意进制数：
除商取余，倒着往上数

*/
int main(void)
{
int a = 0x10;
return 0;
}

4.基本数据类型

#include <stdio.h>
/*
定义一个数据类型 char ch = ‘a’;
auto signed char ch = ‘a’ ----> char ch = ‘a’;
<存储类型> <有无符号> <数据类型> 变量名;
/
/
基本数据类型分为整数，浮点数
因为其在内存中的存储方式不同
整数都是以其补码的形式存储
而浮点类型是以小数+指数的形式存在
1/4用于存储指数部分
3/4用于存储小数部分
由于内存中只能以二进制的形式进行存储
所以浮点类型在内存中是一个近似值
*/

/*
char:字符类型，占1个字节
取值范围：
有符号：signed char
-2^7 ~ 2^7-1 -128 ~ +127
无符号：unsigned char
0~2^8-1 0 ~ 255
/
/
short:短整数类型，占2个字节
取值范围：
有符号：signed short
-2^15 ~2^15-1 -32768 ~ + 32767
无符号：unsigned short
0 ~ 2^16-1 0 ~ 65535
*/

/*
int:整数类型，占4个字节
取值范围：
有符号：signed int
-2^31 ~2^31-1
无符号：unsigned int
0 ~ 2^32-1
*/

/*
long long:长整数类型，占8个字节
取值范围：
有符号：signed long long
-2^63 ~ 2^63-1
无符号：unsigned long long
0 ~ 2^64 -1
*/

/*
浮点类型：
float:单精度浮点型：占4个字节，精确到小数点后6位
double:双精度浮点型：占8个字节，精确到小数点后10位
*/
int main(void)
{
auto signed char ch = ‘a’; //char ch = ‘a’

char ch2 = 'a'; 
char ch3 = 'b';;


return 0;

}

5.标识符和关键词

#include <stdio.h>
/*
标识符：
1.只能由字母，数字，下划线和$组成
2.开头不能是数字
3.不能和关键词重合
/
/
c语言关键词：（32个关键词）
数据类型关键字(12个)：
char、short、int、long、signed、unsigned、float、double、struct、union、enum、void
控制语句关键字 (12 个）：
1、循环控制（3个）
for、do、while
2、分支语句（5个）
if、else，switch、case，default
4、辅助控制语句（4个）
return break、continue、goto
存储类型关键字（ 4 个）
auto、register、static、const
其他关键字（ 4 个）
typedef、sizeof，extern，volatile
*/
int main(void)
{
return 0;
}

6.基本类型的使用

#include <stdio.h>
#include <stdbool.h>
/*
初始化：在操作系统给其分配空间的时候赋值
赋值： 后续对变量值的修改都称为赋值
*/

/*

/*
字符0 ~9 ：48 ~57
小写字母a~z ：97 ~122
大写字母A~Z ：65 ~90
换行符 ：10 //putchar(10)
*/
int main(void)
{
#if 0
char ch = ‘a’;

char ch2 = 65;  //将65当作ascii存放在内存中
**//%c：输出字符**
**%d：输出32位有符号整数**
printf("ch = %c\n",ch);
printf("ch = %d\n",ch); //输出字符‘a'的ascii

printf("ch2 = %c\n", ch2);  //输出65对应的字符
printf("ch2 = %d\n", ch2); //输出ascii 65
char ch3 = 128;
printf("ch3 = %d\n",ch3);

int a = 100;
**int b = 0b10011111; //将二进制数赋值给变量b**
**//int c = 0678;//非法的数字“8"**
int c = 0567; //将八进制数赋值给变量c
**int d = 0x12345678;//将十六进制数赋值给d**

//%o:输出32位无符号八进制
//%x:输出32位无符号十六进制
//printf不支持输出二进制整数
//#:输出进制的前导符
printf("a = %d %#o %#x\n",a,a,a);
printf("b = %d %#o %#x\n",b,b,b);
printf("c = %d %#o %#x\n", c, c,c);
printf("d = %d %#o %#x\n", d, d, d);

float f1 = 3.14;
//%f:输出有符号浮点类型，默认输出后6位
//**保留输出小数点后两位 %.2f**
printf("f1 = %.2f\n",f1);
float f2 = 6873.1234567; //如果是一个很大的数，
					 	//小数点精度可能丢失
printf("f2 = %f\n", f2);

double d1 = 56778.12345678; //对于很大的浮点型，使用double来计算
printf("d1 = %.10lf\n",d1);

/*
浮点类型和0如何比较？
当 f1>= -0.000001 && f1 <= 0.000001

如何判断两个浮点类型是否相等？
当 f1 - f2>= -0.000001 && f1-f2 <= 0.000001
*/
float f1 = 0.0000001;
//if (f1 == 0) //错误写法
if(f1 >= -0.000001 && f1 <= 0.000001)
{
printf(“f1 = 0\n”);
}
else
{
printf(“f1 != 0\n”);
}

//其他数据类型 bool类型
//bool的值只有两个 0（false） 和 1(true)
//bool占1个字节
//bool b1 = 0;
//bool b1 = true;
//bool b1 = false;
//bool b1 = 0.000001;
bool b1 = 6789.213;
printf(“b1 = %d\n”,b1);
#endif
long b = 1234567;
long long c = 123456789;
printf(“b =%ld\n”,b);//l:表示输出长整形或者在doule输出时使用
printf(“b =%lld\n”, c);//ll:输出long long 类型使用
//数据类型所占内存空间的大小？
//sizeof：用于计算数据类型所占内存空间的大小
int a = 100;
printf(“sizeof(a) = %lld\n”,sizeof(a)); //sizeof的值可以是变量
printf(“sizeof(char) = %lld\n”, sizeof(char)); //sizeof的值可以是数据类型
printf(“sizeof(short) = %lld\n”, sizeof(short));
printf(“sizeof(int) = %lld\n”, sizeof(int));
printf(“sizeof(long) = %lld\n”, sizeof(long));
printf(“sizeof(long long) = %lld\n”, sizeof(long long));
printf(“sizeof(float) = %lld\n”, sizeof(float));
printf(“sizeof(double) = %lld\n”, sizeof(double));
printf(“sizeof(char*) = %lld\n”, sizeof(char*));
printf(“sizeof(int*) = %lld\n”, sizeof(char*));
printf("sizeof(char()[]) = %lld\n", sizeof(char()[]));

return 0;

}

7.数据在内存中的存储

#include <stdio.h>
/*
**整数在内存中是以补码的形式存在的
我们给变量赋的值称为源码，数据在内存中
存放的叫补码，为了实现源码和补码的转换
定义了：反码
/
/
源码和补码之间的转换：
1.正数的源码，反码，补码都一样
2.负数的反码等于源码取反，补码等于反码加一
（注意：在源码反码补码转换时，符号位不动）
/
/
向内存中存储时 :看正负
从内存中取出数据时:看最高位是否当作符号位
/
/
数据的所有计算都是用补码来进行计算
*/

/*
举例：
char ch = 97;
源码：0110 0001
反码：0110 0001
补码：0110 0001

char ch = -10;
存储时：
源码：1000 1010
反码：1111 0101
补码：1111 0110
取出时：
补码：1111 0110
反码：1111 0101
源码：1000 1010
unsigned char = -10;
存储时：
源码：1000 1010
反码：1111 0101
补码：1111 0110
取出时：
补码：1111 0110
反码：1111 0110
源码：1111 0110 = 246
*/
int main(void)
{
char ch = 97; //97称为源码
unsigned char ch2 = -10;
printf(“ch2 = %d\n”,ch2);

char ch3 = 0;
for (int i = 0; i < 1000; i++)
{
	ch3++;  //ch3 = ch3 +1；
	//%u：输出32位无符号10进制数
	printf("%u ",ch3);
}
//127 + 1 = -128？
unsigned int a = -89;
printf("a = %u\n",a);

/*
127：
源码：0111 1111
反码：0111 1111
补码：0111 1111
1：
源码：0000 0001
反码：0000 0001
补码：0000 0001

127 + 1：
127 补码：0111 1111

1 补码：0000 0001

补码：1000 0000
反码：1111 1111
源码：1000 0000 = -128

*/
return 0;
}

8.格式化

#include <stdio.h>
/*
字符常量：
int a =10;
a :变量
‘a’ :字符a,占1个字节
“a” :字符串a,占2个字节
*/

/*
科学计数法：
数学表达式：1123.456789—>1.123456789*10^3
c语言表达式：1123.456789—> 1.123456789e+3
科学计数法格式： <+/->m.ne<+/->k
*/

/*
宏常量：
#define 常量名 值
注意事项：
1.宏变量需要遵从标识符的命名规则
2.宏变量可以直接使用
3.宏变量的作用域为从定义开始，到当前文件末尾
4.宏变量可以定义在文件的任意位置
5.宏常量一般写在文件的最上方，且都由大写字母组成
6.宏常量只做纯替换，不作语法安全性等边界的检查
*/
#define M 3
#define N 4
#define SUM(M,N) M+N
//#define SUM(M,N) ((M) + (N))

int main(void)

{
char buf[64] = “hello world”;
//%s:输出一个字符串，其参数为字符串的首地址

printf("buf = %s\n",buf);

printf("%%\n");
unsigned int num = 100;
printf("num = %p\n",&num);
printf("num = %#llx\n",&num); //输出8字节16进制整数

//num = M + N;
num = SUM(M, N) * 2; //num = M+N*2;
printf("num = %d\n",num);
return 0;

}

9.

#include <stdio.h>
/*
vs2022中，所有从外存向内存写入的字符串
都必须指定最大字符串的长度
/
/
崩溃：访问了不能访问的内存空间
*/
int main(void)
{
char buf[5] = { 0 }; //申请一个字符数组
//gets(buf); //从终端获取一段字符串写入buf中
gets_s(buf,5);//限制从终端获取的最大字符个数为5
//printf(“sizeof(_int64) = %lld\n”, sizeof(__int64));

for (int i = 0; i < 5; i++)
{
	printf("%c [%d]\n",buf[i],buf[i]);
}
//puts(buf); //向终端输出一段字符串
puts("");  //puts会默认输出换行符
return 0;

}
#include <stdio.h>

int main(void)
{
//int ch = getchar(); //从终端获取一个字符,赋值给ch
//printf(“ch = %c [%d]\n”,ch,ch);

//putchar(ch);  //putchar的参数可以是一个变量
//putchar('a');  //putchar的参数可以是一个字符
//putchar(65); //putchar的参数可以是ascii
//putchar(10);