C语言笔记

标识符

用来标识数据类型，变量，函数，语句的符号

类别	关键字
数据类型关键字	char，double，enum，float，int，long，short，signed，struct，union，unsigned，void
控制语句关键字	break，continue，case，do，default，else，for，goto，if，return，switch，while
存储类型关键字	auto，extern，register，static
其他关键字	const，sizeof，typedef，volatile

数据类型

常量和变量

• 常量：值一直不变的量
• 变量：值可以变化的量

变量

定义格式

类型说明符    变量名；

eg:

int  variable;   //定义一个整形变量

整形变量

short int	短整型	2
int	整型	4
long int	长整型	4
unsigned short	无符号短整型	2
unsigned int	无符号整型	4
unsigned long	无符号长整型	4

• 无符号整数占用的字节数与相应的有符号整数相同。但是不能表示负数。
• 有符号整数以二进制补码形式存储，最左边第一位是符号位。0正1负
• 无符号整数以二进制原码形式存储。
• 可以和unsigned组合，定义无符号整数，打印时占位符用%u

eg：

#include<stdio.h>
int main(){
	int Jinjian;
	Jinjian = 100;
	printf("Jinjian的值是%d\n",Jinjian);
	Jinjian = 200;
	printf("Jinjian的值是%d\n",Jinjian);
	return 0;
} 

浮点型变量

float	单精度
double	双精度

#include<stdio.h>
int main(){
	float Jinjian;
	Jinjian = 100.000;
	printf("Jinjian的值是%f\n",Jinjian);
	Jinjian = 200.564;
	printf("Jinjian的值是%f\n",Jinjian);
	return 0;
} 

字符型变量

关键词char

eg：

#include<stdio.h>
int main(){
	char Jinjian;
	Jinjian = 'A';
	printf("Jinjian的值是%c\n",Jinjian);
	Jinjian = 'C';
	printf("Jinjian的值是%c\n",Jinjian);
	return 0;
} 

常量

（程序在执行过程中，值不发生改变的 量。）

整型常量

• 包括，正整数，0，负整数（这个很重要，容易把0忘了）。

浮点型常量

• 浮点型数，小数点是浮动的。

字符常量

• 字符型常量指的是单个字符，用一对单引号表示。每个字符在内存中占用一个字节。
• C语言中的字符常量具有数值特征，可以像整数一样参加运算，此时相当于对字符的ASCII码的运 算。

字符串常量

• 字符串常量是由一对双引号括起来的零个或者多个字符序列。
• 字符串常量在内存中占用一段连续的存储单元，系统在每个字符串的尾部加上’\0’作为字符从的结 束标志
• 因此n个字符组成的字符串，在内存中要占用n+1个字节空间。
• 可以使用sizeof运算符来计算字符串占用的字节数。

eg：

#include<stdio.h>
int main(){
	int a = sizeof("I will never forget you!");
	printf("a = %d",a);
	return 0;
} 

宏定义（符号常量）

#define 标识符 常量值

# 注意，末尾不能加;
#define PI 3.14159 # 这种语法规则

#define PRICE 20
#define OK 666
#include<stdio.h>

int main(void){
	int changdu;
	changdu = sizeof("helloworld");
	printf("字符串的长度是%d",changdu);
	printf("%d\n",PRICE);
	printf("%d",PI);
	return OK;
}

变量的定义和使用

所以变量都要先定义再初始化

先定义再初始化

int a,r;
	a = 3;

定义的同时初始化

int x = 100;
char ch = 'x';
int a = 0, b = 1;

变量的使用例子

#include "stdio.h"

int main(){
	int num;
	printf("输入一些数字： ");
	scanf("%d",&num);
	printf("\n");
	printf("输入的数字是：%d",num);
	return 0;
}

运算符和表达式

赋值运算符

赋值运算符的左侧必须是个变量

运算符	含义	例子
+=	加法赋值	x += 5; // 等价于 x = x + 5;
-=	减法赋值	x -= 5; // 等价于 x = x - 5;
*=	乘法赋值	x *= 5; // 等价于 x = x * 5;
/=	除法赋值	x /= 5; // 等价于 x = x / 5;
<<=	取模赋值	x %= 5; // 等价于 x = x % 5;
>>=	左移位赋值	x <<= 5; // 等价于 x = x << 5;
&=	按位与赋值	x &= 5; // 等价于 x = x & 5;
^=	按位异或赋值	x ^= 5; // 等价于 x = x ^ 5;
|=	按位或赋值	x |=5; //等价于x = x | 5;

算数运算符

运算符	含义
+	加
-	减
=	等于
/	除
%	取余

自增运算符

运算符	含义
++x;	加号在前，先把x的值+1，再把加了之后的值给变量a
x++;	加号在后，先把x的值赋值给变量a，再把x的值+1
–x;	减号在前，先把x的值-1，再把减了之后的值给变量a
x–;	减在后，先把x的值赋值给变量a，再把x的值-1

sizeof

求字节数

eg：

#include<stdio.h>

int main(){
	printf("字节数：%d\n",sizeof("I will never forget you!"));
	printf("字节数：%d",sizeof("I don't know why I want to rember you forever!"));
	return 666;
}

数据类型转换

• 不同的数据类型放在一块一起运算，需要转换成相同的类型才能进行运算。
• （中国人和外国人，之间交流，也需要转换，总要有一个人，要学中文，或者一个人学英文）

自动转换

系统按照默认的规则转换。

强制转换

格式：（类型说明符） （表达式）;

eg:

#include "stdio.h"

int main(){
	int a = 6,b = 4;
	float c;
	c = float(a + b) / 3;
	printf("字节数：%f",c);
	return 666;
}

运算符的优先级

进制

进制也就是进位计数制，是人为定义的计数方法。 对于任何一种进制—X进制，就表示每一位上的数运 算时都是逢X进一位。 十进制是逢十进一，十六进制是逢十六进一，二进制就是逢二进一，以此类推，x进制就是逢x进位。

位

计数单位是，位或者比特（bit），简写，小写b，每个位只能存放1个二进制位。

字节

Byte，字节。1个字节=8位。除此之外，还有KB，MB，GB，TB，PB，EB。1KB=1024B=2的10次方B。

R进制转换为10进制

点，为分隔符。例如10进制。326.56。

326.56  =  3*10^2  +  2*10^1  +  6*10^0  +  5*10^-1  +  6*10^-2

例如8进制，165.2

165.2  =  1*8^2  +  6*8^1  +  5*8^0  +  2*8^-1

例如8进制。165.2

165.2  =  1*8^2  +  6*8^1  +  5*8^0  +  2*8^-1

例如2进制。1011.1。

1011.1  =  1*2^3  +  0*2^2  +  1*2^1  +  1*2^0  +  1*2^-1 

通过这种规律，可以将所有其他进制转换为10进制。

10进制转R进制

十进制有整数部分和小数部分，需要分开转换。整数部分：除R取余。

小数部分：乘R取整。

2进制<–>8进制

以小数点为基准，向左右两边划分，每三位一组，不够的补0

2进制<–>16进制

有符号无符号数

计算机中规定：二进制数的最高位是符号位。0，表示该数是正数，1，表示该数为负数。

所以，正数50就是   00110010 负数50就是 10110010

定点整数和定点小数

010Editor

数据在电脑中是如何储存的可以通过010 Editor来观察

原码反码补码

所有的0和1代码，在电路中表现，都是加减的操作。按照常规思路，应该是下面这种。

+40 00101000
-43 10101011
# 直接相加的结果是11010011，也就是 -83

+40 00101000
+43 00101011
# 直接相加的结果是01010011，也就是 +83

计算机中存放的数，是以补码存在和运算的。

原码

一个二进制数同时包含符号和数值两个部分，最高位是符号位。

反码

• 正数，的原码和反码相同。
• 负数，其反码，除了符号位不变外，其余各位，0换成1，1换成0

补码

• 正数的，补码和原码相同。
• 负数的，补码=反码+1。

顺序结构程序设计

顺序式样

输出printf()

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

输入scanf()

#include<stdio.h>

int main(){
	int num;
	printf("需要输入一个数字："):
	scanf("%d",&num);
	printf("刚刚输入的数字是：%d"，num);
	return 0;
}

scanf和printf，这两个函数格式(你希望以什么样的形式输入，希望以什么样的形式输出)

printf("格式控制字符串",输出列表项);

scanf("格式控制字符串",输出列表项);

高频使用格式整理

%d	十进制(int)
%o	八进制（int）
%x，%X	十六进制（int）
%u	十进制（无符号）（int）
%f	（ float 和 double ）
%l	输出长整型
%m	输出指定宽度。如果值>m，输出实际。否则，空格补全
%c	单个字符

#include "stdio.h"

int main() {
    int zhengshu=12341231;
    float fudianshu=123055.150544;
    char danzifu='M';
    int shijinzhi=60;
    printf("得到的结果是：%d",zhengshu);
    printf("\n");
    printf("得到的结果是：%o",shijinzhi);
    printf("\n");
    printf("得到的结果是：%x",shijinzhi);
    printf("\n");
    printf("得到的结果是：%u",shijinzhi);
    printf("\n");
    printf("得到的结果是：%lf",fudianshu);
    printf("\n");
    printf("得到的结果是：%f",fudianshu);
    printf("\n");
    printf("得到的结果是：%3.1f",fudianshu);
    printf("\n");
    printf("得到的结果是：%10d",zhengshu);
    printf("\n");
    printf("得到的结果是：%c",danzifu);
    
    return 666;
}

字符数据输入和输出

用于单个字符。getchar和putchar。

#include<stdio.h>

int main(){
	char Yliken;
	Yliken = getchar();
	printf("输入的结果是: %c\n",Yliken);
	printf("输入的结果是: ");
	putchar(Yliken);
	return 0;
}

数学标准函数

有些函数需要引入，math.h，有些引入标准库即可。

函数名	含义
abs()	求绝对值
acos()	求反余弦
asin()	求反正弦
atan()	求反正切
atan2()	求反正切，按符号判定象限
ceil()	求不小于某值的最小正数。
cos()	求余弦
fabs()	求浮点数的绝对值
floor()	求不大于某值的最大整数

#include "stdio.h"
#include "math.h"

int main() {
 	int num;
 	int result;
	printf("输入一个数字：");
	scanf("%d",&num);
 	result = sqrt(num);
 	printf("计算的结果是：%d", result);
 	return 666;
}

循环结构

for循环

格式

for(表达式1;表达式2;表达式3){
 循环体语句;
}

情况1：

for(;表达式2;表达式3)
 循环体语句;
 

#省略表达式1，这种写法是将循环变量赋初值放在for之前

#include "stdio.h"

int main() {
 
	int index;
	int sum=0;
	for(index=1;index<=30;index++){
	sum = sum +index;
}
	printf("%d",sum);
	return 666;
}

#等价于

#include "stdio.h"
	int main() {
 
	int index=1;
	int sum=0;
	for(;index<=30;index++){
	sum = sum +index;
}
	printf("%d",sum);
	return 123;
}

情况2

for(表达式1;;表达式3)
 循环体语句;

#省略表达式2，表示不对循环进行控制，此时如果没有进行其他处理的话，会形成死循环，应避免这种for结构。

#include "stdio.h"

int main() {
 
	int index;
	for(index=1;;index++){
	printf("%d",index);
	printf("\n");
	printf("\n");
}
 
 return 123;
}

情况3

for(表达式1;表达式2;)
 循环体语句;
 

#省略表达式3，可以在循环体语句中加入修改循环变量的值的语句

#include "stdio.h"

int main() {
 
	int index;
	int sum=0;
	for(index=1;index<=30;index+=8){
	sum = sum +index;
}
	printf("%d",sum);
	return 666;
	}

#等价于

#include "stdio.h"

int main() {
 
	int index;
	int sum=0;
	for(index=1;index<=30;){
	sum = sum +index;
	index=index+8;
}
	printf("%d",sum);
	return 123;
}

• for循环中的，表达式1和表达式3也可以是逗号表达式（建议少用）
• 只要表达式2的值非0，就执行循环体
• 当然，还有其他的变形，但是不建议使用变形（会基本结构和上面三种变形即可）

while语句

格式
while(表达式){
 循环体;
}

• 计算表达式的值，如果为真，向下执行，如果为假，执行while语句块下面的
• 执行循环体
• 返回第一步
• 结束循环，执行while语句块下面的语句
• 先判断循环条件，再执行循环体。

// 计算100以内的所有数的和

#include "stdio.h"

int main() {
 
	int index=1;
	int sum=0;
	while(index<=10){
	sum = sum + index;
	printf("当前的总和是：%d",sum);
	index=index+1;
	printf("\n");
	printf("\n");
}
 
	printf("helloworld");
 
	return 123;
}

do-while语句

格式
do
	循环体
while(表达式);

#include "stdio.h"
	int main() {
 
	int index=1;
	int sum=0;
 
	do{
	sum = sum + index;

	printf("当前的总和是：%d",sum);

	index=index+1;
	printf("\n");
	printf("\n");
	}
	while(index<=10);
	printf("helloworld");
 
	return 123;
}

• while循环和do while循环，有不太一样的地方
• 先执行循环体语句 计算表达式的值，如果为真，返回到第一步，如果为假，结束循环，执行语句块下面的内容
• do后面没有分号，while(表达式)后面有分号。
• 循环体中必须有改变循环条件的语句，否则会出现死循环

break和continue

• break：用于循环语句中，可使程序终止循环，而转去执行循环语句的后继语句。
• continue：跳过循环体中，continue后面的语句，继续下一次循环。

数组

数组是相同数据类型的，有序数据的集合。（有序数据指的是数据中的每一个数据都是有序号的，按顺 序排序的）

• 如论如何记住一点：数组名是数组首个元素的地址。

1 维数组定义

格式
类型名 数值名[常量表达式]；

int num[80];   // 定义了一个整型一维数组，数组名是num，含有80个元素，从num[0]到num[79]，总共80个值。

同一数组的数组元素在内存中用的是一片连续的存储单元。(和内存有关系)

int a[8]; #定义一个有8个整型元素的数组a
char ch[80]; #定义一个有80个字符型元素的数组ch
float f[7]; #定义一个有7个浮点型元素的数据f

1 维数组初始化

• 定义的同时初始化（初始状态）

  int a[6]={1,2,3,4,5,6}; // 规范
  // 等价于
  int a[]={1,2,3,4,5,6};

• 只给几个赋值，其他的都是0。

  int a[6]={1,2,3};

• 一个数组中所有的元素都是0，可以简写

  int a[6]={0};

相关demo

#include "stdio.h"

int main() {
 
	int num[6]={0,1,2,3,4,5};
	printf("%d",num[3]);
 
	return 666;
}

==========================================

#include "stdio.h"

int main() {
 
	int num[6]={0,1,2,3,4,5};
	printf("%d",num[3]);
	printf("\n");
	num[3]=1000;
	printf("%d",num[3]);
 
	return 666;
}

2维数组定义

• 存储4名学生3门课程的成绩。

  int score[4][3];

• 表示方式

  int score[4][3]; #4行3列
  # 从score[0][0]到score[3][2]，分别代表行和列
  # 列，从第0列到第2列
  # 行，从第0行到第3行
  # 下标

  

多维数组

score[4][3]可以看成是

score[0]的数组元素有score[0][1],score[0][2],score[0][3]
score[1]的数组元素有score[1][1],score[1][2],score[1][3]
score[2]的数组元素有score[2][1],score[2][2],score[2][3]
score[3]的数组元素有score[3][1],score[3][2],score[3][3]

• 二位数组（包含更多维数组）在内存中是按行存放的。在内存中先存放第1行，再存放第2行，以此类推

  score[1][1]=5; # 二维数组元素的赋值和引用

2 维数组的初始化

• 按行赋值，这种方式比较直观

  int a[3][4]={
      {1,2,3,4},
      {5,6,7,8},
      {9,10,11,12}
  };

• 所有数据都放到一个大括号里面，按数组元素排列的顺序赋值

  int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};

• 部分赋值，其他没有赋值的元素初始值为0

  int a[3][4]={
      {1},
      {5,6},
      {0,0,11}
  };

• 行可以省略，但是列不能省略

  int b[2][3]={1,2,3,4,5,6}
  
  int b[][3]={1,2,3,4,5,6}

scanf补充

#include<stdio.h>

int main() {
    printf("输入：");
    int a,b;
    scanf("%d",&a);
    scanf("%d",&b);
    printf("%d\n",a);
    printf("%d\n",b);
    return 666;
}

也就是说，黑窗口是可以输入内容的，但是输入的内容，有没有被程序读取到，那就的看scanf的顺序了

加了循环，能多读取几个。不加循环，那就读取一个。。

字符组成的数组

字符数组定义

• 和整型数组一样，也分为一维字符数组和二维字符数组。
• (由一个一个的字符组成的数组)

一维字符数组

char str[5]; #定义了一个字符数组，可以存储5个字符型数据

二维字符数组

char book[5][20]; #定义一个二维数组，用来存放5本书的书名

字符数组的初始化

用数组的方式来存放字符串，数组里面的每一个值，都是一个字符。

方式1：直接赋值。

char str[5]={'c','h','i','n','a'};
char str[]={'c','h','i','n','a'};
# 这样赋值之后，那么
str[0]='c'
str[1]='h'
str[2]='i'
str[3]='n'
str[4]='a'

# 打印字符数组里面的所有字符
#include "stdio.h"

int main() {
	char str[5]={'C','H','I','N','A'};
	for(int index=0;index<5;index++){
	printf("%c",str[index]);
	}
	return 666;
}

方式2：允许使用字符串常量对字符数组进行初始化。（这个比较方便，也比较常见）

#include "stdio.h"

int main() {
	char str[]={"CHINA"}; # 整体是个字符串常量。

	for(int index=0;index<5;index++){
	printf("%c",str[index]);
}
	return 666;
} 
# 这两种效果初始化是一样的

字符数组在定义时，如果没有初始化，那么元素的初值是不确定的。

二维字符数组

#include "stdio.h"

int main() {
    char str[][10]={{"zhangsan"},{"lisi"},{"wangwu"},{"hello"},{"world"}};
    for(int index1=0;index1<5;index1++){
        for(int index2=0;index2<10;index2++)
            printf("%c",str[index1][index2]);
       printf("\n");
   }
    return 666;
}

字符串

内存中存储字符串时，除了存储有效字符以外，还需要在后面有一个’\0’。作为字符串结束的标志。

• 通常是利用字符数组来存放字符串。（字符串是通过字符数组来存储和处理的）

  char str[6]={"hello"}; # （这种次常见）
  # 用字符数组存放 的 字符串
  # 等价于
  char str[6]="hello"; # （这种最为常见）
  # 用字符数组存放 的 字符串
  # 等价于
  char str[6]={'c','h','i','n','a','\0'}; # 用字符数组存放的字符串
  # 用字符数组存放的字符串
  # ===============上面3种初始化的方式，都是等价的========================
  # 这三种方式，无论如何都要记住
  # 这三种方式，无论如何都要记住
  # 这三种方式，无论如何都要记住
  # 但是，和下面这个不等价，因为没有结束标志，所以，只是一个字符数组，而不是一个字符串。
  # 但是，和下面这个不等价，因为没有结束标志，所以，只是一个字符数组，而不是一个字符串。
  # 但是，和下面这个不等价，因为没有结束标志，所以，只是一个字符数组，而不是一个字符串。
  char str[]={'c','h','i','n','a'}; 
  # 只是一个字符数组

一定要注意：

• 字符串是用字符数组存储的（在内存中）
• 但是字符数组不一定就是字符串。但是字符串是通过字符数组存放的。
• 因为字符串一定要有一个结束标志。
• 所以，存储字符串的数组长度，至少是字符串的有效长度+1。
• 不要忘了前面讲过的，单引号和双引号的使用，在什么情况下使用
  • 单引号和双引号是重要的区分。
  • 想不起来字符串和字符数组的时候，就想想单引号和双引号。

#include "stdio.h"

int main() {
	int x ;
	x = sizeof("helloworld");
	printf("%d",x);
	return 666;
 }

字符串的整体输入/输出

方式1：整体

#include "stdio.h"

int main() {
 
 char str[10];
 
 printf("输入一些内容：");
 scanf("%s",str); # 注意这个地方的细节

 
 printf("输入的结果是：");
 for(int index=0;index<10;index++){
 printf("%c",str[index]);
 }
 
 return 666;
}

//==============================================

//scanf("%s",str)   #str就是数组的首地址，有了首地址，就相当于找到线索了，就找到
整个字符串了

方式2：gets输入

只能输入一个字符串，遇到回车结束。

#include "stdio.h"

int main() {
    char str[30];
    printf("输入一些内容：");
    
    gets(str);
    printf("刚刚输入的内容是：%s",str);
}

方式3：puts输出

只能输出一个字符串，输出后自动换行。

#include "stdio.h"

int main() {
    char str[30];
    printf("输入一些内容：");
    gets(str);
    
    puts("刚刚输入的内容是：");
    puts(str);
}

缓冲区溢出（堆栈）

先在这个地方做个标记（gets是一个危险函数可能会缓冲区溢出）

#include "stdio.h"

int main() {
    char b = 'a';
    char a[6]={0};
    gets(a);
    
    printf( "%c\n",b);
    printf( "%s\n",a);
}

第一行是输入，溢出了，覆盖了变量b

字符串处理函数

要用到的标准库

#include <string.h>

strcpy()

# strcpy(des,src)

# strcpy(字符串1,字符串2)

• 功能：将字符串2复制到字符串1（相当于替换的效果）
• 字符串2可以是字符数组名，也可以是字符串常量
• 字符串1必须有足够的空间
• 复制时遇到字符串2的结束符为止
• 覆盖的效果

#include "stdio.h"
#include <string.h>

int main() {
    char str1[30]="12345678";
    char str2[30]="qwer";
    strcpy(str1,str2);
    puts(str1);
}

strncpy()

• 将字符串2的前n个字符复制到字符串1中。
• 其实就是部分替换的效

# strncpy(字符串1,字符串2,n)
#include "stdio.h"
#include <string.h>

int main() {
    char str1[30]="123456";
    char str2[30]="qwertyuiop";
    strncpy(str1,str2,3);
    puts(str1);
}

strcat()

• 拼接两个字符串
• 连接时，字符串2的首字符，会覆盖字符串1的结束符’\0’

//strcat(字符串1,字符串2)
#include "stdio.h"
#include <string.h>

int main() {
 	char str1[30]="123456";
 	char str2[30]="qwertyuiop";
 	strcat(str1,str2);
 	puts(str1);
}

strcmp()

• 字符串比较函数

  // strcmp(字符串1,字符串2)
  #include "stdio.h"
  #include <string.h>
  
  int main() {
      char str1[30]="qwer5";
      char str2[30]="qwert";
      int result;
      result = strcmp(str1,str2);
      printf("%d",result);
      return 666;
  }

返回值为一个整数

• 字符串1<字符串2，返回值<0，一般是，-1
• 字符串1=字符串2，返回值=0。
• 字符串1>字符串2，返回值>0，一般是，1。

比较规则

• 从字符串的首字符开始，依次比较对应字符串的ASCII码，直到出现不同的字符或者结束符为止。
• 以第一个不相同字符串的比较结果为准，返回两个字符的差。

strlen()

• 计算字符串的长度，但不包括结束标志 \0。

  // strlen(字符串)
  #include "stdio.h"
  #include "string.h"
  
  int main() {
  	char str1[30]="qwert";
  	int x = strlen(str1);
  	printf("%d", x);
  	return 666;
   }

strlwr()

• 大写转小写。

  // strlwr(字符串)
  #include "stdio.h"
  #include <string.h>
  
  int main() {
      char str1[30]="QWERT";
      puts(strlwr(str1));
      return 666;
  }

strupr()

• 小写转大写

# strupr(字符串)
#include "stdio.h"
#include <string.h>

int main() {
    char str1[30]="QWERT";
    puts(strupr(str1));
    return 666;
}

习惯

• 如果是字符数组，一般命名里面包含char。
• 如果是字符串，一般命名里面包含str。
• 这样命名的好处是，方便自己分辨清楚。

函数

分类

• 标准函数：(本地库函数)C语言已经提供了大量已经设计好的函数，可以直接调用
• 自定义函数：用户根据自己的需求，定义的函数
• 第三方函数：除了上述两种函数之外的函数，都叫第三方函数

自定义函数的格式

无参数无返回值

格式
void 函数名(){
	函数体
}

demo

#include<stdio.h>

void dayin(){
	printf("JinJian!");
}

int main(){
	dayin();
	
	return 0;
}

无参数有返回值

demo

#include<stdio.h>

void dayin(int a){
	return a;
}

int main(){
	int c = 1;
	int d = dayin(c);
	printf("%d",d);
	return 0;
}

有参数无返回值

类型名 函数名(类型1 形参1,类型2 形参2,类型3 形参3,...类型n 形参n){
	函数体
}

demo

#include "stdio.h"

void sum(int a,int b){
 
	int value;
	value = a+b;
	printf("%d",value); 
}
int main() {
	sum(100,200);
 	return 666;
}

有参数有返回值

demo

#include "stdio.h"

int sum(int a,int b){
	int value;
	value = a+b;
	return value;	
 }	
	int main() {
	int result = sum(100,200);
	printf("%d",result);
	return 666;
}

三种函数的调用方式

• 调用一个没有返回值的函数：只是要求函数完成一定的操作
• 以函数返回值参与表达式的运算。a=abs(x)
• 函数的嵌套调用。putchar(getchar())

指针

指针也就是内存地址，指针变量是用来存放内存地址的变量。就像其他变量或常量一样，在使用指针存储其他变量地址之前，对其进行声明。

指针的访问方式

直接访问

demo

#include"stdio.h"

int main(){
	int num;
	num =32;
	printf("num变量的值是：%d\n",num);
	printf("%d",&num);
	return 666;
}

• 这种利用变量名，访问分配给变量的内存空间的方式，称为直接访问。

间接访问

#include"stdio.h"

int main(){
    int num=100;
    int *pnum;
    pnum=#
    printf("num变量的值是%d\n",num);
    printf("num变量的地址是%x\n",&num);
    printf("指针变量pnum的值是%x\n",pnum);
    printf("指针变量pnum的地址是%x\n",&pnum);
    printf("取出指针变量pnum所指向的变量的值%d\n",*pnum);
    return 666;    
}

• 第一步：从变量p中取出变量num的首地址
• 第二步：根据取到的变量a的首地址，再访问变量num。

指针变量的初始化

• 指向变量的指针的初始化

  1.定义后初始化
  #include"stdio.h"
  
  int main(){
   int a = 67;
   int *pa;
   
   pa = &a;
   return 666;
  }
  
  2.定义的同时初始化
  #include"stdio.h"
  
  int main(){
   int a = 67 , *pa = &a; # 定义一个指针变量pa，该指针变量pa指向变量a
  
   return 666;
  }

• 指向数组指针的初始化

  1.定义后初始化
  #include"stdio.h"
  int main(){
   int a[5]={12,23,34,45,56};
   int *p;
   p = a;
   return 666;
  }
  
  
  2.定义的用时初始化
  #include"stdio.h"
  
  int main(){
   int a[5]={12,23,34,45,56}, *p = a;
   return 666;
  }

• 指向同类型的指针变量

  1.定义后初始化
  #include"stdio.h"
  
  int main(){
   int a=300; 
   int *pa,*pb; 
   pa = &a; 
   pb = pa; 
   return 666;
  }
  
  2.定义时初始化
  #include"stdio.h"
  
  int main(){
   int a=300, *pa = &a;
   int *pb=pa;
   return 666;
  }

指针和一维数组

int a[5]={1,2,3,4,5};
int *p;
p=a;
# 等价于（因为数组的名字是数组首元素的地址）
p=&a[0];

#include"stdio.h"

int main(){
    int a[5]={1,2,3,4,5};
    int *p;
    p=a;
    printf("a的值是%x\n",a);
    printf("p的值是%x\n",p);
    printf("====================\n");
    for (int i = 0; i < 5; ++i) {
        printf("元素a[%d]的地址是%x\n",i,&a[i]);
   }
    printf("指向了下一个元素：%d",p+1);
    return 666;
}

进一步验证了，数组名，是数组首元素的地址。既然a的值和p的值一样，那用a和p都行。所以，指针 就是变量。

指针变量就是地址。

所以，访问一维数组元素有下面几种方式

• 利用数组下标访问数组元素（例如 a[3]）
• 数组名作为指针访问数组元素（例如 *(a+3)）
• 指针变量下标法访问数组元素（例如 p[3]）
• 利用指针变量访问数组元素（例如 *(p+3)）

结构体

结构体是一种自定义的数据类型，可以将不同类型的数据组合成一个整体。结构体可以包含多个成员变量，每个成员变量可以是不同的数据类型。

结构体的定义方式

方式一

struct books{
	int bno;
	char bname[20];
	char author[20];
	float price;
};

struct books book1,book2;

方式二

struct books{
	int bno;
	char bname[20];
	char author[20];
	float price;
}book1,book2;

方式三

struct{
 	nt bno;
	char bname[20];
	char author[20];
	float price;
}book1,book2;

结构体的初始化

大多数情况下，都是选择，，定义的同时初始化

struct books book1={1001,"computer","张三",34.5}

demo

#include "stdio.h"
int main() {
 
 	struct books{
	int bno;
	char bname[20];
	char author[20];
	float price;
};
 
	struct books book1={1001,"C语言程序设计","张三",34.5};
 
	printf("书本的编号是：%d\n",book1.bno);
	printf("书本的名字是：%s\n",book1.bname);
	printf("书本的作者是：%s\n",book1.author);
	printf("书本的价钱是：%f\n",book1.price);
 
	return 666;
}

结构体作为函数参数

常规方法

• 方法1：用结构体变量名作参数。
• 方法2：用指向结构体变量的指针作实参，将结构体变量的地址传给形参。（结构指针作为函数参 数）

结构体和指针

指向结构体变量的指针，叫做结构指针。

格式
struct 结构名 *指针变量名

struct books{
 int bno;
 char name[20];
};

struct books book1={1001,"C语言程序设计"};

struct books *p;

p=&books1;

通过结构指针访问取值

#include"stdio.h"

struct books{
    int bno;
    char name[20];
};

int main(){
    struct books book1={1001,"C语言程序设计"};
    struct books *p; // 结构指针的定义

    p=&book1; // 

    printf("book1的编号：%d\n",(*p).bno);

    printf("book1的编号：%d\n",p->bno); 

    printf("book1的编号：%d\n",book1.bno); 

    printf("book1的编号：%s\n",book1.name); 

    return 666;
}

(*p).n // 得到p指向的结构变量str的成员n的值

p->n // 得到p指向的结构变量str的成员n的值

    

p->n++ // 得到p指向的结构变量str的成员n的值，然后n的值+1，等价于 (p->n)++

++p->n // 等价于 ++(p->n) ，使p指向的结构变量str的成员n的值+1

    
(++p)->n // p先自加1，然后得到，它指向的结构变量str的成员n的值

(p++)->n // 先得到p->n的值，然后p的值+1

结构指针作为函数参数

#include"stdio.h"

struct books{
 int bno;
 char name[20];
};

// 函数定义，作用是打印

void dayin(struct books *ps){
 
 printf("编号是：%d\n",ps->bno);
 printf("书名是：%s\n",ps->name);
 
}

int main( ){
 struct books book1={1001,"biancheng"};
 struct books *p;
 p=&book1;
 
 dayin(p);
 return 666;
}

共用体(联合体)

在计算机的内存中分配一个特殊的存储空间，由若干个连续的内存单元构成，不同类型的数据都可以放 在该空间。

demo

union chengji{
 float yuwen;
 int shuxue;
 int yingyu;
    char xingming;
};

union chengji zhangsan,lisi;

union chengji{
 float yuwen;
 int shuxue;
 int yingyu;
    char xingming;
}zhangsan,lisi;

• 定义了联合体之后，系统为分配内存。
• 联合体变量占用的存储空间是占有存储空间最大的联合体成员所占的空间。
• 某一个时刻，只有一个成员有效。

链表

• 链表，是动态内存分配的一种结构。按需分配内存。使用动态分配的内存单元存放数据。
• 链表是由若干相同结构类型的元素依次串联而成，使用指针表示两个元素之间的前后关系。
• 链表中的每一个元素都是结点，节点是结构类型。数据域，指针域。

文件操作

C语言中，按照数据存储的编码方式，数据文件分为：

• ASCII文件：以ASCII码进行存储和编码的文件。文件的内容就是字符。可以用记事本打开。（也叫 文本文件）
• 二进制文件：存储二进制数据的文件，是计算机可以识别的机器代码。用记事本打开是乱码。

相关函数

fopen

fopen("文件名","文件打开方式")

#include <stdio.h>

int main () {
   	FILE * fp;
    fp = fopen ("hello.txt", "w+");
    if(fp == 0){
    	    printf("打开失败");
   	} else{
    	    printf("打开成功");
   	}
    return 666;
}

• 如果打开成功，则返回指向新打开的文件的指针
• 如果打开失败，返回空指针，NULL，在stdio.h中被定义为 0 。

fclose

demo

#include <stdio.h>

int main () {
    FILE * fp;
    int res;
    fp = fopen ("hello.txt", "w+");
    if(fp == 0){
        printf("打开失败\n");
   } else{
        printf("打开成功\n");
        res=fclose(fp);
        if(res==0){
            printf("关闭成功\n");
       } else{
            printf("关闭失败\n");
       }
   }
    return 666;
}

fputc

使用该函数向文件中写入一个字符。

#include <stdio.h>

int main () {
    FILE * fp;
    int res;
    int res2;
    char zifu='Q';
    fp = fopen ("hello.txt", "w+");
    if(fp == 0){
        printf("打开失败\n");
   } else{
        printf("打开成功\n");
        res2=fputc(zifu,fp);
        if(res2 == 0 ){
            printf("写入失败\n");
       } else{
            printf("写入成功\n");
            printf("调用完fputc的返回值是：%d\n",res2);
       }
        res=fclose(fp);
        if(res==0){
            printf("关闭成功\n");
       } else{
            printf("关闭失败\n");
       }
        printf("调用完fclose的返回值是：%d\n",res);
   }
    return 666;
}

fgetc

ch=fgetc(fp)

#include <stdio.h>

int main () {
    FILE * fp;
    int res;
    int res2;
    fp = fopen ("hello.txt", "r");
    if(fp == 0){
        printf("打开失败\n");
   } else{
        printf("打开成功\n");
        res2=fgetc(fp);
        if(res2 == 0 ){
            printf("读取失败\n");
       } else{
            printf("读取成功\n");
            printf("调用完fgetc的返回值是：%d\n",res2);
            printf("读取的结果是：%c\n",res2);
			}
        res=fclose(fp);
        if(res==0){
            printf("关闭成功\n");
       } else{
            printf("关闭失败\n");
       }
        printf("调用完fclose的返回值是：%d\n",res);
   }
    return 666;
}

fputs

使用该函数向文件中写入一个字符串。

fputs(str,fp)

#include <stdio.h>

int main (){
    FILE *fp;
    fp = fopen("hello.txt", "w+");
    fputs("这是 C 语言\n", fp);
    fputs("这是一门程序设计语言。", fp);
    fclose(fp);
    return(0);
}

fgets

读取字符串

fgets(str,n,fp)

#include <stdio.h>

int main(){
    FILE *fp;
    char str[60];
    fp = fopen("hello.txt" , "r");
    if( fgets (str, 60, fp)!=NULL ) {
        puts(str);
   }
    fclose(fp);
    return 666;
}