C语言程序设计

笔记 / 2020-10-15

C程序设计

image-20201015183307086

image-20201015183335892

试题难度：1:3:6

第一章 程序设计和C语言

1. 程序

就是一组 计算机能识别和执行的***指令***。

2. 计算机语言

机器语言 就是由0和1组成的计算机可以识别的指令。

符号语言***（汇编语言）：通过符号表示二进制数。***

img

缺点:不通用

高级语言：使用很接近于人类的语言完成计算机程序的设计。

特点：接近人类，不依赖机器。

高级语言->编译程序->机器语言

第一高级语言：FORTRAN

高级语言的发展：非结构化(BASIC)->结构化-(C语言)->面向对象(Java,C#,C++,Python,PHP)

C语言的标准：C89和C99

C语言的注释：//行注释 /* /段注释（C99）C89---》/ */段注释

C语言特点：面向过程，可以应用系统程序和应用程序的开发。

/*
	这是第一个C语言程序 
*/ 
#include<stdio.h>//头文件 std标准 io输入输出 
int main(){//主函数--程序的入口main 
 //int--->返回值 
	printf("Hello!");//输出语句，表示打印Hello 
	return 0;//返回一个0,表示正常结束；异常结束返回一个
	//非0值 
}

注意：每一个C语言程序***必须***有一个main()函数。

#include<stdio.h>
int main(){
	//程序-->内存 --->执行 
	int a,b,sum;//定义变量,在内存中分配空间 
	a = 100;
	b = 30;//给变量赋值 
	sum = a+b;
	printf("你好sum=%d\n",sum);	
	//"sum=%d\n"输出格式 
	//sum输出的变量 %d表示输出一个整数 
	//\n回车换行
	printf("hello"); 
	return 0;
}

3. C语言的程序结构

  1. 一个C语言程序是由一个或者多个***源程序***组成的。
  2. 一个C语言程序是由一个或者多个函数构成的，但必须包含main()函数，并且只能有一个
  3. C语言程序总是从main()函数开始执行的。
  4. 每个***C语言语句***后必须有一个 分号。
    • a = 100;-->c语言 语句
    • a = 100-->c语言 表达式
  5. C语言本身不包含输入(scanf)和输出(printf)语句,是通过stdio.h头文件引入的。

4. 写C语言程序的步骤和方法

源程序--> .c文件 .cpp文件

  1. 编写c语言的源程序（.c或.cpp），数据文件
  2. 对源程序进行编译（目的：检查程序是否有错误，将源程序转化为二进制文件）-->目标程序
  3. 对编译后的文件进行连接处理。（将多个编译后的C语言文件进行组合）
  4. 可以得到可执行文件（.exe）

第二章 算法

程序=算法+数据结构

  1. 对数据的描述为数据类型和数据的组成形式，称为数据结构。int a;自定义的数据类型 class Student{。。。。}

  2. 算法：解决问题的步骤和方法。

    做菜（1）准备材料（数据）（2）制作步骤（算法）

  3. 计算机的算法：数值运算算法（10%）和非数值运算算法（90%）。

1. 算法的特性：

  1. 有穷性：算法的步骤是有穷的。
  2. 确定性：算法的步骤是确定的。
  3. 有零或者多个输入：输入必要的数据。
  4. 有一个或者多个输出：算法的“解”。
  5. 有效性：算法的每一个步骤都是可以有效执行的。

2. 如何描述一个算法

  1. 用自然语言表示算法
  2. 用程序流程图
  3. N-S流程图表示算法
  4. 用伪代码表示算法
  5. 用计算机语言表示算法

第三章 顺序程序设计

1.三种基本结构

  1. 顺序结构
  2. 选择结构（if和switch）
  3. 循环结构（while和for）

1.数据的两个形式：常量和变量。

  1. 常量：在程序运行时，值不能变化的量

    整型常量：100，-2,200；

    实型常量：（1）十进制表示：1.2 23.5

    指数表示：12.2e-2

  2. 字符常量：（1）普通字符：’a’ ‘?’

  3. 转义字符

    \n 表示回车换行

    \t 表示光标移动到下一个tab的位置。

    \\表示字符\

    ‘\101’ ‘\x41’

  4. 字符串常量：”avc” “a”

注意：”a”和’a’的区别？

2. 符号常量

#include<stdio.h>
#define PI 3.1415 //符号常量 
int main(){
	int r=3; 
	r = 10; 
	printf("圆的面积：%f\n",PI*r*r);
	printf("PI=%f\n",PI);
	
	const int a = 10; //常变量
	printf("a=%d\n",a);
	return 0;
}

***常变量***和***符号常量***有什么区别？

常变量在程序编译时，需要占用内存，符号常量在编译时，不需要占用内存。

3. 变量

使用方法：先定义，后使用。

int:整型 int a;在内存中开辟空间。

Dev-c++：4Byte；TurboC：2Byte；

64位机器：8Byte。

1. 整型

#include<stdio.h>
int main(){
	int a;//定义变量，在内存中开辟4Byte大小
	a = 10;//给变量赋值 
	//1Byte = 8bit 
	//4Byte = 32bit
	//00000000 00000000 00000000 00000000
	//11111111 11111111 11111111 11111111
	//01111111 11111111 11111111 11111111
	//1111=+7
	//0111=-7
	printf("a=%d\n",a);
	short b = 12;//短整型，在内存中开辟2Byte 
	printf("b=%d\n",b);
	long c = 13;//长整型，内存中开辟4Byte 
	printf("c=%d\n",c); 
	long long d = 13;//双长型， 内存中开辟8Byte
	printf("d=%d\n",d); 
	return 0;
}

short<=int<=long<=long long

2. 无符号数

#include<stdio.h>
int main(){
	//补码 
	unsigned int a = 100;
	//11111111 11111111 11111111 11111111
	//00000000 00000000 00000000 00000000
	//1111=15
	//0000=0
	printf("a = %d\n",a);
	unsigned int b = -100;
	printf("b = %d\n",b);
	printf("b = %u\n",b);//%u无符号数的输出格式 
	//0110 
	return 0;
}

3. 字符型

#include<stdio.h>
int main(){
	char ch = 'a';//会在内存中开辟1Byte。 
	//字符在计算机存储的时候，存储的都是字符的ASCII码
	printf("ch = %c\n",ch); 
	printf("ch ascii = %d\n",ch);
	//计算'1'-1的结果？ 48
	char ch2 = '1';
	int a = 1;
	printf("%d\n",(ch2-a));
	return 0;
}

程序：将小写字符a转化为大写。

#include<stdio.h>
int main(){
	char ch = 'a';//97   A:65   =32
	//小写字符的ascii码和大写字符的ascii码相差32
	char ch2 = ch - 32;
	printf("ch2 = %c",ch2); 
	return 0;
}

4. 浮点数

单精度浮点型：float，4Byte，小数有效位数是6位。

双精度浮点型：double，8Byte，小数有效位数是15位。

#include<stdio.h>
int main(){
	float a = 12.34519872123F;
	printf("a = %.8f\n",a); 
	double b = 12.34519872123;
	printf("b = %.11f\n",b);
	//12.4--double 12.4f--float
	float c = 12.3456;
	//将double的数赋值给float类型，有可能发生数据溢出 
	return 0;
}

4. 标识符(变量名称)

规则：只能由字母，数字，下划线

_构成，第一个字符必须是字母或下划线。例如:int 2ac; int _2abc;

算术运算：+(加法,正号) -(减法,负号) * / % 10%3=1 2%5=2

#include<stdio.h>
int main(){
	int a = 17;
	int b = 5;
	int c; 
	c = a+b; //=赋值运算符   +算术运算符  
	//算术运算符的优先级高于赋值运算符 
	printf("c= %d\n",c);
	c = a-b;
	printf("c= %d\n",c);
	c = a*b;
	printf("c= %d\n",c);
	c = a/b;//17/5 = 3  int/int=int 
	printf("c= %d\n",c);
	c = a%b;//2.3%2
	printf("c= %d\n",c);
	//%两边的值，必须是整型 
	//printf("c= %d\n",2.3%2.3);错误 
	return 0;
}

5. ++和--

a++：a = a +1;先使用a的值，然后a再加1.

++a：a = a + 1;先将a的值+1,然后再使用a的值.

#include<stdio.h>
int main(){
	int  a  = 18 ;
	int b;
	//b = a++;
	//1.先将a的值赋值给b=18
	//2.a = 19 
	b = ++a;
	//1.a=19
	//2.b=19
	printf("a = %d,b=%d",a,b);
	return 0;
}

6. 算术运算符的优先级

先乘除，后加减，结合顺序：从左到右。

a=b=c=d=100;

不同类型数据间的混合运算。

  1. 在+-*/运算的两个数，其中有一个数为float或double类型时，运算结果为double类型，因为系统会将所有的float类型先转化为double类型，再进行运算。

  2. 如果int类型与float或double类型进行运算，先把int类型和float类型转化为double类型，然后进行运算，结果为double类型。

  3. 字符类型char与整型进行运算结果为整型。char与实数类型进行运算，结果为实数类型。

#include<stdio.h>
int main(){
	int i = 3;
	float f = 3.5f;
	double d = 7.5;
	double dd;//从左到右 
	//1.计算10+'a'=107;107+i*f-d/3
	//2. i*f=10.5;107+10.5-d/3
	//3.107+10.5=117.5;117.5-d/3
	//4.d/3=7.5/3=2.5;117.5-2.5
	//5.115.000000
	printf("dd=%f",dd);
	return 0;
}

7. 强制类型转化

缺点：有可能引起精度的丢失。

#include<stdio.h>
int main(){
	float a = 12.8456f;
	int b;
	b = (int)a; 
	printf("b = %d",b);
	return 0;
	//(int)((double)(7/2)+3.5)
	//1.(int)((double)3+3.5)
	//2.(int)(3.0+3.5)
	//3.(int)6.5
	//4.6
	//(int)((double)7/2+3.5)
}

8. 赋值语句=

结合顺序：从右向左。

#include<stdio.h>
int main(){
	//int a,b,c=10;
	//int a=b=c=10;错误
	int a=10,b=10,c=10;	
	printf("a=%d,b=%d,c=%d",a,b,c); 
	return 0;
}

复合赋值运算：+=,-=,*=,/=,%=

a+=3;//a=a+3;

#include<stdio.h>
int main(){
	int a = 6,b=3;
	//a+=3;  a = a+3;
	a*=b+3;//a = a * (b +3)
	printf("a=%d",a); 
	return 0;
	//X-=X*X
	//X=X-(X*X)=5-5*5=-20
}

赋值过程中的类型转化

  1. 将浮点型数转化为整型，直接舍弃小数部分。
  2. 将整型转化为浮点型，数值不变，以小数的形式保存。
  3. 将一个double类型数据转化为float类型数据时，注意数值范围能溢出。
  4. 字符型数据赋值给整型变量，将字符的ASCII码直接赋值。
  5. 整型数据赋值给字符型数据，可以发生数据错误。
#include<stdio.h>
int main(){
	//1.浮点型-->整型
	float a = 12.5f;
	int b;
	b = a;//高精度--->低精度 
	printf("b=%d\n",b);
	//2.整型--->浮点型
	int c =32;
	double d;
	d = c;
	printf("d=%f\n",d);
	//3.double--->float 有可能发生精度的丢失
	double e = 12.34567893;
	float f;
	f = e;
	printf("f=%f\n",f);
	//4.char 1Byte->int 4Byte
	char c1 = 'd';
	int num1;
	num1 = c1;
	printf("num1=%d\n",num1);
	//5.int->char 有可能会发生数据错误
	//512 256 128 64 32 16 8 4 2 1
	//     1   0   0  1  0 0 0 0 1
	//
	int i = 289;
	char c2;
	c2 = i;
	printf("c2=%d\n",c2); 
	return 0;
}

9. 标准化指数

100.3456=1.003456e2

0.00345=3.45e-3

printf()

#include<stdio.h>
int main(){
	//1.d格式--->输出整型数据 
	printf("No.1:%d\n",122);
	printf("No.2:%5d\n",122);//输出数据占5列（向右对齐）
	printf("No.3:%-5d\n",122);//输出数据占5列（向左对齐）
	//2.c格式--->单个字符 
	printf("No.4:%c\n",'\101');
	//3.f格式--->浮点型数据（float,double）
	printf("No.5:%f\n",3.14);//3.140000
	float a = 10.0f;
	printf("No.6:%20.15f\n",a/3);//占20列，15位小数 
	printf("No.7:%-20.15f\n",a/3);
	//4.e格式--->结果为指数形式
	printf("No.8:%25.15e\n",a/3);
	printf("No.9:%e\n",190.34);
	printf("No.10:%e\n",0.002345);
	//5.o格式-- >将一个数按照8进制输出 
	printf("No.11:%o\n",1001);
	//6.x格式-- >将一个数按照16进制输出 
	printf("No.12:%x\n",1001);
	//7.u格式-->输出一个无符号的数
	printf("No.13:%u\n",1001);
	return 0;
}

10 .输入输出

输入

输入：scanf()

#include<stdio.h>
int main(){
	int a;
	scanf("a=%d",&a); //输入格式,往什么地方输入
	//&-->取地址符
	printf("a = %d\n",a); 
	printf("a(addr)=%p\n",&a);
	printf("a(addr)=%d\n",&a);
	return 0;
}

#include<stdio.h>
int main(){
	float a,b,c;
	scanf("a=%f,b=%f,c=%f",&a,&b,&c);
	printf("a=%f,b=%f,c=%f",a,b,c);
	return 0;
}

特例1：输入数字时：

#include<stdio.h>
int main(){
	int a,b,c;
	scanf("%d%d,%d",&a,&b,&c);
	printf("a=%d,b=%d,c=%d",a,b,c);
	//1.每输入一个数据后，加空格
	//2.每输入一个数据后，加回车
	//3. 每输入一个数据后，加tab
	return 0;
}

特例2：输入字符时

#include<stdio.h>
int main(){
	char a,b,c;
	scanf("%c%c%c",&a,&b,&c);
	printf("a=%c,b=%c,c=%c",a,b,c);
	//对于字符输入时，每一个字符要紧紧的挨在一起。 
	return 0;
}

字符输入输出

1.输出：putchar();
#include<stdio.h>
int main(){
	char a = 'a';
	char b = 'r';
	char c = 'w';
	int d = 65;
	putchar(a); //将变量a的值输出 
	putchar('\n');
	putchar(b);
	putchar(c);
	putchar('\101');
	putchar(d);
	return 0;
}
2.字符的输入：getchar()

调用一次getchar()函数，从键盘中得到一个字符。

#include<stdio.h>
int main(){
	char a,b,c;
	a = getchar();//获得到键盘输入的单个字符 
	b = getchar();
	c = getchar();
	putchar(a); 
	putchar(b); 
	putchar(c); 
	return 0;
}

#include<stdio.h>
int main(){
	int x,y;
	scanf("%d%3d",&x,&y);
	printf("%d %d",x,y); 
	return 0;
}

#include<stdio.h>
#include<math.h>
int main(){
	//求三角形面积
	//海伦公式
	double a,b,c;//三个边长
	printf("请输出三个边的边长：\n");
	scanf("a=%lf,b=%lf,c=%lf",&a,&b,&c);
	double s,area;
	s = (a+b+c)/2;
	area = sqrt(s*(s-a)*(s-b)*(s-c));//sqrt(3)
	printf("三角形的面积是：%f",area);
	return 0;
}

求一元二次方程的根。

#include<stdio.h>
#include<math.h>
int main(){
	float a,b,c;
	printf("请输入a,b,c的值：\n");
	scanf("%f,%f,%f",&a,&b,&c);
	float p,q;
	p = -b/(2.0*a); 
	q = sqrt(b*b-4*a*c)/2.0*a;
	float x1,x2;
	x1 = p+q;
	x2 = p-q;
	printf("x1=%f,x2=%f",x1,x2);
	return 0;
}

第四章 选择结构

1. 关系运算

  • >
  • <
  • ==
  • >=
  • <=
  • !=

作用：判断左右两边的值***是否***满足。

3>2:判断3是否大于2，如果条件满足，返回值1。如果不满足，返回值0。

3>=3:返回值1。

优先级

算术运算符 > 关系运算符 > 赋值运算符

image-20201021215816737

#include<stdio.h>

int main(){
	int a =1,b=3,c=2;
	printf("%d\n",(a==b>c)); 
	//1.b>c  3>2=1
	//2.a==1
	printf("%d\n",(a<=b==c));
	printf("%d\n",(a+1>b==c));
	//1.a+1
	//2.2>b-->0
	//3.0==c
	return 0;
}

2. 逻辑运算

  • and&&
  • or||
  • not!

作用：判断逻辑运算符左右的表达式是否满足条件。满足：1.不满足：0

#include<stdio.h>

int main(){
	printf("%d\n",(1&&1));
	printf("%d\n",(1&&0));
	printf("%d\n",(0&&1));
	printf("%d\n",(0&&0));
	
	printf("%d\n",(1||1));
	printf("%d\n",(1||0));
	printf("%d\n",(0||1));
	printf("%d\n",(0||0));
	
	printf("%d\n",(!0));
	printf("%d\n",(!1));
	return 0;
}

image-20201021220226628

#include<stdio.h>
int main(){
	int a = 10;
	int b = -2;
	printf("%d",(a&&b));
	//非0的数表示真,0表示假 
	return 0;
}

#include<stdio.h>
int main(){
	int a = 2,b=4,c=3,d=7;
	printf("%d\n",a<b||c<d);//1||1--->1
	printf("%d\n",a<b&&c<d);//1
	printf("%d\n",a>b||c<d);//0||1--->1
	printf("%d\n",a<b&&c>d);//1&&0--->0
	printf("%d\n",!a<b&&c>d);//0<4&&c>d-->0
	return 0;
}

例题：

#include<stdio.h>
int main(){
	int a = 1,b=9;
	++a||b++;//2||?=1
	printf("b=%d",b);
	return 0;
}

a&&b，对于这个表达式，a如果确定为假，整个表达式为假，b这个表达式不执行。

a||b, 对于这个表达式，a如果确定为真，整个表达式为真，b这个表达式不执行。

  • Y = 5>3&&8<4-!0
  • = 5>3&&8<4-1
  • = 5>3&&8<3
  • = 1&&0=0

3. 选择结构

if…else…

if(条件：条件表达式、逻辑表达式,){条件满足}else{条件不满足}

#include<stdio.h>
int main(){
	//例如：输入两个整数，由大到小输出。
	int a,b,t;
	scanf("%d%d",&a,&b);//12 6   6 12
	if(a<b){
		t = a;
		a = b;
		b = t;
	} 
	printf("%d,%d",a,b); 
	return 0;
}

输入一个年份，判断此年份是否为闰年？year

判断条件：1.能被4整除，但不能被100整除；2.能被400整除。

(year%4==0&&year%100!=0)||(year%400==0)

#include<stdio.h>
int main(){
	int year;
	printf("请输入年份：\n");
	scanf("%d",&year);
	if((year%4==0&&year%100!=0)||(year%400==0)){
		printf("是闰年！"); 
	}else{
		printf("不是闰年！"); 
	}
	return 0;
}

如果,在if..else语句中，不论是if中还是else中，只有1条语句，{}是可以省略的。

#include<stdio.h>
int main(){
	int year;
	printf("请输入年份：\n");
	scanf("%d",&year);
	if((year%4==0&&year%100!=0)||(year%400==0))
		printf("是闰年！"); 
	else
		printf("不是闰年！"); 
	return 0;
}

image-20201021220505071

输入x的值，求y。

#include<stdio.h>
int main(){
	int x,y;
	scanf("%d",&x);
	if(x<1){
		y = x;
	}else if(1<=x&&x<10){
		y=2*x-1;
	}else if(x>=10){
		y = 3*x-11;
	}
	printf("y = %d",y);
	return 0;
}

4. 条件表达式

条件表达式（唯一一个三目运算）

例如：给定两个数，输出最大值。

表达式1?表达式2:表达式3;

执行步骤：

首先执行表达式1，如果表达1为真，执行表达式2；如果表达式1为假，执行表达式3。

#include<stdio.h>
//输入一个字符，判断它是否是大写字母，如果是大写字母
//转换为小写字母，如果是小写字母，直接输出。
int main(){
	char ch,c;
	ch=getchar();
	c=(ch>='A'&&ch<='Z')?ch+32:ch;
	putchar(c);
	return 0;
}
c/c++

文章目录

最新评论

最新文章