Week01
一.语言基础认知
1.1 C语言是什么?
通过一系列的语法和语义规则来描述计算机程序的行为和逻辑，可以将程序转化为二进制指令，并由CPU执行。
语言=语法+逻辑
1.2 C语言的特点
-
简洁
- C语言的语法简单，简单明了，使得程序易于阅读和理解。
-
高效
- C语言的执行效率高，可以用于开发需要高性能的应用程序。
-
可移植
- C语言可以在不同的硬件平台和操作系统上运行，具有较高的可移植性。
-
模块化
- C语言支持函数和结构体等模块化编程方法，使得程序的复杂性得到有效控制。
-
标准化
- C语言的语法和标准库已经被ISO和ANSI标准化，具有广泛的应用和兼容性。
1.3 C语言的应用领域
- 系统软件
- 嵌入式软件
- 网络设备
- 游戏开发
二.C语言的基础语法
2.1 第一个C语言程序
// 单行注释 快捷键 ctrl+k,ctrl+c
// 取消注释 快捷键 ctrl+k,ctrl+u
/*
ctrl+shift+/ 切换注释块*/
#include <stdio.h> //头文件 对库函数进行声明 比如 printf
//main 函数是主函数，一个工程有且只有一个主函数 ，也是程序的入口函数
// main 左边的int是函数的返回值 右边的()里是函数的形参 {}是函数体，代码块
int main(int num)
{printf("Hello，World!\n");return 0 ;
}int main()
{printf("Hello，World!\n");return 0 ;
}
C程序代码规范:
1.一个说明或者一个语句独占一行，比如:包含头文件，一个可执行语句都要执行。
2.函数体内要有明显缩进，按一个tap键为一个缩进
3.括号要成对写，如果要删除，也要成对删除
4.一句可执行语句的末尾一定要加分号
2.2语言语法规范
C语言规定，标识符可以是字母(A～Z，a～z)、数字(0～9)、下划线_组成的字符串，并且第一个字符必须是字母或下划线。
#include<stdio.h> extern int kk;//在外部声明了一个变量 ，不是定义 kk可以在别的文件中定义extern int kk1;extern void fn();
int main(int num) {//变量 可以变化的量 int a;//定义变量a = 90;//赋值int b = 90;//定义的的同时赋值int m, n;//同时定义多个变量多个变量m = 1;n = 2;printf("打印输出m的值：%d\n",m); // \n转义字符 表示换行 printf("hhhhhhhhhhhhhhhhhhhh");fn();return 0;}
int kk1=200;
int kk=100;
extern int a;
void fn(){printf("%d",a);
}
2.3变量的声明和定义
变量的声明与定义的区别：
1、定义变量是创建了变量并为其分配内存，声明没有分配内存
2、一个变量在一定的区域内只能被定义一次，声明可以有很多次
变量声明的本质:声明就是告诉编译器，这个变量已经在别的地方定义过了，这个只做基本的声明，
并没有为其分配内存。
2.4标识符的命名规范:
1.只能由数字，字母，下划线组成
2.不能以数字开头
3.不能使用c语音的关键字和保留字
4.见名之意
5.尽量使用大驼峰和小驼峰的方式命名,比如:
（1）大驼峰命名法 每个单词首字母大写 例如：MyFirstName
(2) 小驼峰命名法 从第二个单词开始，首字母大写 例如：myFirstName
(3)下划线命名法 每个单词之间用_连接 例如：my_first_name
2.5语言的关键字
数据类型关键字 （12个）
char(字符型) , short（短整型） ,int（整型） ,long（长整型） , float（浮点型）, double（浮点型，变量精度更高）,
unsigned（无符号数）, signed（有符号数）, struct（结构体）, union（联合体又叫共用体）, enmu（枚举）, void（空类型）--特殊不能定义变量，修饰函数的参数或返回值，表示没有
控制语句关键字 （12个）
if , else , switch , case , default
for ,do, while ,break, continue, goto, return
存储类关键字（5个）
auto（以后一般不用） , extern（外部的）, register（寄存器）, static, const
- register是寄存器的意思，用register修饰的变量是寄存器的变量
三.C语音的数据类型
C语言中，数据类型分为四类:
-
基本数据类型
-
构造数据类型
-
指针类型
-
空类型
3.1 字符型 char
char 表示为字符类型，用于存储单个字符，每个字符变量都是由8个bit位构成，在内存中就是一个字节
相关特性:
- 给字符型变量赋值时，需要用一对英文半角格式的单引号('')把字符括起来。
- 字符变量在内存单元存储时，是将与该字符对应的ASII码放在变量的存储单元中。
- char的本质就是一个1个字节大小的模型
1.字符串 只占一个字节 '' 多个字节 会有截断报告2.字符 输出 %c %d 对应的字符及ASCII码3.'\0','0'的区别4.大小写转换
//1.char字符串，用char定义的变量是字符型变量，占1个字节
char ch='a';
char ch1='1';
char ch2='1234';// 错误的，因为必须是一个字节
//printf("%d,%c", ch1, ch1);//52 4 数据显法不正常 有截断
#include<stdio.h>
int main() {//char 字符类型 单引号括住 只能作用于一个字符 转义字符除外//单引号的作用：1、定义字符 2、取字符的Ascll值//注意：printf %c输出的是字符 %d输出的是ASCII值char ch = 'a';printf("%c\n", ch);printf("%d\n", ch);char ch2 = '0';printf("%d\n", ch2);//48 是字符'0'的ASCLL值printf("%c\n", ch2);//'0'char ch3 = '\0';printf("%d\n", ch3);//'\0' 计算机存的是 0int a = 65;printf("%c\n", a);printf("%d\n", a);//注意：'0'和'\0'的区别//字符0存的是 48 '\0'存的是0//字符的大小写转换//'a' 97 'b' 98 'c' 99 ...... 'z' 122// 'A' 65 'B' 66 'c' 67 ...... 'z' 90char ch4 = 'a';ch4 = ch4 - ('a' - 'A');//小写转大写printf("%c\n", ch4);char ch5 = 'A';ch5 = ch5 + ('a' - 'A');printf("%c\n", ch5);//大写转小写return 0;
}
3.2 布尔类型
布尔类型是一种处理逻辑的类型，其有两个值，分别是真（true）或假（false），它在内存中的长度一般只占用1个字节。
- 早期C语言没有布尔类型数据，以0代表逻辑假，1代表逻辑真；
- C99标准定义了新的关键字bool，提供了布尔类型，或者也可以使用stdbool.h中的bool；
布尔类型是一种处理逻辑的类型，其有两个值，分别是真（true）或假（false），它在内存中的长度一般只占用1个字节。
- 早期C语言没有布尔类型数据，以0代表逻辑假，1代表逻辑真；
- C99标准定义了新的关键字bool，提供了布尔类型，或者也可以使用stdbool.h中的bool；
3.3 数据类型的长度
存储单位说明
| 术语 | 含义 |
|---|---|
| bit(比特) | 一个二进制代表一位，一个位只能表示0或1两种状态。数据传输是习惯以“位”（bit）为单位。 |
| Byte(字节) | 一个字节为8个二进制，称为8位，计算机中存储的最小单位是字节。数据存储是习惯以“字节”（Byte）为单位。 |
| 1b | 1bit |
| 1B | 1Byte = 8bit |
| 1KB | 1KB = 1024B |
| 1MB | 1MB = 1024KB |
| 1GB | 1GB = 1024MB |
| 1TB | 1TB = 1024GB |
| 1PB | 1PB = 1024TB |
| ...... | ...... |
基本数据类型的长度
数据类型的长度会受操作系统平台的影响，所以在不同平台下基本数据类型的长度是不一样的。
#include<stdio.h>
#include<stdbool.h>
int main(int num) {//sizeof()作用：返回对象在计算机内存中所占的字节数，返回64位（8bytes）无符号整型//所以占位符使用%lld 代开long long int (8bytes) %zu 打印无符号整型 size_tprintf("%zu", sizeof(size_t));//8 size_t 类型本身的大小//--------上面的了解printf("int 型的字节长度%lld\n", sizeof(int));//4printf("short int 型的字节长度%lld\n", sizeof(short int));//2printf("long int 型的字节长度%lld\n", sizeof(long int));//4printf("long long int型的字节长度%lld\n ", sizeof(long long int));// 8printf("char 型的字节长度%lld\n", sizeof(char));//1printf(" float 型的字节长度%lld\n", sizeof(float));//4printf(" double 型的字节长度%lld\n", sizeof(double));//8printf("long double 型的字节长度%lld\n", sizeof(long double));//8printf("bool 型的字节长度%lld", sizeof(bool));//1//ps:int在不同的编译环境下。字节有所不同，在TC(Turbo C)下2字节 在VC（Visual C++）下是4个字节// 在单片机开发中,int在8位的单片机中占2个字节 在32位单片机 中长度为4个字节 return 0;
}
**在单片机开发中,int在8位的单片机中占2个字节 在32位单片机 中长度为4个字节 **
//2.short短整型，使用short定义的变量是短整型变量，占2个字节
short int a=11; // -32768~~~32767//3.int 整型，用int定义的变量是整型变量，在int a1=44; // -20亿~~~~20亿//4.long长整型，用long定义的变量是长整型的，在32位系统下占4个字节long int a2=66;printf("sizeof(a)=%d\n" ,sizeof(a));//2
printf("sizeof(a1)=%d\n", sizeof(a1));//4
printf("sizeof(a2)=%d\n", sizeof(a2));//4//5.float单浮点型（实数），用float定义的变量是单浮点型的实数，占4个字节
float c=3.8f;
//6.double双浮点型（实数），用double定义的变量是双浮点型的实数，占8个字节
double b=3.8;
//7.struct这个关键字是与结构体类型相关的关键字，可以用它来定义结构体类型，以后讲结构体的时候再讲
//8.union 这个关键字是与共用体（联合体）相关的关键字，以后再讲
//9.enum与枚举类型相关的关键字 以后再讲
//10.signed有符号（正负）的意思在定义char、 整型（short int long）数据的时候用signed修饰，代表咱们定义的数据是有符号的，可以保存正数，也可以保存负数如： signed int a=10;signed int b=-6;注意：默认情况下signed可以省略//11. unsigned无符号的意思在定义char 、整型（short int long）数据的时候用unsigned修饰，代表咱们定义的数据是无符号类型的数据只能保存 正数 和0unsigned int a=101;unsigned int a=-101;//错误unsigned char myChar=255;printf("%u\n",myChar);//12. void空类型的关键字char 、int 、 float 都可以定义变量----void不能定义变量，没有void类型的变量void是用来修饰函数的参数或者返回值，代表函数没有参数或没有返回值void fun(void){}代表fun函数没有返回值，fun函数没有参数
3.4 可移植类型
最开始我们介绍C语言是一门跨平台的编程语言，使用C语言编写的程序可以在不同的系统平台下运行，这里有一些前提，为了更好的兼容不同平台，我们在使用基本上数据类型的时候会采用可移植的类型，这些类型可以确保在不同的平台下稳定的运行
3.5 stdint.h提供了标准的整数类型，
这些类型在不同的系统和编译器之间是可移植的。这个头文件定义了以下几种类型的整数：
- int8_t，uint8_t： 8位有符号和无符号整数
- int16_t，uint16_t：16位有符号和无符号整数
- int32_t，uint32_t：32位有符号和无符号整数
- int64_t，uint64_t：64位有符号和无符号整数
此外，stdint.h还定义了一些与这些类型相关的宏，例如in，INT16_MIN等，这些宏表示对应类型的最大值 、最小值。
3.6 inttypes.h提供了更多的整数类型和函数。
这个头文件定义了以下几种类型的整数：
- intmax_t：最大的整数类型
- uintmax_t：最大的无符号整数类型
- intptr_t：可以转换为指针的整数类型
- uintptr_t：可以转换为无符号整数的指针类型
此外，inttypes.h还定义了一些与这些类型相关的宏，例如UINTMAX_MAX，INTMAX_MAX等，这些宏表示对应类型的最大值。
#include<stdio.h>
// #include<stdbool.h> 提供了bool数据类型
#include<inttypes.h> //提供了精确宽度整数类型 ===可移植类型
int main(int num) {
//可移植类型有什么作用？// c语言有跨平台特点，可在不同系统下运行，为了兼容各种操作系统，inttypes.h头文件里规定了精确宽度整数类型
//8位整型int8_t a = 17;printf("%lld\n", sizeof(a));//16位整型int16_t b = 9;printf("%lld\n", sizeof(b));//无符号的8位整型uint8_t c = 90;printf("%lld\n",sizeof(c));--------------------------intmax_t my_intmax = INTMAX_MAX; // 假设我们想输出 intmax_t 类型的最大值 printf("\n%lld" , my_intmax);return 0;
}
#include<stdio.h>
//stdint.h 提供了一些可移植性的整型
#include<stdint.h>
#include<inttypes.h>
void main() {//int num = 0;int8_t num = 90;//8位有符号整型 int16_t age = 18;//16为有符号整型 相当于shortint32_t nu=900; //32位有符号整型 相当于intprintf("%lld\n", sizeof(num));printf("%lld\n", sizeof(age));printf("%lld\n", sizeof(nu));printf("hello world\n");//stdint.h行定义了一些宏常量printf("%d\n", INT8_MIN);//8位有符号整型最小值printf("%d\n", INT8_MAX);//8位有符号整型最大值printf("%d\n", UINT8_MAX);//8为无符号整型的最大值
}
3.7 常量
在程序执行过程中，值不发生改变的量称为常量。
C语言的常量可以分为直接常量、自定义常量和系统定义常量3类
1、直接常量也称为字面量，可以直接拿来使用，无需说明，例如：
| 整型常量 | 100，200，-100，0 |
|---|---|
| 实型常量 | 3.14 ， 0.125，-3.123f |
| 字符型常量 | 'a', 'b', '1' |
| 字符串常量 | "a", "ab"，"12356" |
注意：
1、不以f结尾的实型常量为double类型
2、以f结尾的实型常量为float类型
2、自定义常量有两种方式
- #define定义的预处理常量，一般出现在函数体的外部
- const声明的常量 一般出现在函数体的内部
3、系统定义的常量
C语言提供了一些常量库，比如有：float.h、limits.h等，这些常量同样受操作系统平台的影响会在不同的平台下不一样。
float.h
#include<stdio.h>
#define PP 3.14 //define定义的预处理常量
#include<float.h>
#include<limits.h> //float.h limits.h是c语言的常量库，提供了一些系统定义的常量
int main() {//1、常量：直接常量 自定义常量 系统定义常量printf("直接常量 整型：%d\n", 100);printf("直接常量 浮点型 %f\n", 3.15);printf("直接常量 字符型 %c\n", 'a');//2、自定义常量有两种定义方式：//1)、#define来定义 又叫预处理常量 这种方式一般出现在函数体的外部//2)、const定义常量 这种方式一般出现在函数体的内部const double pi = 3.14;//常量//pi = 2.18;//报错 常量不允许修改printf("define定义的预处理常量:%f\n",PP);printf("const定义的常量：%lf\n", pi);//3、系统定义的常量// 注意：这些常量同样受操作系统的影响会在不同的平台下不一样//float类型能够表示的最大最小值printf("float类型的最大值：%lf\n",FLT_MIN);printf("float类型的最小值：%lf\n", FLT_MAX);printf("%lf %E\n", FLT_MAX, FLT_MAX); // 3.402823E+38//char类型位数以及能够表示的最大最小值printf("char类型的最小值：%d\n", CHAR_BIT);//8printf("char类型的最小值：%d\n", CHAR_MIN);printf("char类型的最大值:%d\n", CHAR_MAX);//short类型的最大、最小值printf("short类型的最大值:%d\n", SHRT_MAX);printf("short类型的最小值：%d\n", SHRT_MIN);//int类型的最大值 最小值printf("int类型的最大值：%d\n", INT_MAX);printf("int类型的最小值:%d\n", INT_MIN);//long int类型的最大、最小值printf("long类型的最大值:%ld\n", LONG_MAX);printf("long类型的最小值:%ld\n", LONG_MIN);return 0;}
四.数值表示
数据在计算机中是以二进制形式存储的
1、负数在计算机中以补码的方式存储
2、非负数在计算机中以原码的方式存储 (原 反 补 三码合一)
3、八进制以原码存储
4、十六进制以原码存储
计算机数据的存储使用二进制补码形式存储 ，并且最高位是符号位。
正数：最高位是0
负数：最高位是1
规定1：正数的补码与反码、原码一样，称为三码合一
规则2：负数的补码与反码、原码不一样
负数的原码：把十进制转为二进制，然后最高位设1
负数的反码：在原码的基础上，最高位不变，其余位取反（0变1，1变0）
负数的补码：反码+1
4.1进制
-
进制也就是进位制，是人们规定的一种进位方法
-
对于任何一种进制—X进制，就表示某一位置上的数运算时是逢X进一位
-
十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位
| 十进制 | 二进制 | 八进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | A |
| 11 | 1011 | 13 | B |
| 12 | 1100 | 14 | C |
| 13 | 1101 | 15 | D |
| 14 | 1110 | 16 | E |
| 15 | 1111 | 17 | F |
| 16 | 10000 | 20 | 10 |
4.2 二进制
十进制转进制 除n，倒序
1001 1001 ----八进制 （每三位一组） 0 231 ---十六进制 （每四位一组）0x99
-
二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数
-
它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”
-
当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的
-
十进制转化二进制的方法：
-
用十进制数除以2，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果
4.3 八进制
-
八进制，Octal，缩写OCT或O，一种以8为基数的计数法，采用0，1，2，3，4，5，6，7八个数字，逢八进1
-
一些编程语言中常常以数字0开始表明该数字是八进制
-
八进制的数和二进制数可以按位对应（八进制一位对应二进制三位），因此常应用在计算机语言中
-
八进制和二进制互转：
-
十进制转化八进制的方法：
-
用十进制数除以8，分别取余数和商数，商数为0的时候，将余数倒着数就是转化后的结果
4.4 十六进制
-
十六进制（英文名称：Hexadecimal），同我们日常生活中的表示法不一样，它由0-9，A-F组成，字母不区分大小写
-
与10进制的对应关系是：0-9对应0-9，A-F(或a-f)对应10-15
-
十六进制的数和二进制数可以按位对应（十六进制一位对应二进制四位），因此常应用在计算机语言中
-
十六进制和二进制互转：
4.5、c语言如何表示进制数
| 十进制 | 以正常数字1-9开头，如15 |
|---|---|
| 八进制 | 以数字0开头，如017 |
| 十六进制 | 以0x或0X开头，如0xf |
| 二进制 | 以0b或0B开头，如0b1111 |
#include<stdio.h>
int main() {//进制//十进制赋值int a = 17;//八进制赋值int b = 017;//十六进制赋值int c = 0xf;//二进制赋值int d = 0b111;printf("a,b,c,d分别是：%d,%d,%d,%d", a, b, c, d);printf("a,b,c,d分别是：%d,%#o,%#x,%d", a, b, c, d);return 0;
}
4.6、数值的存储方式
计算机底层都是存储数据都是采用二进制，但二进制也有几种，比如：原码、反码、补码。接下来我们来看看他们之间的关系的意义作用.
原码十进制数按照：除二取余、倒序排列，得到的就是原码。
- 10 -> 0000 1010
- -10 -> 1000 1010
- -1 -> 1000 0001
- 1 -> 0000 0001
问题:原码在做计算的时候会出现一些问题，比如正负数的加法运算，以及零的问题。
●正负数加法 -1 + 1 = 0
1000 0001 + 0000 0001 ---------------- 1000 0010 -> -2 ?
●正负零 +0 和 -0 十进制数字0，占了两个二进制；
0000 0000 1000 0000
反码为了解决上面的问题，出现了反码，反码的计算规则如下：
- 正数的反码就是原码本身；
- 负数的反码是按位取反（但符号位不变）；
示例●1 -> 0000 0001 -> 0000 0001 ●-1 -> 1000 0001 -> 1111 1110
0000 0001 + 1111 1110 ----------------- 1111 1111
1111 1111 是运算完之后的结果，但要注意，这时还是反码，需要重新返回来：1000 0000 。反码解决了正负数加法问题，但正负零的问题还是存在。
补码正数的补码就是原码本身；负数的补码就是在反码的基础上+1；
● 1 -> 0000 0001 -> 0000 0001 -> 0000 0001 三码合一
●-1 -> 1000 0001 -> 1111 1110 -> 1111 1111
0000 0001 + 1111 1111 ---------------- 0000 0000 正负0： 0000 0000 1000 0000 ->1111 1111->0000 0000
补码在正负数加减法运算时没问题，也不会出现正负零占两个二进制。
但 1000 0000 不表示为负零，用来表示什么呢？计算机其实默认把8位有符号二进制 1000 0000 表示为 -128 。*****
#include<stdio.h>
int main() {char c = 'A';//字符型 1个字节short s = 100;//短整型 2个字节long l = 12;//长整型 4个字节int m = 9;//整型 2/4字节 VC下就是4个字节float p = 3.1415926;//单浮点 4个字节double d = 2.19;//双浮点 8个字节char* name = "murphy";//字符串类型 8个字节unsigned int ui = 90;//无符号整型 2/4个字节printf("%lld\n", sizeof(char*));//8 ****//整型输出printf("c=%d\n", c);//整型int %dprintf("s=%hd\n", s);//短整型short %hdprintf("l=%ld\n", l);//长整型long %ldprintf("m=%d\n", m);//实型输出printf("p=%f\n", p);//单精浮点数float %f printf("p=%.5f\n", p);//.5表示保留5位小数printf("d=%.2lf\n", d);// 双精度浮点数 %lf .2表示保留2位小数//字符型输出printf("c=%c\n", c);//字符型 %c//字符串类型printf("name=%s\n", name);//字符串类型char* %s//无符号整型printf("ui=%u\n", ui);//无符号整型 unsigned int %u//八进制和十六进制 可以加上前缀# 自动输出八进制和十六进制数据printf("bbb=%#o\n", 120); //输出八进制 %#oprintf("ccc=%#x\n", 120); //输出十六进制 %#x//内存地址printf("ps=%p\n", &c);//输出变量的内存地址printf("ps3=%p", &ui);return 0;
}
移码●补码符号位取反就是移码，一般用来计算浮点数作为阶码和比较数的大小使用。 （了解一下概念即可）
| 十进制数 | 补码 | 移码 |
|---|---|---|
| +15 | 0000 1111 | 1000 1111 |
| -15 | 1111 0001 | 0111 0001 |
| +0 | 0000 0000 | 1000 0000 |
五.输入输出
5.1 输出语句
- 输出：将程序的运行结果输出到控制台或终端窗口中
- printf语法格式:
- printf("输出格式符",输出项）
printf("我今年%d岁了\n",age) //%d表示整型占位符
格式化占位符
| 打印格式 | 对应数据类型 | 含义 |
|---|---|---|
| %c | char | 字符型，输入的数字按照ASCII码相应转换为对应的字符 |
| %hd | short int | 短整数 |
| %hu | unsigned short | 无符号短整数 |
| %d | int | 接受整数值并将它表示为有符号的十进制整数 |
| %u | unsigned int | 无符号10进制整数 |
| %ld | long | 接受长整数值并将它表示为有符号的十进制整数 |
| %f | float | 单精度浮点数 |
| %lf | double | 双精度浮点数 |
| %e,%E | double | 科学计数法表示的数，此处"e"的大小写代表在输出时用的"e"的大小写 |
| %s | char * | 字符串。输出字符串中的字符直至字符串中的空字符（字符串以'\0‘结尾，这个'\0'即空字符） |
| %p | void * | 以16进制形式输出指针 |
| %o | unsigned int | 无符号8进制整数 |
| %x,%X | unsigned int | 无符号16进制整数，x对应的是abcdef，X对应的是ABCDEF |
#include<stdio.h>
int main() {char c = 'A';//字符型 1个字节short s = 100;//短整型 2个字节long l = 12;//长整型 4个字节int m = 9;//整型 2/4字节 VC下就是4个字节float p = 3.1415926;//单浮点 4个字节double d = 2.19;//双浮点 8个字节char* name = "murphy";//字符串类型 8个字节unsigned int ui = 90;//无符号整型 2/4个字节printf("%lld\n", sizeof(char*));//8 ****//整型输出printf("c=%d\n", c);//整型int %dprintf("s=%hd\n", s);//短整型short %hdprintf("l=%ld\n", l);//长整型long %ldprintf("m=%d\n", m);//实型输出printf("p=%f\n", p);//单精浮点数float %f printf("p=%.5f\n", p);//.5表示保留5位小数printf("d=%.2lf\n", d);// 双精度浮点数 %lf .2表示保留2位小数//字符型输出printf("c=%c\n", c);//字符型 %c//字符串类型printf("name=%s\n", name);//字符串类型char* %s//无符号整型printf("ui=%u\n", ui);//无符号整型 unsigned int %u//八进制和十六进制 可以加上前缀# 自动输出八进制和十六进制数据printf("bbb=%#o\n", 120); //输出八进制 %#oprintf("ccc=%#x\n", 120); //输出十六进制 %#x//内存地址printf("ps=%p\n", &c);//输出变量的内存地址printf("ps3=%p", &ui);return 0;
}
补充：
%zu****：用于输出 sizeof() 返回值是 size_t****类型
size_t类型的无符号整数。
size_t是一个无符号长长整数类型
5.2 输入语句
-
输入：接收用户****输入的数据的过程
-
scanf语法格式：
-
scanf("格式化字符串",&变量1，&变量2,......);
-
格式化字符串用于指定输入的数据类型及其格式
-
变量1、变量2等是要读入的变量的地址
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int main() {int a;printf("请输入年龄:");//scanf_s("%d", &a); scanf("%d", &a); //&a代表变量a的内存地址printf("5年后您的年龄是:%d", a + 5);return 0;
}
这个错误信息提示你的代码中使用了 scanf 函数，这个函数可能存在安全问题，你可以考虑使用 scanf_s 函数来代替，以确保代码的安全性。
解决方法有两种：
1、将scanf改为scanf_s即可
2、在代码的最上行加入：#define _CRT_SECURE_NO_WARNINGS
六.运算符
6.1 算数运算符
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| + | 加 | 10 + 5 | 15 |
| - | 减 | 10 - 5 | 5 |
| * | 乘 | 10 * 5 | 50 |
| / | 除 | 10 / 5 | 2 |
| % | 取模(取余) | 10 % 3 | 1 |
| ++a | 前自增 | a=2; b=++a; | a=3; b=3; |
| a++ | 后自增 | a=2; b=a++; | a=3; b=2; |
| --a | 前自减 | a=2; b=--a; | a=1; b=1; |
| a-- | 后自减 | a=2; b=a--; | a=1; b=2; |
#include<stdio.h>
int main() {//算术运算符int a = 12;float b = 3.14;printf("a+b=%f\n", a + b); //+printf("a-b=%f\n", a - b); //-printf("a*b=%f\n", a * b);//*printf("2/b=%f\n", a / b);// 除/ //两数相除，如果想得到小数的结果，分子分母必须有一个为小数，否则结果只能是整数printf("12/3=%f\n", 12/3.0); printf("12对5取余：%d\n", 12 % 5);//% 取余//前置++ 先加后用int m = 9;int n = ++m;printf("前置++:%d\n", n); //10printf("m的值为：%d\n", m);//10//后置++ 先用后加int p = 9;int q = p++;printf("后置加加:%d\n", q);//9printf("p的值为:%d\n", p);//10//同理，前置-- 先减后用 后置--先用后减int j = 5;int k = --j;printf("前置--：%d\n", k);//4printf("%d\n", j);//4int count = 5;int cc = count--;printf("后置--：%d\n", cc);//5printf("%d\n", count);//4return 0;
}
6.2 赋值运算符
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| = | 赋值 | a=2; b=3; | a=2; b=3; |
| += | 加等于 | a=0; a+=2;等同于 a = a + 2; | a=2; |
| -= | 减等于 | a=5; a-=3;等同于 a = a - 3; | a=2; |
| *= | 乘等于 | a=2; a*=2;等同于 a = a * 2; | a=4; |
| /= | 除等于 | a=4; a/=2;等同于 a = a / 2; | a=2; |
| %= | 模等于 | a=3; a%=2;等同于 a = a % 2; | a=1; |
6.3 比较运算符
C 语言的比较运算中， “真”用数字“1”来表示， “假”用数字“0”来表示。
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| == | 相等于 | 4 == 3 | 0 |
| != | 不等于 | 4 != 3 | 1 |
| < | 小于 | 4 < 3 | 0 |
| > | 大于 | 4 > 3 | 1 |
| <= | 小于等于 | 4 <= 3 | 0 |
| >= | 大于等于 | 4 >= 1 | 1 |
6.4 逻辑运算符
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| ! | 非 | !a | 如果a为假，则!a为真；如果a为真，则!a为假。 |
| && | 与 | a && b | 如果a和b都为真，则结果为真，否则为假。 |
| || | 或 | a || b | 如果a和b有一个为真，则结果为真，二者都为假时，结果为假。 |
6.5 位运算符
常见的位运算符号有&、|、^、~、>>、<<，分别代表着如下含义：
| 运算符 | 术语 | 示例 | 结果 |
|---|---|---|---|
| & | 按位与运算 | 011 & 101 | 2个都为1才为1，结果为001 |
| | | 按位或运算 | 011 | 101 | 有1个为1就为1，结果为111 |
| ^ | 按位异或运算 | 011 ^ 101 | 不同的为1，结果为110 |
| ~ | 取反运算 | ~011 | 100 |
| << | 左移运算 | 1010 << 1 | 10100 |
| >> | 右移运算 | 1010 >> 1 | 0101 |
6.5.1 按位与（&）运算：位与位进行比较，如果都为1，则为1，否则为0；
/按位运算符：针
/*1、按位 与运算 & 位与位进行比较 如果都为1，则为1，否则为0
* 例如：40 & 15 =
* 40转成二进制： 0010 1000
* 15转成二进制： 0000 1111
*
* 0010 1000
* 0000 1111
* ------------
* 0000 1000======>8
*/
printf("%d\n", 40 & 15);//8
6.5.2 按位或（|）运算：位与位进行比较，如果都为0，则为0，否则为1；
/*
2、按位或|： 位与位进行比较 如果都为0则为0，否则为1
例如：40 | 150010 10000000 1111-----------0010 1111======>47
*/
printf("%d\n", 40 | 15);//47
6.5.3 按位异或运算：位与位进行比较，相同为0，不同为1；
/*3、异或运算^：位与位进行比较 相同为0 不同为1
* 例如：40 ^15
* 0010 1000
* 0000 1111
* --------------
* 0010 0111====>39
*/
printf("%d\n", 40 ^ 15);//39
6.5.4 按位取反运算：补码取反，再将取反后的补码转为原码；
/*** 按位取反运算：补码取反，再将取反后的补码转为原码。* 1、正数取反：由于正数的原码和补码是相同的，取反的方式简便了些。* 补码（原码） -> 取反 -> 补码逆运算 -> 反码逆运算（符号位不变） -> 取反后的原码* 2、负数取反：* 原码 -> 反码 -> 补码 -> 取反 -> 取反后的补码即原码* 示例：* 原码（补码） 取反的补码 补码逆运算-1 反码逆运算* ~40 = 0010 1000 -> 1101 0111 -> 1101 0110 -> 1010 1001 = -41** 原码（补码） 取反的补码 补码逆运算-1 反码逆运算* ~15 = 0000 1111 -> 1111 0000 -> 1110 1111 -> 1001 0000 = -16** 原码 反码 补码 取反* ~-15 = 1000 1111 -> 1111 0000 -> 1111 0001 -> 0000 1110 = 14*/
printf("~40 = %d\n", ~40);
printf("~15 = %d\n", ~15);
printf("~-15 = %d\n", ~(-15));
6.5.5 左移运算符
将数字的二进制补码全部向左移动，空出来的位置补0，超出范围的二进制数丢弃；
有符号的数据左移后最高位如果为1，则需要进行逆运算；
6.5.6右移运算符 >>
逻辑移位****：将数字的二进制补码全部向右移动，空出来的位置补0，超出范围的二进制数丢弃
算术移位：左边移入的位由原先该值的符号位决定，符号位为1，则移入的位均为1，符号位为0，则移入的位均为0，这样能保证原数的正负形式不变
标准规定，无符号值执行的所有位移操作都是逻辑移位，对于有符号值，到底采用逻辑移位还是算术移位取决于编译器。
6.5.7 运算符的优先级
| 优先级 | 运算符 | 名称或含义 | 使用形式 | 结合方向 | 说明 |
|---|---|---|---|---|---|
| 1 | [] | 数组下标 | 数组名[常量表达式] | 左到右 | -- |
| () | 圆括号 | (表达式）/函数名(形参表) | -- | ||
| . | 成员选择（对象） | 对象.成员名 | -- | ||
| -> | 成员选择（指针） | 对象指针->成员名 | -- | ||
| 2 | - | 负号运算符 | -表达式 | 右到左 | 单目运算符 |
| ~ | 按位取反运算符 | ~表达式 | |||
| ++ | 自增运算符 | ++变量名/变量名++ | |||
| -- | 自减运算符 | --变量名/变量名-- | |||
| ***** | 取值运算符 | *指针变量 | |||
| & | 取地址运算符 | &变量名 | |||
| ! | 逻辑非运算符 | !表达式 | |||
| (类型) | 强制类型转换 | (数据类型)表达式 | -- | ||
| sizeof | 长度运算符 | sizeof(表达式) | -- | ||
| 3 | / | 除 | 表达式/表达式 | 左到右 | 双目运算符 |
| ***** | 乘 | 表达式*表达式 | |||
| % | 余数（取模） | 整型表达式%整型表达式 | |||
| 4 | + | 加 | 表达式+表达式 | 左到右 | 双目运算符 |
| - | 减 | 表达式-表达式 | |||
| 5 | << | 左移 | 变量<<表达式 | 左到右 | 双目运算符 |
| >> | 右移 | 变量>>表达式 | |||
| 6 | > | 大于 | 表达式>表达式 | 左到右 | 双目运算符 |
| >= | 大于等于 | 表达式>=表达式 | |||
| < | 小于 | 表达式<表达式 | |||
| <= | 小于等于 | 表达式<=表达式 | |||
| 7 | == | 等于 | 表达式==表达式 | 左到右 | 双目运算符 |
| ！= | 不等于 | 表达式!= 表达式 | |||
| 8 | & | 按位与 | 表达式&表达式 | 左到右 | 双目运算符 |
| 9 | ^ | 按位异或 | 表达式^表达式 | 左到右 | 双目运算符 |
| 10 | | | 按位或 | 表达式|表达式 | 左到右 | 双目运算符 |
| 11 | && | 逻辑与 | 表达式&&表达式 | 左到右 | 双目运算符 |
| 12 | || | 逻辑或 | 表达式||表达式 | 左到右 | 双目运算符 |
| 13 | ?: | 条件运算符 | 表达式1?表达式2: 表达式3 | 右到左 | 三目运算符 |
| 14 | = | 赋值运算符 | 变量=表达式 | 右到左 | -- |
| /= | 除后赋值 | 变量/=表达式 | -- | ||
| *= | 乘后赋值 | 变量*=表达式 | -- | ||
| %= | 取模后赋值 | 变量%=表达式 | -- | ||
| += | 加后赋值 | 变量+=表达式 | -- | ||
| -= | 减后赋值 | 变量-=表达式 | -- | ||
| <<= | 左移后赋值 | 变量<<=表达式 | -- | ||
| >>= | 右移后赋值 | 变量>>=表达式 | -- | ||
| &= | 按位与后赋值 | 变量&=表达式 | -- | ||
| ^= | 按位异或后赋值 | 变量^=表达式 | -- | ||
| |= | 按位或后赋值 | 变量|=表达式 | -- | ||
| 15 | ， | 逗号运算符 | 表达式,表达式,… | 左到右 | -- |
