C语言
C简介
C 语言是一种通用的高级语言,最初是由丹尼斯·里奇在贝尔实验室为开发 UNIX 操作系统而设计的。C 语言最开始是于 1972 年在 DEC PDP-11 计算机上被首次实现。
在 1978 年,布莱恩·柯林汉(Brian Kernighan)和丹尼斯·里奇(Dennis Ritchie)制作了 C 的第一个公开可用的描述,现在被称为 K&R 标准。
UNIX 操作系统,C编译器,和几乎所有的 UNIX 应用程序都是用 C 语言编写的。由于各种原因,C 语言现在已经成为一种广泛使用的专业语言。
- 易于学习。
- 结构化语言。
- 它产生高效率的程序。
- 它可以处理底层的活动。
- 它可以在多种计算机平台上编译。
关于C
- C 语言是为了编写 UNIX 操作系统而被发明的。
- C 语言是以 B 语言为基础的,B 语言大概是在 1970 年被引进的。
- C 语言标准是于 1988 年由美国国家标准协会(ANSI,全称 American National Standard Institute)制定的。
- 截至 1973 年,UNIX 操作系统完全使用 C 语言编写。
- 目前,C 语言是最广泛使用的系统程序设计语言。
- 大多数先进的软件都是使用 C 语言实现的。
- 当今最流行的 Linux 操作系统和 RDBMS(Relational Database Management System:关系数据库管理系统) MySQL 都是使用 C 语言编写的。
为什么要用C
C 语言最初是用于系统开发工作,特别是组成操作系统的程序。由于 C 语言所产生的代码运行速度与汇编语言编写的代码运行速度几乎一样,所以采用 C 语言作为系统开发语言。下面列举几个使用 C 的实例:
- 操作系统
- 语言编译器
- 汇编器
- 文本编辑器
- 打印机
- 网络驱动器
- 现代程序
- 数据库
- 语言解释器
- 实体工具
第一个C语言程序
hello world
# include <stdio.h>
int main(){
/*在双引号中间输入Hello World*/
printf("hello world");
return 0;
}
// 注:在最新的C标准中,main函数前的类型为int而不是void
C语言的具体结构
简单来说,一个C程序就是由若干头文件
和函数
组成。[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NCiOQiWs-1642396238135)(C:\Users\XUN~MLF\AppData\Roaming\Typora\typora-user-images\image-20220116135219871.png)]
-
#include <stdio.h>
就是一条预处理命令, 它的作用是通知C语言编译系统在对C程序进行正式编译之前需做一些预处理工作。 -
函数
就是实现代码逻辑的一个小的单元 -
一个C程序有且只有一个主函数,即
main
函数。必不可少 -
C程序就是执行主函数里的代码,也可以说这个主函数就是C语言中的唯一入口。
-
return是函数的返回值,根据函数类型的不同,返回的值也是不同的。
注释
多行注释 /* 注释内容 */
单行注释 // 注释一行
标识符
C语言规定,标识符可以是字母(A~Z,a~z)
、数字(0~9)
、下划线_
组成的字符串,并且第一个字符必须是字母或下划线。在使用标识符时还有注意以下几点:
- 标识符的长度最好不要超过8位,因为在某些版本的C中规定标识符前8位有效,当两个标识符前8位相同时,则被认为是同一个标识符。
- 标识符是严格区分大小写的。例如
Imooc
和imooc
是两个不同的标识符。 - 标识符最好选择有意义的英文单词组成做到"见名知意",不要使用中文。
- 标识符不能是C语言的关键字。
数据类型
C语言中,数据类型可分为:
- 基本数据类型
- 构造数据类型
- 指针类型
- 空类型四大类
是
最常用的整型, 实型与字符型(char,int,float,double):
数据类型 | 说明 | 字节 | 应用 | 示例 |
---|---|---|---|---|
char | 字符型 | 1 | 用于存储单个字符 | char sex = ‘M’ ; |
int | 整型 | 2 | 用于存储整数 | int sum = 10 ; |
float | 单精度浮点型 | 4 | 用于存储小数 | float price = 12.56 ; |
double | 多精度浮点型 | 8 | 用于存储位数更多的小数 | double pi = 3.1415926 ; |
整型数据是指不带小数的数字(int,short int,long int, unsigned int, unsigned short int,unsigned long int):
数据类型 | 说明 | 字节 | 取值范围 |
---|---|---|---|
int | 整型 | 2 | -32,768 到 32,767 或 -2,147,483,648 到 2,147,483,647 |
short int | 短整型(int可以省略) | 2 | -32,768 到 32,767 |
long int | 长整型(int可以省略) | 4 | -2,147,483,648 到 2,147,483,647 |
unsigned int | 无符号整型 | 2 | 0 到 65,535 或 0 到 4,294,967,295 |
unsigned short int | 无符号短整型(int可以省略) | 2 | 0 到 65,535 |
unsigned long int | 无符号长整形(int可以省略) | 4 | 0 到 4,294,967,295 |
注:
int
short int
long int
是根据编译环境的不同,所取范围不同。- 而其中
short int
和long int
至少是表中所写范围, 但是int
在表中是以16位编译环境写的取值范围。 - 另外 c语言
int
的取值范围在于他占用的字节数 ,不同的编译器,规定是不一样。 - ANSI标准定义
int
是占2个字节,TC是按ANSI标准的,它的int
是占2个字节的。但是在VC里,一个int
是占4个字节的。
常量和变量
什么是常量
- "量"表示数据。常量,则表示一些固定的数据,也就是不能改变的数据
- 就好比现实生活中生男生女一样, 生下来是男孩永远都是男孩, 生下来是女孩就永远都是女孩, 所以性别就是现实生活中常量的一种体现
- 在C语言中,可以**用一个标识符来表示一个常量,称之为符号常量。*符号常量在*使用之前必须先定义,其一般形式为:
#define 标识符 常量值
#include <stdio.h>
#define POCKETMONEY 10 //定义常量及常量值
int main()
{
// POCKETMONEY = 12; //小明私自增加零花钱对吗?
printf("小明今天又得到%d元零花钱\n", POCKETMONEY);
return 0;
}c
什么是变量
变量就是可以变化的量,而每个变量都会有一个名字(标识符)。变量占据内存中一定的存储单元。使用变量之前必须先定义变量
变量定义的一般形式为:数据类型 变量名;
多个类型相同的变量:数据类型 变量名, 变量名, 变量名…;
int a;
a = 100;
int b, c, d;
b = 2;
c = 3;
d = 4;
printf("%d/n",num)
变量的赋值分为两种方式:
- 先声明再赋值
- 声明的同时赋值
输入输出函数
printf和scanf
C 语言中的 I/O (输入/输出) 通常使用 printf() 和 scanf() 两个函数。
printf函数
格式化输出语句,也可以说是占位输出,是将各种类型的数据按照格式化后的类型及指定的位置从计算机上显示。
其格式为:printf("输出格式符",输出项)
;
# include <stdio.h>
int main(){
int a = 10;
printf("a=%d\n",a);
return 0;
}
scanf函数
- scanf函数用于接收键盘输入的内容, 是一个阻塞式函数,程序会停在scanf函数出现的地方, 直到接收到数据才会执行后面的代码
- printf函数的调用格式为:
scanf("格式控制字符串", 地址列表);
- 例如:
scanf("%d", &num);
#include <stdio.h>
int main(){
int number;
scanf("%d", &number); // 接收一个整数
printf("number = %d\n", number);
}
- 地址列表项中只能传入变量地址, 变量地址可以通过&符号+变量名称的形式获取
- 接收非字符和字符串类型时, 空格、Tab和回车会被忽略
- 接收多条数据
- 格式控制字符串和地址列表项在数量和类型上必须一一对应
- 非字符和字符串情况下如果没有指定多条数据的分隔符, 可以使用空格或者回车作为分隔符(不推荐这种写法)
- 非字符和字符串情况下建议明确指定多条数据之间分隔符
- \n是scanf函数的结束符号, 所以格式化字符串中不能出现\n
scanf运行原理
- 系统会将用户输入的内容先放入输入缓冲区
- scanf方式会从输入缓冲区中逐个取出内容赋值给变量
- 如果输入缓冲区的内容不为空,scanf会一直从缓冲区中获取,而不要求再次输入
putchar和getchar
-
putchar: 向屏幕输出一个字符
#include <stdio.h> int main(){ char ch = 'a'; putchar(ch); // 输出a }
-
getchar: 从键盘获得一个字符
#include <stdio.h> int main(){ char ch; ch = getchar();// 获取一个字符 printf("ch = %c\n", ch); }
类型转换
自动类型转换
数据类型存在自动转换的情况.
自动转换发生在不同数据类型运算时,在编译的时候自动完成。
char
类型数据转换为int
类型数据遵循ASCII
码中的对应值.
注:
字节小的可以向字节大的自动转换,但字节大的不能向字节小的自动转换
char可以转换为int,int可以转换为double,char可以转换为double。但是不可以反向。
强制类型转换
强制类型转换是通过定义类型转换运算来实现的。其一般形式为:
(数据类型) (表达式)
// 将double转换为int
int a = (int)10.5;
运算符
算术运算符
优先级 | 名称 | 符号 | 说明 |
---|---|---|---|
3 | 乘法运算符 | * | 双目运算符,具有左结合性 |
3 | 除法运算符 | / | 双目运算符,具有左结合性 |
3 | 求余运算符 (模运算符) | % | 双目运算符,具有左结合性 |
4 | 加法运算符 | + | 双目运算符,具有左结合性 |
4 | 减法运算符 | - | 双目运算符,具有左结合性 |
#include <stdio.h>
int main(){
int a = 10;
int b = 5;
// 加法
int result = a + b;
printf("%i\n", result); // 15
// 减法
result = a - b;
printf("%i\n", result); // 5
// 乘法
result = a * b;
printf("%i\n", result); // 50
// 除法
result = a / b;
printf("%i\n", result); // 2
// 算术运算符的结合性和优先级
// 结合性: 左结合性, 从左至右
int c = 50;
result = a + b + c; // 15 + c; 65;
printf("%i\n", result);
// 优先级: * / % 大于 + -
result = a + b * c; // a + 250; 260;
printf("%i\n", result);
}
赋值运算符
优先级 | 名称 | 符号 | 说明 |
---|---|---|---|
14 | 赋值运算符 | = | 双目运算符,具有右结合性 |
14 | 除后赋值运算符 | /= | 双目运算符,具有右结合性 |
14 | 乘后赋值运算符 (模运算符) | *= | 双目运算符,具有右结合性 |
14 | 取模后赋值运算符 | %= | 双目运算符,具有右结合性 |
14 | 加后赋值运算符 | += | 双目运算符,具有右结合性 |
14 | 减后赋值运算符 | -= | 双目运算符,具有右结合性 |
#include <stdio.h>
int main(){
// 复合赋值运算符 += -= *= /= %=
// 将变量中的值取出之后进行对应的操作, 操作完毕之后再重新赋值给变量
int num1 = 10;
// num1 = num1 + 1; num1 = 10 + 1; num1 = 11;
num1 += 1;
printf("num1 = %i\n", num1); // 11
int num2 = 10;
// num2 = num2 - 1; num2 = 10 - 1; num2 = 9;
num2 -= 1;
printf("num2 = %i\n", num2); // 9
int num3 = 10;
// num3 = num3 * 2; num3 = 10 * 2; num3 = 20;
num3 *= 2;
printf("num3 = %i\n", num3); // 20
int num4 = 10;
// num4 = num4 / 2; num4 = 10 / 2; num4 = 5;
num4 /= 2;
printf("num4 = %i\n", num4); // 5
int num5 = 10;
// num5 = num5 % 3; num5 = 10 % 3; num5 = 1;
num5 %= 3;
printf("num5 = %i\n", num5); // 1
}
关系运算符
优先级 | 名称 | 符号 | 说明 |
---|---|---|---|
6 | 大于运算符 | > | 双目运算符,具有左结合性 |
6 | 小于运算符 | < | 双目运算符,具有左结合性 |
6 | 大于等于运算符 | >= | 双目运算符,具有左结合性 |
6 | 小于等于运算符 | <= | 双目运算符,具有左结合性 |
7 | 等于运算符 | == | 双目运算符,具有左结合性 |
7 | 不等于运算符 | != | 双目运算符,具有左结合性 |
#include <stdio.h>
int main(){
int result = 10 > 5;
printf("result = %i\n", result); // 1
result = 5 < 10;
printf("result = %i\n", result); // 1
result = 5 > 10;
printf("result = %i\n", result); // 0
result = 10 >= 10;
printf("result = %i\n", result); // 1
result = 10 <= 10;
printf("result = %i\n", result); // 1
result = 10 == 10;
printf("result = %i\n", result); // 1
result = 10 != 9;
printf("result = %i\n", result); // 1
}
逻辑运算符
优先级 | 名称 | 符号 | 说明 |
---|---|---|---|
2 | 逻辑非运算符 | ! | 单目运算符,具有右结合性 |
11 | 逻辑与运算符 | && | 双目运算符,具有左结合性 |
12 | 逻辑或运算符 | \|\| | 双目运算符,具有左结合性 |
逻辑非
- 格式:
! 条件A;
- 运算结果: 真变假,假变真
- 运算过程:
- 先判断条件A是否成立,如果添加A成立, 那么结果就为0,即“假”;
- 如果条件A不成立,结果就为1,即“真”
- 使用注意:
- 可以多次连续使用逻辑非运算符
- !!!0;相当于(!(!(!0)));最终结果为1
#include <stdio.h>
int main(){
// ()优先级高, 先计算()里面的内容
// 10==10为真, 所以result = !(1);
// !代表真变假, 假变真,所以结果是假0
int result = !(10 == 10);
printf("result = %i\n", result); // 0
}
逻辑与
- 格式:
条件A && 条件B;
- 运算结果:一假则假
- 运算过程:
- 总是先判断"条件A"是否成立
- 如果"条件A"成立,接着再判断"条件B"是否成立, 如果"条件B"也成立,结果就为1,即“真”
- 如果"条件A"成立,"条件B"不成立,结果就为0,即“假”
- 如果"条件A"不成立,不会再去判断"条件B"是否成立, 因为逻辑与只要一个不为真结果都不为真
- 使用注意:
- "条件A"为假, "条件B"不会被执行
#include <stdio.h>
int main(){
// 真 && 真
int result = (10 == 10) && (5 != 1);
printf("result = %i\n", result); // 1
// 假 && 真
result = (10 == 9) && (5 != 1);
printf("result = %i\n", result); // 0
// 真 && 假
result = (10 == 10) && (5 != 5);
printf("result = %i\n", result); // 0
// 假 && 假
result = (10 == 9) && (5 != 5);
printf("result = %i\n", result); // 0
}
逻辑或
-
格式:
条件A || 条件B;
-
运算结果:一真则真
-
运算过程
- 总是先判断"条件A"是否成立
- 如果"条件A"不成立,接着再判断"条件B"是否成立, 如果"条件B"成立,结果就为1,即“真”
- 如果"条件A"不成立,"条件B"也不成立成立, 结果就为0,即“假”
- 如果"条件A"成立, 不会再去判断"条件B"是否成立, 因为逻辑或只要一个为真结果都为真
-
使用注意:
- "条件A"为真, "条件B"不会被执行
-
#include <stdio.h> int main(){ // 真 || 真 int result = (10 == 10) || (5 != 1); printf("result = %i\n", result); // 1 // 假 || 真 result = (10 == 9) || (5 != 1); printf("result = %i\n", result); // 1 // 真 || 假 result = (10 == 10) || (5 != 5); printf("result = %i\n", result); // 1 // 假 || 假 result = (10 == 9) || (5 != 5); printf("result = %i\n", result); // 0 }
三目运算符
-
三目运算符,它需要3个数据或表达式构成条件表达式
-
格式:
表达式1?表达式2(结果A):表达式3(结果B)
- 示例:
考试及格 ? 及格 : 不及格;
- 示例:
-
int a = 10; int b = 20; int max = (a > b) ? a : b; printf("max = %d", max); // 输出结果为:20
自增自减
优先级 | 名称 | 符号 | 说明 |
---|---|---|---|
2 | 自增运算符(在后) | i++ | 单目运算符,具有左结合性 |
2 | 自增运算符(在前) | ++i | 单目运算符,具有右结合性 |
2 | 自减运算符(在后) | i– | 单目运算符,具有左结合性 |
2 | 自减运算符(在前) | –i | 单目运算符,具有右结合性 |
#include <stdio.h>
int main(){
int number = 10;
number++;
printf("number = %i\n", number); // 11
++number;
printf("number = %i\n", number); // 12
}
选择结构
if语句
if语句
int age = 19;
if(age >= 18) {
printf("去上网\n");
}
printf("回家\n");
if-else语句
if(age > 18){
printf("上网\n");
}else{
printf("回家\n");
}
printf("开心\n");
if-else if -else
if(age>40){
printf("给房卡");
}else if(age>25){
printf("给名片");
}else if(age>18){
printf("给网卡");
}else{
printf("给好人卡");
}
printf("买烟\n");
if语句可以嵌套使用
if(表达式1){
语句块1;
if(表达式2){
语句块2;
}
}else{
if(表达式3){
语句块3;
}else{
语句块4;
}
}
switch语句
语法格式
switch(表达式){
case 常量表达式1:
语句1;
break;
case 常量表达式2:
语句2;
break;
case 常量表达式n:
语句n;
break;
default:
语句n+1;
break;
}
#include <stdio.h>
int main() {
int num = 3;
switch(num){
case 1:
printf("星期一\n");
break;
case 2:
printf("星期二\n");
break;
case 3:
printf("星期三\n");
break;
case 4:
printf("星期四\n");
break;
case 5:
printf("星期五\n");
break;
case 6:
printf("星期六\n");
break;
case 7:
printf("星期日\n");
break;
default:
printf("回火星去\n");
break;
}
}
循环结构
do while
int count = 0;
do {
printf("发射子弹~哔哔哔哔\n");
count++;
}while(count < 10);
while
九九乘法表
#include <stdio.h>
int main(){
int i=1,j ,result;
while(i<=9){
j = 1;
while(j<=i){
result = i*j;
printf("%d*%d=%d\t",i,j,result);
j++;
}
printf("\n");
i++;
}
return 0;
}
for
九九乘法表
#include <stdio.h>
int main(){
int i,j ,result;
for(i=1;i<=9;i++){
j=1;
for(j=1;j<=i;j++){
result = i*j;
printf("%d*%d=%d\t",i,i,result);
}
printf("\n");
}
return 0;
}
break语句和continue语句
continue语句的作用是结束本次循环开始执行下一次循环。
break语句与continue语句的区别是:
break是跳出当前整个循环,continue是结束本次循环开始下一次循环。
数组
一维数组
定义数组
// int 元素类型
// ages 数组名称
// [10] 元素个数
int ages[10];
初始化数组
int ages[3]={14,15,16}; //指定元素个数,完全初始化
int nums[] = {1,2,3,5,6}; // 不指定元素个数,完全初始化,根据大括号中的元素的个数来确定数组的元素个数
int nums[10] = {1,2};// 没有显式初始化的元素,那么系统会自动将其初始化为0
// 先定义后初始化
int ages[3];
ages[0]=14;
ages[1]=15;
ages[2]=16;
// 如果定义数组后,没有初始化,数组中是有值的,是随机的垃圾数,所以如果想要正确使用数组应该要进行初始化。
int nums[5];
for(i=0;i<5;i++){
printf("%d\t",nums[i])
}
// 结果是: 0 0 30 0 0
注意
:
- 使用数组时不能超出数组的索引范围使用, 索引从0开始, 到元素个数-1结束
- 使用数组时不要随意使用未初始化的元素, 有可能是一个随机值
- 对于数组来说, 只能在定义的同时初始化多个值, 不能先定义再初始化多个值
数组的遍历
int ages[5] = {14,15,14,12,15};
for (int i = 0; i < 4; i++) {
printf("ages[%d] = %d\n", i, ages[i]);
}
计算数组的长度
int ages[4] = {19, 22, 33, 13};
int length = sizeof(ages)/sizeof(int);
printf("length = %d", length);
// 输出结果:4
排序
计数排序
- 计数排序是一个非基于比较的排序算法,该算法于1954年由 Harold H. Seward 提出。它的优势在于在
对一定范围内的整数排序
时,快于任何比较排序算法。 - 排序思路:
- 1.找出待排序数组最大值
- 2.定义一个索引最大值为待排序数组最大值的数组
- 3.遍历待排序数组, 将待排序数组遍历到的值作新数组索引
- 4.在新数组对应索引存储值原有基础上+1
代码实现
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 用于排序数组
int newNums[4] = {0};
// 计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 遍历待排序数组
for(int i = 0; i < len; i++){
// 取出待排序数组当前值
int index = nums[i];
// 将待排序数组当前值作为排序数组索引
// 将用于排序数组对应索引原有值+1
newNums[index] = newNums[index] +1;
}
// 计算待排序数组长度
int len2 = sizeof(newNums) / sizeof(newNums[0]);
// 输出排序数组索引, 就是排序之后结果
for(int i = 0; i < len2; i++){
for(int j = 0; j < newNums[i]; j++){
printf("%i\n", i);
}
}
/*
// 计算待排序数组长度
int len2 = sizeof(newNums) / sizeof(newNums[0]);
// 还原排序结果到待排序数组
for(int i = 0; i < len2; i++){
int index = 0;
for(int i = 0; i < len; i++){
for(int j = 0; j < newNums[i]; j++){
nums[index++] = i;
}
}
}c
*/
return 0;
}
选择排序
-
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小元素,然后放到排序序列末尾。以此类推,直到所有元素均排序完毕。
-
排序思路:
- 假设按照升序排序
- 1.用第0个元素和后面所有元素依次比较
- 2.判断第0个元素是否大于当前被比较元素, 一旦小于就交换位置
- 3.第0个元素和后续所有元素比较完成后, 第0个元素就是最小值
- 4.排除第0个元素, 用第1个元素重复1~3操作, 比较完成后第1个元素就是倒数第二小的值
以此类推, 直到当前元素没有可比较的元素, 排序完成
代码实现
// 选择排序
void selectSort(int numbers[], int length) {
// 外循环为什么要-1?
// 最后一位不用比较, 也没有下一位和它比较, 否则会出现错误访问
for (int i = 0; i < length; i++) {
for (int j = i; j < length - 1; j++) {
// 1.用当前元素和后续所有元素比较
if (numbers[i] < numbers[j + 1]) {
// 2.一旦发现小于就交换位置
swapEle(numbers, i, j + 1);
}
}
}
}
// 交换两个元素的值, i/j需要交换的索引
void swapEle(int array[], int i, int j) {
int temp = array[i];c
array[i] = array[j];
array[j] = temp;
}
冒泡排序
-
冒泡排序(Bubble Sort)是一种简单的排序算法。它重复 地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
-
排序思路:
- 假设按照升序排序
- 1.从第0个元素开始, 每次都用相邻两个元素进行比较
- 2.一旦发现后面一个元素小于前面一个元素就交换位置
- 3.经过一轮比较之后最后一个元素就是最大值
- 4.排除最后一个元素, 以此类推, 每次比较完成之后最大值都会出现再被比较所有元素的最后
直到当前元素没有可比较的元素, 排序完成
代码实现
// 冒泡排序
void bubbleSort(int numbers[], int length) {
for (int i = 0; i < length; i++) {
// -1防止`角标越界`: 访问到了不属于自己的索引
for (int j = 0; j < length - i - 1; j++) {
// 1.用当前元素和相邻元素比较
if (numbers[j] < numbers[j + 1]) {
// 2.一旦发现小于就交换位置
swapEle(numbers, j, j + 1);
}
}
}c
}
// 交换两个元素的值, i/j需要交换的索引
void swapEle(int array[], int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
插入排序
-
插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
-
排序思路:
- 假设按照升序排序
- 1.从索引为1的元素开始向前比较, 一旦前面一个元素大于自己就让前面的元素先后移动
- 2.直到没有可比较元素或者前面的元素小于自己的时候, 就将自己插入到当前空出来的位置
代码实现
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 0.计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 1.从第一个元素开始依次取出所有用于比较元素
for (int i = 1; i < len; i++)
{
// 2.取出用于比较元素
int temp = nums[i];
int j = i;
while(j > 0){
// 3.判断元素是否小于前一个元素
if(temp < nums[j - 1]){
// 4.让前一个元素向后移动一位
nums[j] = nums[j - 1];
}else{
break;
}
j--;
}
// 5.将元素插入到空出来的位置c
nums[j] = temp;
}
}
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 0.计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 1.从第一个元素开始依次取出所有用于比较元素
for (int i = 1; i < len; i++)
{
// 2.遍历取出前面元素进行比较
for(int j = i; j > 0; j--)
{
// 3.如果前面一个元素大于当前元素,就交换位置
if(nums[j-1] > nums[j]){
int temp = nums[j];
nums[j] = nums[j - 1];
nums[j - 1] = temp;
}else{
break;
}
}
}
}
希尔排序
-
1959年Shell发明,第一个突破O(n2)的排序算法,是简单插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
-
排序思路:
- 1.希尔排序可以理解为插入排序的升级版, 先将待排序数组按照指定步长划分为几个小数组
- 2.利用插入排序对小数组进行排序, 然后将几个排序的小数组重新合并为原始数组
- 3.重复上述操作, 直到步长为1时,再利用插入排序排序即可
代码实现
int main()
{
// 待排序数组
int nums[5] = {3, 1, 2, 0, 3};
// 0.计算待排序数组长度
int len = sizeof(nums) / sizeof(nums[0]);
// 2.计算步长
int gap = len / 2;
do{
// 1.从第一个元素开始依次取出所有用于比较元素
for (int i = gap; i < len; i++)
{
// 2.遍历取出前面元素进行比较
int j = i;
while((j - gap) >= 0)
{
printf("%i > %i\n", nums[j - gap], nums[j]);
// 3.如果前面一个元素大于当前元素,就交换位置
if(nums[j - gap] > nums[j]){
int temp = nums[j];
nums[j] = nums[j - gap];
nums[j - gap] = temp;
}else{
break;
}
j--;
}c
}
// 每个小数组排序完成, 重新计算步长
gap = gap / 2;
}while(gap >= 1);
}
折半查找
-
基本思路
-
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
-
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败
-
实现步骤
-
在有序表中,取中间元素作为比较对象,若给定值与中间元素的要查找的数相等,则查找成功;
-
若给定值小于中间元素的要查找的数,则在中间元素的左半区继续查找;
-
若给定值大于中间元素的要查找的数,则在中间元素的右半区继续查找。
-
不断重复上述查找过 程,直到查找成功,或所查找的区域无数据元素,查找失败。
-
代码实现
int findKey(int values[], int length, int key) {
// 定义一个变量记录最小索引
int min = 0;
// 定义一个变量记录最大索引
int max = length - 1;
// 定义一个变量记录中间索引
int mid = (min + max) * 0.5;
while (min <= max) {
// 如果mid对应的值 大于 key, 那么max要变小
if (values[mid] > key) {
max = mid - 1;
// 如果mid对应的值 小于 key, 那么min要变
}else if (values[mid] < key) {
min = mid + 1;
}else {
return mid;
}
// 修改完min/max之后, 重新计算mid的值
mid = (min + max) * 0.5;
}
return -1;c
}
进制转换
- 实现思路:
- 将二进制、八进制、十进制、十六进制所有可能的字符都存入数组
- 利用按位与运算符和右移依次取出当前进制对应位置的值
- 利用取出的值到数组中查询当前位输出的结果
- 将查询的结果存入一个新的数组, 当所有位都查询存储完毕, 新数组中的值就是对应进制的值
代码实现
#include <stdio.h>
void toBinary(int num)
{
total(num, 1, 1);
}
void toOct(int num)
{
total(num, 7, 3);
}
void toHex(int num)
{
total(num, 15, 4);
}
void total(int num , int base, int offset)
{
// 1.定义表用于查询结果
char cs[] = {
'0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', 'a', 'b',
'c', 'd', 'e', 'f'
};
// 2.定义保存结果的数组
char rs[32];
// 计算最大的角标位置
int length = sizeof(rs)/sizeof(char);
int pos = length;//8
while (num != 0) {
int index = num & base;
rs[--pos] = cs[index];
num = num >> offset;
}
for (int i = pos; i < length; i++) {
printf("%c", rs[i]);
}
printf("\n");
}
int main()
{
toBinary(9);
return 0;
}
二维数组
二位数组的定义
int a[2][3];
二位数组初始化
int a[2][3]={ {80,75,92}, {61,65,71}};
// 先定义后初始化
int a[2][3];
a[0][0] = 80;
a[0][1] = 75;
a[0][2] = 92;
a[1][0] = 61;
a[1][1] = 65;
a[1][2] = 71;
// 完全初始化,可以省略第一维的长度
int a[][3]={{1,2,3},{4,5,6}};
int a[][3]={1,2,3,4,5,6};
二维数组的遍历
int i,j;
char cs[2][3] = {
{'a', 'b', 'c'},
{'d', 'e', 'f'}
};
for (int i = 0; i < 2; i++) { // 外循环取出一维数组
// i
for (int j = 0; j < 3; j++) {// 内循环取出一维数组的每个元素c
printf("%c", cs[i][j]);
}
printf("\n");
}
字符串
字符串是位于双引号中的字符序列
- 在内存中以“\0”结束,所占字节比实际多一个
字符串初始化
-
在C语言中没有专门的字符串变量,通常用一个字符数组来存放一个字符串。
- 当把一个字符串存入一个数组时,会把结束符‘\0’存入数组,并以此作为该字符串是否结束的标志。
- 有了‘\0’标志后,就不必再用字符数组 的长度来判断字符串的长度了
-
初始化
-
char name[9] = "lnj"; //在内存中以“\0”结束, \0ASCII码值是0 char name1[9] = {'l','n','j','\0'}; char name2[9] = {'l','n','j',0}; // 当数组元素个数大于存储字符内容时, 未被初始化的部分默认值是0, 所以下面也可以看做是一个字符串 char name3[9] = {'l','n','j'};
字符串输出
-
如果字符数组中存储的是一个字符串, 那么字符数组的输入输出将变得简单方便。
- 不必使用循环语句逐个地输入输出每个字符
- 可以使用printf函数和scanf函数一次性输出输入一个字符数组中的字符串
-
使用的格式字符串为“%s”,表示输入、输出的是一个字符串 字符串的输出
-
输出
- %s的本质就是根据传入的name的地址逐个去取数组中的元素然后输出,直到遇到\0位置
char chs[] = "lnj";
printf("%s\n", chs);
- 注意点:
- \0引发的脏读问题
char name[] = {'c', 'o', 'o', 'l' , '\0'};
char name2[] = {'l', 'n', 'j'};
printf("name2 = %s\n", name2); // 输出结果: lnjcool
输入
char ch[10];
scanf("%s",ch);
- 注意点:
- 对一个字符串数组, 如果不做初始化赋值, 必须指定数组长度
- ch最多存放由9个字符构成的字符串,其中最后一个字符的位置要留给字符串的结尾标示‘\0’
- 当用scanf函数输入字符串时,字符串中不能含有空格,否则将以空格作为串的结束符
字符串常用方法
C语言中供了丰富的字符串处理函数,大致可分为字符串的输入、输出、合并、修改、比较、转 换、复制、搜索几类。
使用这些函数可大大减轻编程的负担。
使用输入输出的字符串函数,在使用前应包含头文件"stdio.h"
使用其它字符串函数则应包含头文件"string.h"
字符串输出函数:puts
-
格式: puts(字符数组名)
-
功能:把字符数组中的字符串输出到显示器。即在屏幕上显示该字符串。
-
优点:
- 自动换行
- 可以是数组的任意元素地址
-
缺点
- 不能自定义输出格式, 例如 puts(“hello %i”);
char ch[] = "lnj";
puts(ch); //输出结果: lnj
// puts函数完全可以由printf函数取代。当需要按一定格式输出时,通常使用printf函数
字符串输入函数:gets
- 格式: gets (字符数组名)
- 功能:从标准输入设备键盘上输入一个字符串。
char ch[30];
gets(ch); // 输入:lnj
puts(ch); // 输出:lnj
/*
可以看出当输入的字符串中含有空格时,输出仍为全部字符串。说明gets函数并不以空格作为字符串输入结束的标志,而只以回车作为输入结束。这是与scanf函数不同的。
注意gets很容易导致数组下标越界,是一个不安全的字符串操作函数
*/
字符串长度
- 利用sizeof字符串长度
- 因为字符串在内存中是逐个字符存储的,一个字符占用一个字节,所以字符串的结束符长度也是占用的内存单元的字节数。
char name[] = "it666";
int size = sizeof(name);// 包含\0
printf("size = %d\n", size); //输出结果:6
利用系统函数
- 格式: strlen(字符数组名)
- 功能:测字符串的实际长度(不含字符串结束标志‘\0’)并作为函数返回值。
char name[] = "it666";
size_t len = strlen(name2);
printf("len = %lu\n", len); //输出结果:5
以“\0”为字符串结束条件进行统计
/**
* 自定义方法计算字符串的长度
* @param name 需要计算的字符串
* @return 不包含\0的长度
*/
int myStrlen2(char str[])
{
// 1.定义变量保存字符串的长度
int length = 0;
while (str[length] != '\0')
{
length++;//1 2 3 4
}
return length;
}
/**
* 自定义方法计算字符串的长度
* @param name 需要计算的字符串
* @param count 字符串的总长度
* @return 不包含\0的长度
*/
int myStrlen(char str[], int count)
{
// 1.定义变量保存字符串的长度
int length = 0;
// 2.通过遍历取出字符串中的所有字符逐个比较
for (int i = 0; i < count; i++) {
// 3.判断是否是字符串结尾
if (str[i] == '\0') {
return length;
}
length++;
}
return length;
}
字符串连接函数:strcat
-
格式: strcat(字符数组名1,字符数组名2)
-
功能:把字符数组2中的字符串连接到字符数组1 中字符串的后面,并删去字符串1后的串标志 “\0”。本函数返回值是字符数组1的首地址。
-
char oldStr[100] = "welcome to"; char newStr[20] = " lnj"; strcat(oldStr, newStr); puts(oldStr); //输出: welcome to lnj"
-
字符串拷贝函数:strcpy
- 格式: strcpy(字符数组名1,字符数组名2)
- 功能:把字符数组2中的字符串拷贝到字符数组1中。串结束标志“\0”也一同拷贝。字符数名2, 也可以是一个字符串常量。这时相当于把一个字符串赋予一个字符数组。
char oldStr[100] = "welcome to";
char newStr[50] = " lnj";
strcpy(oldStr, newStr);
puts(oldStr); // 输出结果: lnj // 原有数据会被覆盖
字符串比较函数:strcmp
- 格式: strcmp(字符数组名1,字符数组名2)
- 功能:按照ASCII码顺序比较两个数组中的字符串,并由函数返回值返回比较结果。
- 字符串1=字符串2,返回值=0;
- 字符串1>字符串2,返回值>0;
- 字符串1<字符串2,返回值<0。
char oldStr[100] = "0";
char newStr[50] = "1";
printf("%d", strcmp(oldStr, newStr)); //输出结果:-1
char oldStr[100] = "1";
char newStr[50] = "1";
printf("%d", strcmp(oldStr, newStr)); //输出结果:0
char oldStr[100] = "1";
char newStr[50] = "0";
printf("%d", strcmp(oldStr, newStr)); //输出结果:1
字符串数组基本概念
字符串数组其实就是定义一个数组保存所有的字符串
1.一维字符数组中存放一个字符串,比如一个名字char name[20] = “nj”
2.如果要存储多个字符串,比如一个班所有学生的名字,则需要二维字符数组,char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)
如果要存储两个班的学生姓名,那么可以用三维字符数组char names[2][15][20]
##字符串数组的初始化
char names[2][10] = { {'l','n','j','\0'}, {'l','y','h','\0'} };
char names2[2][10] = { {"lnj"}, {"lyh"} };
char names3[2][10] = { "lnj", "lyh" };
函数
函数的概念
函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数,即主函数 main() ,所有简单的程序都可以定义其他额外的函数。
您可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由您来决定的,但在逻辑上,划分通常是根据每个函数执行一个特定的任务来进行的。
函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。
C 标准库提供了大量的程序可以调用的内置函数。例如,函数 strcat() 用来连接两个字符串,函数 memcpy() 用来复制内存到另一个位置。
函数还有很多叫法,比如方法、子例程或程序,等等。
函数分类
-
从函数定义的角度看,函数可分为库函数和用户定义函数两种
- 库函数: 由C语言系统提供,用户无须定义,也不必在程序中作类型说明,只需在程序前包含有该函数原型的头文件即可在程序中直接调用。在前面各章的例题中反复用到printf、scanf、getchar、putchar等函数均属此类
- ***用户定义函数:***由用户按需编写的函数。对于用户自定义函数,不仅要在程序中定义函数本身,而且在主调函数模块中还必须对该被调函数进行类型说明,然后才能使用
-
从函数执行结果的角度来看, 函数可分为有返回值函数和无返回值函数两种
- 有返回值函数: 此类函数被调用执行完后将向调用者返回一个执行结果,称为函数返回值。(必须指定返回值类型和使用return关键字返回对应数据)
- 无返回值函数: 此类函数用于完成某项特定的处理任务,执行完成后不向调用者返回函数值。(返回值类型为void, 不用使用return关键字返回对应数据)
-
从主调函数和被调函数之间数据传送的角度看,又可分为无参函数和有参函数两种
- 无参函数: 在函数定义及函数说明及函数调用中均不带参数。主调函数和被调函数之间不进行参数传送。
- 有参函数: 在函数定义及函数说明时都有参数,称为形式参数(简称为形参)。在函数调用时也必须给出参数,称为实际参数(简称为实参)
函数的定义
定义函数的步骤
- 函数名:函数叫什么名字
- 函数体:函数是干啥的,里面包含了什么代码
- 返回值类型: 函数执行完毕返回什么和调用者
返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2,…) {
函数体;
返回值;
}
- 无参无返回值
- 没有返回值时return可以省略
void rose() {
printf(" {@}\n");
printf(" |\n");
printf(" \\|/\n"); // 注意: \是一个特殊的符号(转意字符), 想输出\必须写两个斜线
printf(" |\n");
// 如果函数不需要返回数据给调用者, 那么函数中的return可以不写
}
-
有参数无返回值
void 函数名(参数类型 形式参数1,参数类型 形式参数2,…) { 函数体; }
-
无参有返回值
-
int getMax() { printf("请输入两个整数, 以逗号隔开, 以回车结束\n"); int number1, number2; scanf("%i,%i", &number1, &number2); int max = number1 > number2 ? number1 : number2; return max; }
-
有参有返回值
int printMax(int value1, int value2) {
int max = value1 > value2 ? value1 : value2;
return max;
}
函数的参数
- 形式参数
- 在***定义函数***时,函数名后面小括号()中定义的变量称为形式参数,简称形参
- 形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元。
- 因此,形参只有在函数内部有效,函数调用结束返回主调函数后则不能再使用该形参变量
int max(int number1, int number2) // 形式参数
{
return number1 > number2 ? number1 : number2;
}
- 实际参数
- 在***调用函数***时, 传入的值称为实际参数,简称实参
- 实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须具有确定的值,以便把这些值传送给形参
- 因此应预先用赋值,输入等办法使实参获得确定值
int main() {
int num = 99;
// 88, num, 22+44均能得到一个确定的值, 所以都可以作为实参
max(88, num, 22+44); // 实际参数
return 0;
}
注意
- 调用函数时传递的实参个数必须和函数的形参个数必须保持一致
- 形参实参类型不一致, 会自动转换为形参类型
- 当使用基本数据类型(char、int、float等)作为实参时,实参和形参之间只是值传递,修改形参的值并不影响到实参函数可以没有形参
返回值类型注意:
- 如果没有写返回值类型,默认是int
- 函数返回值的类型和return实际返回的值类型应保持一致。如果两者不一致,则以返回值类型为准,自动进行类型转换
- 一个函数内部可以多次使用return语句,但是return语句后面的代码就不再被执行
函数的声明
#include <stdio.h>
/* 函数声明 */
int max(int num1, int num2);
int main ()
{
/* 局部变量定义 */
int a = 100;
int b = 200;
int ret;
/* 调用函数来获取最大值 */
ret = max(a, b);
printf( "Max value is : %d\n", ret );
return 0;
}
/* 函数返回两个数中较大的那个数 */
int max(int num1, int num2)
{
/* 局部变量声明 */
int result;
if (num1 > num2)
result = num1;
else
result = num2;
return result;
}
指针
学习 C 语言的指针既简单又有趣。通过指针,可以简化一些 C 编程任务的执行,还有一些任务,如动态内存分配,没有指针是无法执行的。所以,想要成为一名优秀的 C 程序员,学习指针是很有必要的。
正如您所知道的,每一个变量都有一个内存位置,每一个内存位置都定义了可使用 & 运算符访问的地址,它表示了在内存中的一个地址。
指针也就是内存地址,指针变量是用来存放内存地址的变量。就像其他变量或常量一样,您必须在使用指针存储其他变量地址之前,对其进行声明。
指针变量
在C语言中,允许用一个变量来存放其它变量的地址, 这种专门用于存储其它变量地址的变量, 我们称之为指针变量
int age;// 定义一个普通变量
num = 10;
int *pnAge; // 定义一个指针变量
pnAge = &age;
指针的使用
使用指针时会频繁进行以下几个操作:定义一个指针变量、把变量地址赋值给指针、访问指针变量中可用地址的值。这些是通过使用一元运算符 ***** 来返回位于操作数所指定地址的变量的值。下面的实例涉及到了这些操作:
#include <stdio.h>
int main ()
{
int var = 20; /* 实际变量的声明 */
int *ip; /* 指针变量的声明 */
ip = &var; /* 在指针变量中存储 var 的地址 */
printf("var 变量的地址: %p\n", &var );
/* 在指针变量中存储的地址 */
printf("ip 变量存储的地址: %p\n", ip );
/* 使用指针访问值 */
printf("*ip 变量的值: %d\n", *ip );
return 0;
}
二级指针
- 如果一个指针变量存放的又是另一个指针变量的地址,则称这个指针变量为指向指针的指针变量。也称为“二级指针”
char c = 'a';
char *cp;
cp = &c;
char **cp2;
cp2 = &cp;
printf("c = %c", **cp2);
指针访问数组
数组元素指针
- 一个变量有地址,一个数组包含若干元素,每个数组元素也有相应的地址, 指针变量也可以保存数组元素的地址
- 只要一个指针变量保存了数组元素的地址, 我们就称之为数组元素指针
int a[10] = {1,2,3,4,5,6,7,8,9,10};
int *p = &a[0];
printf("%p,%p", &(a[0]), a); //输出结果:0x1100, 0x1100
- 注意: 数组名a不代表整个数组,只代表数组首元素的地址。
- “p=a;”的作用是“把a数组的首元素的地址赋给指针变量p”,而不是“把数组a各元素的值赋给 p”
int a[5] = {2, 4, 6, 8, 22};
int *p;
// p = &(a[0]);
p = a;
printf(“%d %d\n”,a[0],*p); // 输出结果: 2, 2
- 在指针指向数组元素时,允许以下运算:
- 加一个整数(用+或+=),如p+1
- 减一个整数(用-或-=),如p-1
- 自加运算,如p++,++p
- 自减运算,如p–,–p
指向函数指针
函数作为一段程序,在内存中也要占据部分存储空间,它也有一个起始地址
函数有自己的地址,那就好办了,我们的指针变量就是用来存储地址的。
因此可以利用一个指针指向一个函数。其中,函数名就代表着函数的地址。
指针函数的定义
格式: 返回值类型 (*指针变量名)(形参1, 形参2, …);
int sum(int a,int b)
{
return a + b;
}
int (*p)(int,int);
p = sum;
-
指针函数定义技巧
- 1、把要指向函数头拷贝过来
- 2、把函数名称使用小括号括起来
- 3、在函数名称前面加上一个*
- 4、修改函数名称
-
应用场景
- 调用函数
- 将函数作为参数在函数间传递
-
注意点:
- 由于这类指针变量存储的是一个函数的入口地址,所以对它们作加减运算(比如p++)是无意义的
- 函数调用中"(指针变量名)"的两边的括号不可少,其中的不应该理解为求值运算,在此处它 只是一种表示符号
结构体
什么是结构体
- 结构体和数组一样属于构造类型
- 数组是用于保存一组相同类型数据的, 而结构体是用于保存一组不同类型数组的
- 例如,在学生登记表中,姓名应为字符型;学号可为整型或字符型;年龄应为整型;性别应为字符型;成绩可为整型或实型。
- 显然这组数据不能用数组来存放, 为了解决这个问题,C语言中给出了另一种构造数据类型——“结构(structure)”或叫“结构体”。
定义结构体类型
struct Student {
char *name; // 姓名
int age; // 年龄
float height; // 身高
};
定义结构体变量
struct Student {
char *name;
int age;
} stu;
// #################
struct Student {
char *name;
int age;
};
struct Student stu;
// 匿名结构体变量
struct {
char name;
int age;
} stu;
结构体成员访问
// 一般对结构体变量的操作是以成员为单位进行的,引用的一般形式为:结构体变量名.成员名
struct Student {
char name;
int age;
};
struct Student stu;
// 访问stu的age成员
stu.age = 17;
printf("age = %d", stu.age);
结构体变量初始化
struct Student {
char *name;
int age;
};
struct Student stu = {"ning"", 21};
// 定义后逐个初始化
struct Student {
char *name;
int age;
};
struct Student stu;
stu.name = "lnj";
stu.age = 35;
#include <stdio.h>
#include <string.h>
struct Books
{
char title[50];
char author[50];
char subject[100];
int book_id;
};
int main( )
{
struct Books Book1; /* 声明 Book1,类型为 Books */
struct Books Book2; /* 声明 Book2,类型为 Books */
/* Book1 详述 */
strcpy( Book1.title, "C Programming");
strcpy( Book1.author, "Nuha Ali");
strcpy( Book1.subject, "C Programming Tutorial");
Book1.book_id = 6495407;
/* Book2 详述 */
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Zara Ali");
strcpy( Book2.subject, "Telecom Billing Tutorial");
Book2.book_id = 6495700;
/* 输出 Book1 信息 */
printf( "Book 1 title : %s\n", Book1.title);
printf( "Book 1 author : %s\n", Book1.author);
printf( "Book 1 subject : %s\n", Book1.subject);
printf( "Book 1 book_id : %d\n", Book1.book_id);
/* 输出 Book2 信息 */
printf( "Book 2 title : %s\n", Book2.title);
printf( "Book 2 author : %s\n", Book2.author);
printf( "Book 2 subject : %s\n", Book2.subject);
printf( "Book 2 book_id : %d\n", Book2.book_id);
return 0;
}
结构体数组
struct Student {
char *name;
int age;
};
struct Student stu[2];
结构体指针
// 定义一个结构体类型
struct Student {
char *name;
int age;
};
// 定义一个结构体变量
struct Student stu = {“lnj", 18};
// 定义一个指向结构体的指针变量
struct Student *p;
// 指向结构体变量stu
p = &stu;
/*
这时候可以用3种方式访问结构体的成员
*/
// 方式1:结构体变量名.成员名
printf("name=%s, age = %d \n", stu.name, stu.age);
// 方式2:(*指针变量名).成员名
printf("name=%s, age = %d \n", (*p).name, (*p).age);
// 方式3:指针变量名->成员名
printf("name=%s, age = %d \n", p->name, p->age);
return 0;
}
/*通过结构体指针访问结构体成员, 可以通过以下两种方式
(*结构指针变量).成员名
结构指针变量->成员名(用熟)
*/
共用体
- 和结构体不同的是, 结构体的每个成员都是占用一块独立的存储空间, 而共用体所有的成员都占用同一块存储空间
- 和结构体一样, 共用体在使用之前必须先定义共用体类型, 再定义共用体变量
格式
union 共用体名{
数据类型 属性名称;
数据类型 属性名称;
... ....
};
union Data
{
int i;
float f;
char str[20];
} data;
访问
#include <stdio.h>
#include <string.h>
union Data
{
int i;
float f;
char str[20];
};
int main( )
{
union Data data;
data.i = 10;
data.f = 220.5;
strcpy( data.str, "C Programming");
printf( "data.i : %d\n", data.i);
printf( "data.f : %f\n", data.f);
printf( "data.str : %s\n", data.str);
return 0;
}
枚举
-
枚举使用的注意
- C语言编译器会将枚举元素(spring、summer等)作为整型常量处理,称为枚举常量。
- 枚举元素的值取决于定义时各枚举元素排列的先后顺序。默认情况下,第一个枚举元素的值为0,第二个为1,依次顺序加1。
- 也可以在定义枚举类型时改变枚举元素的值
enum Season { Spring, Summer, Autumn, Winter } s; // 也就是说spring的值为0,summer的值为1,autumn的值为2,winter的值为3 enum Season { Spring = 9, Summer, Autumn, Winter }; // 也就是说spring的值为9,summer的值为10,autumn的值为11,winter的值为12
关键字
-
auto关键字(忘记)
-
只能修饰局部变量, 局部变量如果没有其它修饰符, 默认就是auto的
-
特点: 随用随开, 用完即销
-
auto int num; // 等价于 int num;
-
-
register关键字(忘记)
-
只能修饰局部变量, 原则上将内存中变量提升到CPU寄存器中存储, 这样访问速度会更快
-
但是由于CPU寄存器数量相当有限, 通常不同平台和编译器在优化阶段会自动转换为auto
-
register int num;
-
-
static关键字
-
对局部变量的作用
-
延长局部变量的生命周期,从程序启动到程序退出,但是它并没有改变变量的作用域
-
定义变量的代码在整个程序运行期间仅仅会执行一次
-
// 声明一个内部函数 static int sum(int num1,int num2); // 定义一个内部函数 static int sum(int num1,int num2){ return num1 + num2; }
对全局变量的作用
全局变量分类:
内部变量:只能在本文件中访问的变量
外部变量:可以在其他文件中访问的变量,默认所有全局变量都是外部变量
默认情况下多个同名的全局变量共享一块空间, 这样会导致全局变量污染问题
如果想让某个全局变量只在某个文件中使用, 并且不和其他文件中同名全局变量共享同一块存储空间, 那么就可以使用static -
-
-
extern关键字
-
对局部变量的作用
-
extern不能用于局部变量
-
extern代表声明一个变量, 而不是定义一个变量, 变量只有定义才会开辟存储空间
-
所以如果是局部变量, 虽然提前声明有某个局部变量, 但是局部变量只有执行到才会分配存储空间
-
// 声明一个外部函数 extern int sum(int num1,int num2); // 定义一个外部函数 extern int sum(int num1,int num2){ return num1 + num2; }
-
-
-
注意点:
- 由于默认情况下所有的函数都是外部函数, 所以extern一般会省略
- 如果只有函数声明添加了static与extern, 而定义中没有添加static与extern, 那么无效
typedef关键字
typedef int INTEGER
INTEGER a; // 等价于 int a;
宏定义
被定义为“宏”的标识符称为“宏名”。在编译预处理时,对程序中所有出现的“宏名”,都用宏定义中的字符串去代换,这称为“宏代换”或“宏展开”。
宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。在C语言中,“宏”分为有参数和无参数两种。
##不带参数的宏定义
格式:#define 标识符 字符串
其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。
#include <stdio.h>
// 源程序中所有的宏名PI在编译预处理的时候都会被3.14所代替
#define PI 3.14
// 根据圆的半径计radius算周长
float girth(float radius) {
return 2 * PI *radius;
}
int main ()
{
float g = girth(2);
printf("周长为:%f", g);
return 0;
}
文件操作
模式 | 描述 |
---|---|
r | 打开一个已有的文本文件,允许读取文件。 |
w | 打开一个文本文件,允许写入文件。如果文件不存在,则会创建一个新文件。在这里,您的程序会从文件的开头写入内容。如果文件存在,则该会被截断为零长度,重新写入。 |
a | 打开一个文本文件,以追加模式写入文件。如果文件不存在,则会创建一个新文件。在这里,您的程序会在已有的文件内容中追加内容。 |
r+ | 打开一个文本文件,允许读写文件。 |
w+ | 打开一个文本文件,允许读写文件。如果文件已存在,则文件会被截断为零长度,如果文件不存在,则会创建一个新文件。 |
a+ | 打开一个文本文件,允许读写文件。如果文件不存在,则会创建一个新文件。读取会从文件的开头开始,写入则只能是追加模式。 |
#include <stdio.h>
int main()
{
FILE *fp = fopen("test.txt", "w+");
fclose(fp); // 关闭文件
return 0;
}
- 延长局部变量的生命周期,从程序启动到程序退出,但是它并没有改变变量的作用域
- 定义变量的代码在整个程序运行期间仅仅会执行一次
- ```c
// 声明一个内部函数
static int sum(int num1,int num2);
// 定义一个内部函数
static int sum(int num1,int num2){
return num1 + num2;
}
```
对全局变量的作用
全局变量分类:
内部变量:只能在本文件中访问的变量
外部变量:可以在其他文件中访问的变量,默认所有全局变量都是外部变量
默认情况下多个同名的全局变量共享一块空间, 这样会导致全局变量污染问题
如果想让某个全局变量只在某个文件中使用, 并且不和其他文件中同名全局变量共享同一块存储空间, 那么就可以使用static
-
extern关键字
-
对局部变量的作用
-
extern不能用于局部变量
-
extern代表声明一个变量, 而不是定义一个变量, 变量只有定义才会开辟存储空间
-
所以如果是局部变量, 虽然提前声明有某个局部变量, 但是局部变量只有执行到才会分配存储空间
-
// 声明一个外部函数 extern int sum(int num1,int num2); // 定义一个外部函数 extern int sum(int num1,int num2){ return num1 + num2; }
-
-
-
注意点:
- 由于默认情况下所有的函数都是外部函数, 所以extern一般会省略
- 如果只有函数声明添加了static与extern, 而定义中没有添加static与extern, 那么无效
typedef关键字
typedef int INTEGER
INTEGER a; // 等价于 int a;
宏定义
被定义为“宏”的标识符称为“宏名”。在编译预处理时,对程序中所有出现的“宏名”,都用宏定义中的字符串去代换,这称为“宏代换”或“宏展开”。
宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。在C语言中,“宏”分为有参数和无参数两种。
##不带参数的宏定义
格式:#define 标识符 字符串
其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。
#include <stdio.h>
// 源程序中所有的宏名PI在编译预处理的时候都会被3.14所代替
#define PI 3.14
// 根据圆的半径计radius算周长
float girth(float radius) {
return 2 * PI *radius;
}
int main ()
{
float g = girth(2);
printf("周长为:%f", g);
return 0;
}
文件操作
模式 | 描述 |
---|---|
r | 打开一个已有的文本文件,允许读取文件。 |
w | 打开一个文本文件,允许写入文件。如果文件不存在,则会创建一个新文件。在这里,您的程序会从文件的开头写入内容。如果文件存在,则该会被截断为零长度,重新写入。 |
a | 打开一个文本文件,以追加模式写入文件。如果文件不存在,则会创建一个新文件。在这里,您的程序会在已有的文件内容中追加内容。 |
r+ | 打开一个文本文件,允许读写文件。 |
w+ | 打开一个文本文件,允许读写文件。如果文件已存在,则文件会被截断为零长度,如果文件不存在,则会创建一个新文件。 |
a+ | 打开一个文本文件,允许读写文件。如果文件不存在,则会创建一个新文件。读取会从文件的开头开始,写入则只能是追加模式。 |
#include <stdio.h>
int main()
{
FILE *fp = fopen("test.txt", "w+");
fclose(fp); // 关闭文件
return 0;
}