C 语言的基础语法

第一部分 软件的安装

1.推荐使用 visual studio 编辑器

https://visualstudio.microsoft.com/zh-hans/编辑器的下载网址安装流程 和一般软件一样我是百度看了别人的博客 建议性的安装软件比较大  但是学习么  先学完再说

2.Vc6++

这个软件 很多大学都在用   可能你也用过
你说他能用么  能用  但是好用么 我觉得还可以在优化一下
而且这个软件几乎十几年的历史了

3.学校 自己教学用的软件

一般在大学  有的会 使用一些绿色的软件
后面会提示 是实验室使用

第二部分 入门hello world

内容

#include<stdio.h>int main() {printf("hello world");return 0;
}

流程就是

1. 打开visual studio 的编辑器
2. 可能会让你登录 可以不登录 直接跳过
3. 新建文件 ---->选择文件的存放位置
4. 之后就会有个 介绍文件
5. ctrl +a 回车 删除
6. 写下上面文件的内容就行了
7. 然后进行选择 最上面导航的 生成 (B) ----生成 解决方案
8. 最上面导航的 调试 (D) ----开始执行(不调试)

第三部分 hello world-基本构成

#include<stdio.h>
//引入头文件   这里面放着printf的定义 如果你使用printf
//就需要使用这个头文件 提前声明printf  不然会报错//定义函数add
int add(int a, int b)
{return a + b;
}//定义入口文件 main 唯一一个的main
int main()
{printf("输出信息 hello world \n");int result;result = add(12, 11);printf("result的和就是%d\n", result);return 0;
}

​ 基本理解 hello world 用到的构成内容

• 函数
• 主函数
• 变量
• 关键字
• 常量
• printf
• include

函数

函数就是一个功能  比如车 有行驶跑的功能
加油(输入) ====发动机(处理)=======产生热能推动轮子前进(输出)函数就是如此
比如 计算一个相加的函数(能量的类型)  功能名字  (输入 油)
{发动机执行过程return 输出移动轮子的能量
}(输出值的类型)  函数名字  (参数类型 参数1,参数类型 参数2)
{执行过程return 输出值
}int add (int a,int b)
{return a+b
}
这就是一个函数是

主函数

上面我们已经自己定义好了一个 add函数 ，那我们需要怎样来使用它呢？ add函数 能直接运行嘛？ 答案是不行的。

所有的C语言代码都有一个起始入口，而这个入口就是 主函数main 。进入了主函数以后，才能经由主函 数来调用其他函数。 这也意味着，每个C语言代码，只能有且只有一个main函数。 我们把代码稍微修改，现在代码如下。

//例子
#include <stdio.h>
int add(int a, int b)
{return a + b;
}
int main()
{int result;result = add(2, 3);printf("%d", result);return 0;
}

int main() // 这是主函数
{return 0; // 主函数返回值
}主函数是一个为mian 命名的函数
而且一个文件中只能存在 一个main文件
有时也成为了 入口文件函数的执行  需要在main中调用 自然地，我们会想到，主函数是被谁调用的？主函数的返回值必须是 int 吗？
主函数在程序开始的时候被自动调用，不需要在程序内主动调用主函数。
而主函数的返回值会返回给调用这个程序的程序。
C语言标准中规定主函数有返回值且必须是 int 。如果程序正常结束，一般将返回值设置为0。

变量

变量就是一个容器 他可以接受相同类型的任意值

int bian
bian =12
bian =55变量就是存放值的地方但我们需要值的时候可以直接 去找bian 去那值存值

变量声明

变量的类型 变量名字
int  result    一个存放整型结果的变量容器类型  容器的名字
碗         大米   一个存放大米的碗  可以放黑米 白米  糯米....

赋值

就是给值的意思 常用于给变量存值

int result
result   =   12
意思是吧12 存放到result中
下次可以直接从result获得12

常量

就是不变量的

例如 常见的 π 默认π=3.14

标识符

标识符 就是用来表示的一种符号

可用于变量 函数 实例的名字

比如 你的名字 用来表示你这个人的称呼

int result  其中 result 就是标识符  

标识符的构造有一定的规则

1.标识符 有数字 字母 _ 构成
2.标识符 不能以数字开头  可以字母 _开头
12a 是不性的
a12 是可以的

字面量

字面量说白了就是一个值的意思

比如 12 就是字面意思12 “我爱你” 就是字面意思我爱你

关键词

系统为了运行 已经提前定义好的东西

例如 if else 你就不能在用了

printf函数

#include <stdio.h>
int main()
{printf("Hello World\n");return 0;
}

由单词 print（打印） 和单词 format（格式） 的首字母f组成，意为格式化打印。

可以输出一数据

printf("输出的内容");peintf("%d",a);  按照格式化的输出  就是把%d 替换为a输出出去

#include命令

printf函数 并不是我们定义的函数，而是系统自带的函数。这个函数被写在文件 stdio.h 中，我们要使 用 printf 就必须先让编译器理解 printf 。 我们假定 printf 的函数定义写在文件 stdio.h 中，用 #include 命令，可以将文件 stdio.h 的代码复制 到我们的代码中。

第四部分 整数 数据类型

1.C语言中 整型的类型有

char short int long long long

	char	short	int	long	long long
字节	1	2	4	4	8

都是整数 问什么要分这么多类呢

算机通过晶体管的开关状态来记录数据。它们通常8个编为一组，我们称之为字节。而晶体管有开关
两种状态，一个字节有8个晶体管，因此一个字节可以拥有2的八次方个不同的状态。让每一种状态对应
一个数值，这样一个字节可以表示256个不同数值。计算机存储资源是非常珍贵而
稀缺的。对存储资源，程序员可能恨不得把一块掰成两块来用。如果只想表达0到100以内的数值，那么
一个字节就足够了，何必用两个字节来存储

2.使用sizeof 获得字节大小

#include<stdio.h>
int main() {char c = 4;short s = 12123;int i = 1212;long l = 5555;long long ll = 62;printf("char的字节%d\n",sizeof(c)); //1printf("short的字节%d\n", sizeof(s));//2printf("int的字节%d\n", sizeof(i));//4printf("long的字节%d\n", sizeof(l));//4printf("long long的字节%d\n", sizeof(ll));//8return 0;}int和long均占用4个字节。这并未违反C语言标准，C语言标准规
定高级别的类型取值范围不得小于低级别的类型，但是它们可以是一致的。

3.位 字节 范围

在很多语言中 其实就是计算中

位

使用二进制表示数据

100000000 ----这里面的每一个0或1 就是一个位 也称之为b 小b

字节

但是你可能听的很多的就是字节

字节其实就是8个 位组成的几个 数据段

10000000 ----这就是一个字节 一个字节=8位 1B=8b

范围

毕竟二进制 也是数值

一个 位 的范围就是 0-1 一个位只有两个状态 0 或1

那么一个字节 就是8个位二进制的数据

00010010 -----0->2^8 -1 0-255

为什么要减-1 因为 是从零开始的 012 就是三个 123 就是三个

那么 总共能放 256个 从0开始 到255 正好256 如果从1开始 到256正好256

无符号整形

int的范围 是四个字节 他的范围 4*8=32位 2^32次方个放数据的空间

但是int 是放不了的 因为 int 是会区分正负的

正负就需要一个位 那么就剩下31个位了

所以int 的范围 -2^31 --> +2^31-1

那么就有问题了 可不可以不要正负号 就是纯纯的正数 ?有的

那就是无符号整形

如果你确定你不会用到负数，那么请使用unsigned关键词。表明这个数据类型，是不带有符号位的。既 然不带有符号位了，那么原本留给符号位的那一个二进制位，可以用来表示数值

int a;  包含正负 -2^31   -->     +2^31-1
unsigned int a ; 只有正数  0 --->2^32-1

第五部分 浮点(小数)类型

我们来讨论一下类似于1.234567，0.00001，这类非整数的数据。

浮点类型：float

#include <stdio.h>
int main()
{float a = 1.234567;float b = 0.00001;float c = 365.12345;printf("%f\n", a);printf("%f\n", b);printf("%f\n", c);return 0;
}标准规定，float类型必须至少能表示6位有效数字，并且取值范围至少是10^-37~10+37。365.12345;  365.123可以精准  但是之后的比一定确认

浮点类型：double

#include <stdio.h>
int main()
{double a = 1.234567;double b = 0.00001;double c = 365.12345;printf("%f\n", a);printf("%f\n", b);printf("%f\n", c);return 0;
}次 365.12345 也是正确的了。
但是，请注意 double 类型也是有精度范围的。如果是更高精度的数据， double 也会出现误差。
我们日常的应用中，不会苛求一个精度完美的数值，是会允许存在一定误差范围的。但是，如果涉及高
精度领域的计算时，需要额外使用特殊的方法进行数值计算，以尽量减少误差。

字节大小

#include <stdio.h>
int main()
{float a = 1.234567;double b = 0.00001;double c = 365.12345;printf("%d\n", sizeof(a));//4printf("%d\n", sizeof(b));//8printf("%d\n", sizeof(c));//8return 0;
}

第六部分 变量 常量

变量 与常量

1. 变量与常量
在整个程序的运行过程中，没有变化且不能变化的，我们称之为常量。
在程序运行期间，可以改变并且有可能会改变的，我们称之为变量。

变量的声明

类型 标识符 ;
int num ;     //定义了一个存放整型的  名字及叫做  num变量注意num的命名
要符合 标识符的规范
1.不能数字开头  int 12a (错误实例)
2.有字母 数字 _ 构成   +12(错误示例)
3.你能是关键字  例如 int int (错误示例)

变量的有效访问

标识符必须经过声明或定义才能正常被编译器识别，而关键词可以直接使用。
因此，要让标识符被编译器看做是一个变量，必须将标识符在使用前声明为一个变量。

#include <stdio.h>
int main()
{int a;a=12printf("%d\n", a); // 正确， 变量使用前被声明了。return 0;
}
//换个写法
#include <stdio.h>
int main()
{//此时使用 a  但是a 在此之前还未定义声明  //系统不知道 a 代表什么类型 有什么东西存放其中  就会报错printf("%d\n", a); // 找不到a的声明  报错int a;return 0;
}

初始化 和赋值

#include <stdio.h>
int main()
{int a;printf("%d\n", a);return 0;
}
执行的时候会报错  因为此时a 声明了
但是没有初始化  也就是说此时a的值是一个未知数
所以我们要给a 初始化

初始化的方式

方式1

#include <stdio.h>
int main()
{int a=4;//声明 存放int 的a变量  初始化为4printf("%d\n", a);return 0;
}

方式2

#include <stdio.h>
int main()
{int a;a=4;//声明 存放int 的a变量 //在把4存放到 a中printf("%d\n", a);return 0;
}

以上的两种当时 让a 有了具体的值 就不会报错了

初始化和赋值的区别

初始化 就是在创建变量a的时候直接给一个值

int a=12;//初始化

赋值 创建变量之后 使用= 赋值操作 把值村放进去

int a;//定义
a=12;//赋值

区别

初始化 只能存在一次
而赋值可以进行多次int a=12;
int a=14;  此时就会报错int a;
a=12;
a=14; //正常运行  a存放的是14

常量

常量是程序中，一开始就被写死在代码中，且不能被改变的量

分为字面常量和符号常量

字面常量

例如：100，200，1.3344，"HelloWorld"，被称之为字面常量。
字面常量不需要声明，并且编译器通过它的写法可以立即判断出它的类型字面常量就是所谓的 '值'  可见的一个值常见类型
数字字面常量 1231 21 12
小数字面常量 2.02
字符串字面常量 "hello"

符号常量 定义常量

#define PRICE 3

#include <stdio.h>
#define PRICE 3
int main()
{//PRICE=12  //就会报错printf("衣服的价格是%d,卖出去3件收入%d", PRICE, PRICE * 3);return 0;
}PRICE 就是定义的常量

第七部分 字符 常量与变量

定义：字符常量由单引号包括。

类似于’a’ , ‘b’ , ‘c’ , ‘1’ , ‘2’。这样的都是字符常量。 字符常量通常只写一个字符，如果需要多个字符，请使用字符串"ab"。

C语言 有明确的区分 单引号 用于字符char类型 ""双引号用于字符串

’ a’ 字符 a

“a” 字符串 a

字符的大小

探究字符类型占用空间 我们可以用 sizeof 来探究一下，字符类型在计算机内部所占用的空间大小

#include <stdio.h>
int main()
{printf("字节大小 %d",sizeof('a'));return 0;
}

字符类型常量在C编译器将字符常量看做整型，因此占用4个字节。而在C++编译器中只占1个字节。
在Visual Studio中，如果你使用后缀名c为后缀名，将使用C编译器。而使用cpp为后缀名，将使用C++编译器

#include <stdio.h>
int main()
{printf("字节大小 %d",sizeof(char));char a = 'a';printf("字节大小 %d", sizeof(a));return 0;
}都占用一个字节

char 字符和整数的关系----ASCII

计算机没必要直接存储字符，可以用某个数值来代表某个字符。 而这个映射关系，被称作美国信息交换标准代码（American Standard Code for Information Interchange）。我们一般将其简称为 ASCII 。

字符在计算机内部用整数表示，并且只需要用到0至127的整数范围。 若要显示成实际的字符，由printf函数根据占位符 %c 将其转换为真实的字符并打印在控制台上。 既然这样，没必要为字符专门新设计一种类型，字符类型与只占用一个字节的整数类型完全一致。 我们之前学习过仅占一个字节的整型类型— char 类型。为了表示这个类型也能用于字符，这种类型使 用英语character的缩写 char 来表示

字符变量

char a='a';
a 就是一个字符变量

#include <stdio.h>
int main()
{char a = 'a';printf("字节大小 %d", a);//97printf("字节大小 %c", a);// 'a'return 0;
}

特殊情况

#include <stdio.h>
int main()
{char a = 'a';char b = '\n';char c = 'c';printf("字节大小 a=%d,b=%d,c=%d", a,b,c);//97 10 99printf("字节大小 a=%c,b=%c,c=%c", a,b,c);//到 \n 会识别为换行的字符  进行换行操作return 0;
}总结就是 %c 输出的是char 的字符  %d 输出的是char 的数字

字符串的长度

#include <stdio.h>
int main()
{printf("hello world 的长度 %d",sizeof("hello world"));//12return 0;
}原来在字符串结尾处，为了标记这个字符串已经结束了，会在字符串会多占用一个字节，并在这个字节
里面填数值0，用于标识字符串结束

转义字符

#include <stdio.h>
int main()
{printf("hello0world ");///hello0worldprintf("hello\0world ");//helloreturn 0;
}hello0world的0  字符串有字符构成 0 是字符的0  对应数值48
hello\0world   \0 是转义的 0 就是数值0  0代表字符串的截断
我们需要的是数值 零 ，而不是字符 零 。

\数值 被称作转义字符。
转义字符虽然写法上有多个字符，实际上它对应ASCII表中的一个字符。于直接在字符串中写0会被认为是字符0，而 \数值 这种写法，可以让我们输入数值0。但是，这个数
值不是用十进制来表示的，而是用八进制。#include <stdio.h>
int main()
{printf("\110\145\154\154\157"); Helloreturn 0;
}

字符和ascll 码 是对应的关系

字符串是有字符构成的

根据ascll 直接输出字符 \八进制数据

存在一些特殊的 \八进制 比如 \12 就是换行的数据

\12 和\n 效果一致 之所以有\n 是为了好记 \12 看起来也不直接

#include <stdio.h>
int main()
{//printf("\110\145\154\154\157");printf("\41\42\43\44\45\46");//根据ascll的八进制  找到对应的字符输出字符printf("\12\n");//为了方便记忆 出现了\n  \n和\12 一样输出ascll码 就是换行字符return 0;
}

第八部分 printf函数

printf特点

#include <stdio.h>
int main()
{int a = 1;float b = 2.345;char c = 'a';printf("整型a为%d 浮点b为%f 字符c为%c 字符c对应的ASCII码为%d", a, b, c, c);return 0;
}

1. printf 是一个变参函数。(参数的数量和类型不确定)

   printf("%d   %f",12,12.3)
   printf("%c",'a')
   参数不确定
   

2. printf 的第一个参数是字符串。

   printf("%c",'a')
   "%c" 必须是字符串 也就是必须双引号 引用
   

3. printf 的第一个参数是需要输出的字符以及需要被替换的占位符。

   printf("我将输出字符%c",'a')
   第一个参数是字符串 字符串包含了占位符
   这个字符串会对外输出到控制台
   

4. printf 的第二及后续参数将依次替换占位符。

   printf("我将输出字符%c,b的ascll数值是%d",'a','b')占位符出现的早晚 后后面的参数是对应的
   'a'-----给了 %c
   'b'---给了%d
   

5. 占位符的类型和数量需要与后续的参数类型和数量对应

   printf("我将输出字符%c,b的ascll数值是%d",'a','b')
   'a'-----给了 %c
   'b'---给了%d
   printf("我将输出字符%c,b的ascll数值是%d",'b','a')
   'b'-----给了 %c
   'a'---给了%d

2. 整型类型的占位符

有符号整数

对于有符号位的整型 char ， short ，传入 printf 的可变参数时，会被提升为 int 。而比 int 更高级的 整型则不发生变化

所以，在处理 char ， short ， int 时，均可使用 %d 来占位。 而在Visual Studio中 int 与 long 的范围一致，按理来说也可以使用 %d 来占位。 但是为了程序的可移植性，在切换到别的平台下时， int 和 long 有可能不一致。 所以，请使用 %ld 来为 long 占位。更高级的 long long 则需要使用 %lld 来占位。

结论：

char，short，int使用 %d 。

long使用 %ld 。

long long使用 %lld 。

无符号整数

于无符号位的整型 unsigned char ， unsigned short ，传入 printf 的可变参数时，会被提升 为 unsigned int 。

于无符号整型，需要将 d 替换成 u 表明最高位不被看作符号位，而是数据位。

结论：

unsigned char，unsigned short，unsigned int使用 %u 。

unsigned long使用 %lu 。

unsigned long long使用 %llu 。

小数

2.3 浮点类型的类型提升 float 会被提升为 double ， double 不发生变化。 结论： float，double均使用 %f 。

转换规范

.1 转换规范总览 转换规范以%百分号开始，依次具有下面这些元素：

1. 零个或多个标志字符(-,+,0,#)。
2. 一个可选的十进制整数常量表示的最小字段宽度。
3. 一个可选的用点号表示的精度范围，它的后面可以跟一个十进制整数。
4. 一个可选的长度指示符，可以用下列字母组合之一来表示：h、hh、l、LL，z。
5. 由单个字符表示的转换操作，取自下面这个集合:c、d、e、E、f、i、o、s、u、x、X。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7Iy1AgEl-1665413760046)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20221007201635720.png)]

转换操作 二进制字节长度n 转换方式

c sizeof(int) 数值对应的ASCII字符 d sizeof(int) 有符号十进制整型e sizeof(double) 双精度浮点型，e计数法表示 E sizeof(double) 双精度浮点型，e计数法表示 f sizeof(double) 双精度浮点型，十进制浮点数 i sizeof(int) 与d相同 o sizeof(unsigned int) 无符号八进制整型 s sizeof(char *) 字符串 u sizeof(unsigned int) 无符号十进制整型 x sizeof(unsigned int) 无符号十六进制整型 X sizeof(unsigned int) 无符号十六进制整型

#include <stdio.h>
int main()
{char c1 = 127;short s1 = 32767;int n1 = 2147483647;char c2 = -128;short s2 = -32768;int n2 = -2147483648;printf("%d\n", c1);printf("%d\n", s1);printf("%d\n", n1);printf("%d\n", c2);printf("%d\n", s2);printf("%d\n", n2);return 0;
}
变量c1，s1，c2，s2均为比int低级的整型类型。它们在进入printf时会转换为int。因此使用转换操作d，
取sizeof(int)字节二进制数据，并将它们按照有符号整型转换为字符并打印在控制台上

#include <stdio.h>
int main()
{unsigned char c1 = 0;unsigned short s1 = 0;unsigned int n1 = 0;unsigned char c2 = 255;unsigned short s2 = 65535;unsigned int n2 = 4294967295;printf("%u\n", c1);printf("%u\n", s1);printf("%u\n", n1);printf("%u\n", c2);printf("%u\n", s2);printf("%u\n", n2);return 0;
}量c1，s1，c2，s2均为比unsigned int低级的整型类型。它们在进入printf时会转换为unsigned int。
因此使用转换操作u，取sizeof(unsigned int)字节二进制数据，并将它们按照无符号整型转换为字符并
打印在控制台上。

#include <stdio.h>
int main()
{char c = 65;short s = 66;int n = 67;printf("c=%d\n", c);printf("s=%d\n", s);printf("n=%d\n", n);printf("c=%c\n", c);printf("s=%c\n", s);printf("n=%c\n", n);return 0;
}
变量c，s，n 为比int低级或等于的整型类型。它们在进入printf时会转换为int。因此使用转换操作c，取
sizeof(int) 字节二进制数据，将数值转换为数值对应的ASCII字符并打印在控制台上。

#include <stdio.h>
int main()
{float f = 1.234;double df = 1.234567;printf("%f\n", f);printf("%f\n", df);return 0;
}变量f, df 为比double低级或等于的整型类型。它们在进入printf时会转换为double。因此使用转换操作
f，取 sizeof(double) 字节二进制数据，并将它们按照双精度浮点型转换为字符并打印在控制台上

#include <stdio.h>
int main()
{float f = 1.234;double df = 1.234567;printf("%e\n", f);printf("%e\n", df);printf("%E\n", f);printf("%E\n", df);return 0;
}

#include <stdio.h>
int main()
{unsigned int n = 123456;printf("%u\n", n); // 十进制printf("%o\n", n); // 八进制printf("%x\n", n); // 十六进制，小写字母printf("%X\n", n); // 十六进制，大写字母return 0;
}

#include <stdio.h>
int main()
{printf("%s", "Hello World\n");return 0;
}

综合

#include <stdio.h>
int main()
{//常见的占位符//d u f   c s    e E    o x Xint a = 12;printf("d%d 用于输出 整数类型的站位 例如 char short int long longlong\n",a);//u 无符号整形unsigned int u = 222;printf("u%u 用于输出无符号整数类型的站位 例如 unsignedchar unsignedshort unsignedint unsignedlong unsignedlonglong\n", u);//f小数的站位double db = 12.22;printf("f%f 用于输出 小数类型的站位 例如float double\n", db);//c 字符char ch = 'a';printf("c %c用于输出字符类型的站位 例如char\n", ch);//s 字符串printf("s %s用于输出字符串类型的站位\n", "hello");//e 科学计数法 E科学计数法int bag = 12132132132312;printf("e %e用于输出科学计数法的站位\n", bag);printf("E %E用于输出科学计数法的站位\n", bag);//o 8进制 x  X  16进制的输出 int s8 = 121212;printf("o %o用于八进制的站位\n", s8);printf("x %x用于八进制的站位\n", s8);printf("X %X用于八进制的站位\n", s8);return 0;
}

printf 占位符的参数讲解

占位符的拆分

% 标志 [+ - # 0 ] 长度 .精度 字节伸展 类别符号

举个例子

% 0 12 .5 ll d

类别符号 就是上面的//d u f c s e E o x X

字节伸展 ll l ss s

#include <stdio.h>
int main()
{long l = 2147483647;long long ll = 9223372036854775807;printf("%d\n", l);printf("%d\n", ll);return 0;
}%d 取得是sizeof(int) 4字节 longlong是8字节 %d放不下了
%ld 就会提升到sizeof(long) 4字节不够
%lld 就会提升到sizeof(long long) 8字节足够了#include <stdio.h>
int main()
{long l = 2147483647;long long ll = 9223372036854775807;printf("%d\n", l);printf("%lld\n", ll);return 0;
}

.精度

获取小数点后面的个数 .2 就是获得小数点后面2个
1. d、i、o、u、x、X所打印的最小数字位数，不足将补齐。
2. e，E，和f转换中小数点右边的数字位数。
#include <stdio.h>
int main()
{int a = 132;double db = 12.264454;printf("%.5d\n", a);//00132printf("%.3f\n", db);//12.264return 0;
}#include <stdio.h>
int main()
{int un = 123;double df = 123.456789;printf("%.6d\n", un); // 限制为6个最小数字位数，所以前面添加了0，补到6个数字。printf("%f\n", df); // 不限制小数点后的数字个数printf("%.0f\n", df); // 小数点后的数字个数限制为0，小数点后无数字。printf("%.4f\n", df); // 小数点后的数字个数限制为4，小数点后跟了4个数字。return 0;
}

长度

最小字段宽度指定输出的字符最小为多少个字符，如果不足，将使用空格补齐到指定的最小宽度。

#include <stdio.h>
int main()
{int un = 1234;double df = 123.456789;printf("%2d\n", un); // 最小要求2位，有4位，不做处理。printf("%6d\n", un); // 只有4位，补齐到6位。printf("%12f\n", df); // 只有10位，补齐到12位。return 0;
}#include <stdio.h>
int main()
{int a = 132;double db = 12.264454;printf("%8.5d\n", a);// 3空格 00132printf("%10.3f\n", db);//4空格 12.264return 0;
}

标志

 0 使用0而不是空格作为填充字符当我们使用了最小字段宽度时，如果字符不足最小宽度，那么将会用空格补齐到最小宽度。如果指定
了 0 作为标志，则会用字符0，来补齐到最小宽度#include <stdio.h>
int main()
{int a = 132;double db = 12.264454;printf("%08d\n", a);//00000132printf("%010.3f\n", db);//000012.264int n = 1234;printf("%06d\n", n); // 只有4位，使用空格，补齐到6位。printf("%06d\n", n); // 只有4位，使用字符0，补齐到6位return 0;
}

标志 -

打印的字符左对齐

#include <stdio.h>
int main()
{int a = 132;double db = 12.264454;printf("%-8d\n", a);//    132   左对齐printf("%-10.3f\n", db);//12.264454;左对齐return 0;
}

标志 +

总是产生符号，+(正数)或-(负数)

#include <stdio.h>
int main()
{int a = 132;double db = -12.264454;printf("%-+8d\n", a);//    +132   左对齐显示正负printf("%-+10.3f\n", db);//-12.264454;左对齐显示正负return 0;
}#include <stdio.h>
int main()
{int a = 132;double db = -12.264454;printf("%+08d\n", a);//    +0000132   补零 显示正负printf("%+010.3f\n", db);//-00012.264;补零显示正负return 0;
}

标志 #

八进制前加0，十六进制前加0x

#include <stdio.h>
int main()
{int n = 1234;printf("%o\n", n);printf("%X\n", n);printf("%#o\n", n);printf("%#X\n", n);return 0;
}

第九部分scanf函数

printf函数将二进制表示的整数、浮点数、字符、字符串等按照转换规范转换成字符，并打印在控制台 上。与之相反，scanf将键盘输入的字符串根据转换规范，转换成二进制表示的整数、浮点数、字符或 字符串等

#include <stdio.h>
int main()
{char a;short b;int c;long d;float f;double g;//通过控制台输入数据 scanf("%hhd %hd %d %ld %f %lf", &a, &b, &c, &d, &f, &g);printf("%hhd  %hd  %d %ld %f %lf ", a, b, c, d, f, g);return 0;
}

解决Visual Studio 仅为不安全无法使用scnf的问题

添加步骤方式如下：
1. 解决方案下，工程点右键，进入属性。
2. 展开C/C++，选择预处理器。
3. 点击预处理器定义【编辑】。
4. 将_CRT_SECURE_NO_WARNINGS加入预处理定义

scanf的特性

1. scanf是一个变参函数。变参函数中参数的数量和类型不确定scanf("",&a)  a可以是整数 小数.. 除了a 还可有别的  2. scanf的第一个参数是字符串。第一个是字符串 " "  里面是输入的模板格式3. scanf的第一个参数内容为匹配字符以及转换规范。第一个是字符串 "%d %s.. "  里面是输入的模板格式例1：scanf第一个字符串为 "%hhd %hd %d %ld %f %lf" ，每个转换规范使用      空格分割。那么输入时需要用空格进行分割，形如 1 2 3 4 5.6 7.8 。例2：scanf第一个字符串为 "%hhd,%hd,%d,%ld,%f,%lf" ，每个转换规范使用      ,分割。那么输入时需要用逗号进行分割，形如 1,2,3,4,5.6,7.8 。例3：scanf第一个字符串为 "%hhd+%hd-%dx%ld/%f~%lf" ，转换规范使用+-x/~      分割。那么需要像这样输入 1+2-3x4/5.6~7.8 。
4. scanf的后续参数，是转换完成后，数据的存放位置。" "里面的模板 和后面的变量是对应关系
5. 转换规范的写法与数量，需要与后续的参数类型和数量对应。

scanf("%hhd %hd %d %ld %f %lf", &a, &b, &c, &d, &f, &g);子串 "1" 对应转换规范 "%hhd" ，将转换为char类型的二进制表示，1字节。
子串 "2" 对应转换规范 "%hd" ，将转换为short类型的二进制表示，2字节。
子串 "3" 对应转换规范 "%d" ，将转换为int类型的二进制表示，4字节。
子串 "4" 对应转换规范 "%ld" ，将转换为long类型的二进制表示，4字节。
子串 "5.6" 对应转换规范 "%f" ，将转换为float类型的二进制表示，4字节。
子串 "7.8" 对应转换规范 "%lf" ，将转换为double类型的二进制表示，8字节。

字符和字符串

字符的输入 输出

//输入字符
#include <stdio.h>
int main()
{char c;scanf("%c", &c);printf("%d %c\n", c, c);return 0;
}//输入 数值
#include <stdio.h>
int main()
{char c;scanf("%hhd", &c);printf("%d %c\n", c, c);return 0;
}

字符串的输入输出

#include <stdio.h>
int main()
{char c[20];scanf("%s", c);printf("%s\n", c);return 0;
}

scanf与printf的不同

1. printf的后续参数不要加&，而scanf由于需要一个地址，所以对于基本变量需要加&，数组则不需要。

2. printf的参数由于比int小的变量会升级为int，float会升级为double。所以，转换规范d可以用于 char，short，int。转换规范f可以用于float和double。但是scanf是直接把转换结果送到接收变量 中，必须严格使用转换规范。

第十部分 表达式 运算符

表达式

是什么

就是一个值  表达式就是一个值算符往往需要与运算对象一起使用才有意义。例如：
5 + 10
其中，5与10是 运算对象 ，+为 运算符 。
在C语言中，一个或多个运算对象与零个或多个运算符组成表达式。下面几个都是表达式：
100
5 + 10
a / b
a * 10 / b + c以上都是 最终的结果就是一个值

加+

计算和的数据
int a,b;
a=200;
b=100;
c=a+b;   //就是表达式 a+b  表达式就是值  a+b 300

减 -

计算数据的差值
int a,b;
a=200;
b=100;
c=a-b;   //就是表达式 a-b  表达式就是值  a+b 300

加减的 正负表达方式

a =12;
+a //就是+12
-a //就是-12a=-12
+a //就是-12
-a //就是12  取反

乘 *

计算数据乘积
int a,b;
a=200;
b=100;
c=a*b;   //就是表达式 a*b  表达式就是值  a*b 20000

除 /

计算数据除数
int a,b;
a=200;
b=100;
c=a/b;   //就是表达式 a/b  表达式就是值  200/100 2

求余数 %

计算数据除数的余数
int a,b;
a=10;
b=3;
c=a%b;   //就是表达式 a%b  表达式就是值  10%3    1

赋值运算符=

赋值运算符的结果
a=12;  结果就是12运算符的操作
就是把左边的结果赋值给 左边
a=12
把 12赋值给变量a

赋值与初始化的区别

int a = 100; // =表示初始化，不是赋值运算符 a = a + 150; // 赋值运算符，将右边的表达式结果赋值给左边的变量a。 在上面的代码中，第一行代码声明了一个变量a。请注意，声明变量时并将它初始化为100所用的 = 号， 不是赋值运算符，而是变量初始化。虽然初始化和赋值很像，但是 = 号左边并不是一个单纯的变量，而 是变量的声明。你可以借此来区别它们。

自增 自减

前自增++A  --Aa=12b=++a  先加一  在赋值a+1=13  在赋值b=13后子增A++ A--a=12b=++a  先赋值 再加一b=a=12  再加一 a+1=13

第十一部分 数据类型转换

检测数据类型

指针变量和整型、浮点这些数据类型是不能相互赋值 的。

#include <stdio.h>
int main()
{// 一个整型指针变量pint* p;// 各式各样的类型char c;short s;int n;long l;float f;double d;// 将整型赋值给指针类型p = c;  //不能将char 类型分配给int*指针p = s;//不能将short 类型分配给int*指针p = n;//不能将int类型分配给int*指针p = l;//不能将long 类型分配给int*指针p = f;//不能将float 类型分配给int*指针p = d;//不能将double 类型分配给int*指针return 0;
}报错 根据报错的信息确定类型

同类型运算

有符号整形运算

#include <stdio.h>
int main()
{// 一个整型指针变量pint* p;// 各式各样的类型char c;short s;int n;long l;long long ll;// 将整型赋值给指针类型p = c+c;//不能将int 类型分配给int*指针p = s+s;//不能将int 类型分配给int*指针p = n+n;//不能将int 类型分配给int*指针p = l+l;//不能将long 类型分配给int*指针p = ll + ll;//不能将long long 类型分配给int*指针return 0;
}c + c，char同类型运算，结果是一个int类型。
s + s，short同类型运算，结果是一个int类型。
n + n，int同类型运算，结果是一个int类型。
l + l，long同类型运算，结果是一个long类型
ll + ll，long long同类型运算，结果是一个long long类型结论:比int低级的类型，都会转换成int，比int高级的类型不变

结论:比int低级的类型，都会转换成int，比int高级的类型不变

无符号整型同类型

#include <stdio.h>
int main()
{// 一个整型指针变量pint* p;// 各式各样的类型unsigned char c;unsigned short s;unsigned int n;unsigned long l;unsigned long long ll;// 将整型赋值给指针类型p = c+c;p = s+s;p = n+n;p = l+l;p = ll + ll;return 0;
}
uc + uc，unsigned char同类型运算，结果是一个int类型。
us + us，unsigned short同类型运算，结果是一个int类型。
un + un，unsigned int同类型运算，结果是一个unsigned int类型。
ul + ul，unsigned long同类型运算，结果是一个unsigned long类型
int < unsigned int < unsigned long结论:比int低级的类型，都会转换成int，比int高级的类型不变。

浮点型同类型

#include <stdio.h>
int main()
{// 一个整型指针变量pint* p;// 各式各样的类型float f;double d;p = f + f;//不能将float 类型分配给int*指针实体p = d + d;//不能将double 类型分配给int*指针实体return 0;
}f+ f，float同类型运算，结果是一个float类型。
d + dd，double同类型运算，结果是一个double类型。总结 浮点同类型运算类型不变

不同类型的运算

有一个类型大小的比较

char <unsigned char <short <unsigned short<int<unsigned int<long <unsigned long<long long<unsigned long long<float<double

运算 中 都小于int 那么就会转为 int

char <unsigned char <short <unsigned short 运算 char <unsigned char <short <unsigned short
结果 int

运算 存在大于int 就是使用大于int的类型

char <unsigned char <short <unsigned short<int<unsigned int<long <unsigned  long<long long<unsigned long long<float<double 运算
char <unsigned char <short <unsigned short<int<unsigned int<long <unsigned  long<long long<unsigned long long<float<double
结果 存在大于int 结果就是
<int<unsigned int<long <unsigned  long<long long<unsigned long long<float<double

运算存在 浮点型 那么结果就是浮点型 且float<double

char <unsigned char <short <unsigned short<int<unsigned int<long <unsigned  long<long long<unsigned long long<float<double 运算
<float<double结果就是<float<double

整型之间进行运算：若运算符两边类型均低于int或等于int，那么结果为int。若有高于int的，那么结果 为高于int的等级最高的类型。

整型与浮点进行运算：结果为运算符两边等级最高的类型。

整型运算的注意点

整型与整型运算，是不会出现浮点类型的。也就是说，运算结果将丢失小数部分

#include <stdio.h>
int main()
{int n1, n2;n1 = 5;n2 = 2;printf("%d\n", n1 / n2);
}

解决方式-----让浮点类型参与运算 就能保留小数

#include <stdio.h>
int main()
{int n;float f;n = 5;f = 2;printf("%f\n", n / f);
}例如 2/2  变为 2/2.0  2.0/2  2.0/2.0

解决方式二—使用前置类型转换

#include <stdio.h>
int main()
{int n1, n2;n1 = 5;n2 = 2;printf("%d\n", (float)n1 / n2);printf("%d\n", n1 / (float)n2);printf("%d\n", (float)n1 / (float)n2);printf("%d\n", (double)n1 / n2);printf("%d\n", n1 / (double)n2);printf("%d\n", (double)n1 / (double)n2);
}

注意点:

小的整型类型可以赋值给大的，大的整型类型请勿赋值给小的。

第十二部分 关系 逻辑

关系运算符

> < >= <= == !=
大于 小于 大于等于 小于等于 等于 不等于

关系运算的返回值 如果正确返回1  错误返回0
1>2  0
1<2   1
2>=4 0
2<=0 1
1==1 1
1!=1  0其实关系运算符常用  在比较的场景
根据比较的结果 获得0 1进行下一步处理

逻辑运算符

&&   ||  !与   或  非&&  就是说两边的比较都是对的那么结果就是对的
1 && 1   1
0 && 1   0
1 && 0   0
0 && 0   0||  就是说两边的比较存在一个是对的那么结果就是对的
1 || 1   1
0 || 1   1
1 || 0   1
0 || 0   0!   对结果进行取反如果 是对的 取反就是错的!0  1
!1  0

运算符的优先级

从上到下

++ – 自增、自减 后缀 16

++ – 自增、自减 前缀 15

! 逻辑非 单目 15

±正号，负号 单目 15

+/ % 乘、除、取余 双目 13

± 加、减 双目 12

< > <= >= 关系 双目 10

== != 相等、不相等 双目 9

&& 逻辑与 双目 5

|| 逻辑或 双目 4

= 赋值 双目 2

int a;
int i = 0;
a = 9 / 3 + 1 * -2 && ++i || !6;++i 先执行 ++i =1a = 9 / 3 + 1 * -2 && 1 || !6;
在执行 !   !6=0a = 9 / 3 + 1 * -2 && 1 || 0;
在执行 正负  -2 (-2)a = 9 / 3 + 1 * (-2) && 1 || 0;
在执行 * /  9 / 3 =3  1 * (-2) =-2
a = 3 + (-2) && 1 || 0
在执行 +
a = 1 && 1 || 0
在执行 &&  1 && 1=1a =  1 || 0
在执行 ||  1 || 0=1a =   1   

第十三部分 分支…持续学习完善中^ _ ^

c 语言学习大全 值得收藏的文章相关推荐

1. web前端/移动端H5博客专家博客大全--值得收藏的前端技术大牛博客地址

   web前端/移动端H5博客专家博客大全--值得收藏的前端技术大牛博客地址   Huang Jie Blog .Com-前端开发  http://www.huangjieblog.com/?feed=r ...

2. C语言之结构体就这样被攻克了！（绝对值得收藏的文章）

   有的时候,我们所遇到的数据结构,不仅仅是一群数字或者是字符串那么简单.比如我们每一个人的学籍信息,学号是一个长整数,名字却是字符:甚至有更复杂的情况,这种问题在现实生活中并不少见.我们之前学过一种叫数 ...

3. @程序员，这四个学习建议值得收藏

   在我看来,学习能力应该是一个人最重要的能力之一.因为我们赖以生存的所有技能,无一例外都是通过学习获得的.那些优秀的人,也不过是学习能力或者学习效率比一般人强而已. 这样的观点被很多人论证过,商业理论家 ...

4. unity 5.x从入门到精通_Unity学习中值得收藏的学习资料(书籍)与博客

   前言: 对于入门任何领域,收集相关比较优秀的学习资料,都是你不断提高自己的必备技能.而在信息爆炸的时代想要在繁杂的网络世界中找到好的学习资料,必然会耗费一定的时间和精力.为了给大家节省一点时间,在这里 ...

5. 程序员，这四个学习建议值得收藏

   大家好,我是本周的值班编辑 江南一点雨 ,本周将由我为大家排版并送出技术干货,大家可以在公众号后台回复"springboot",获取最新版 Spring Boot2.1.6 视频教 ...

6. mysq学习课堂笔记 第一天学习（值得收藏！）

   笔记来自b站 老杜带你学_mysql入门基础(mysql基础视频+数据库实战)很棒的mysql讲解,建议观看. 话不多说,开始笔记 一共四天的笔记,今天是第一天的,很高兴能给大家提供数据库笔记,这四个 ...

7. Excel 各种密码的破解，各种大全值得收藏！（亲测有效）

   本文介绍在 Excel 的多个文件版本中破解各类密码,包含文件的查看.只读密码,工作表.工作簿的保护密码,以及 VBA 工程密码.内容非常全面,建议你收藏.文件作者加密码是防止数据被查看,修改,所以, ...

8. 免费学习编程-值得收藏

   免费学习编程 Code.org是美国非营利组织在一些科技大佬的鼎立支持下正计划将高品质计算机科学课程带进学校 1. MIT 开放式课程 MIT 提供免费的课程内容浏览服务,只要你有时间,随时可以进入. ...

9. Windows CMD命令大全(值得收藏)

   命令简介 cmd是command的缩写.即命令行 . 虽然随着计算机产业的发展,Windows 操作系统的应用越来越广泛,DOS 面临着被淘汰的命运,但是因为它运行安全.稳定,有的用户还在使用,所以一 ...

最新文章

1. Systemd 入门及常用命令
2. 内置的数据无法实现高性能
3. Memcpy, blockcopy的进一步理解
4. python图书管理系统增删改查_python基础-字典的增删改查
5. tensorflow--embedding_lookup 和 embedding_lookup_sparse
6. 将字符串使用md5加密
7. 【二叉树迭代版前序遍历】LeetCode 144. Binary Tree Preorder Traversal
8. 20169218 2016-2017-2 《网络攻防实践》第三周学习总结
9. GBTD(Gradient Boosting Decision Tree)学习
10. matlab 对话框大小调整,matlab界面设计---对话框设计
11. 深入探访支付宝双11十年路，技术凿穿焦虑与想象极限
12. python的seek用法
13. 本周之后Win11 变成beta通道只能更新22000.176而没办法更新Dev的解决办法 your PC does not meet the hardware system
14. 我的世界 win10c语言版,Minecraft Win10版下载
15. 干货 | 电子设备散热技术详解
16. [渝粤教育] 西南科技大学 数控技术基础 在线考试复习资料
17. PIM-SM原理(ASM)
18. eclipse Oxygen版本 安装cvs插件
19. 虚部用计算机怎么弄,CASIO这个型号的计算机怎么进行虚数运算
20. CentOS 7 安装 Oracle 11.2.0.4

热门文章

1. Windows 7远程桌面登录时崩溃
2. 读书笔记 - 《鱼：一种激发工作热情的绝妙方法》
3. m数据结构 day5 栈：后进先出，只能在表尾插入和删除的线性表
4. 【多线程】线程与进程、以及线程进程的调度
5. 如何在踩踏事故中幸存以及如何避免踩踏事故发生
6. C语言位操作详解-4.2.C语言专题第二部分-朱有鹏-专题视频课程
7. gStore:A Graph-based SPARQL Query Engine---part1
8. 电话号码对应英文单词
9. 函数的递归调用-年龄增大问题
10. div+css使用padding样式和 important标记实现Firefox和IE6处理带float样式的margi