C语言学习笔记P1|第1-6课

本文最后更新于 2024年12月29日 晚上

点击此处转到最近更新

高级语言学习主线

基本符号
数据
函数
运算符
表达式
语句
格式控制
程序

第一课

1. 简单sin案例

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include<complex.h>
#include"math.h"

int main()
{
	float x, y;
	scanf_s("%f", &x);
	y = sin(x);
	printf("%f", y);
}

第二课

1.

变量声明 → 储存单位→地址关联→变量操作

2. 变量的命名规则

  1. 只能用字母,数字,下划线
  2. 必须用字母下划线开头
  3. 区分大小写字符
  4. 关键字不能用作标志符

此规则适用于所有语言

3.

变量定义：变量值类型 变量名；
地址关联：变量名对应存储单元地址；
变量赋值：变量名=变量值类型；

4. %f 浮点型；%d 整型；[^1]

什么是运算符？

举个简单的例子 4 +5 = 9 。 例子中，4 和 5 被称为操作数，”+“ 称为运算符。

C支持以下类型运算符：

  • 算术运算符

  • 比较（关系）运算符

  • 赋值运算符

  • 逻辑运算符

  • 位操作运算符

  • 条件运算符

  • 逗号运算符

  • 指针运算符

  • 求字节数运算符

  • 特殊运算符

算术运算符 ※

以下假设变量： a=10，b=20：

运算符 描述 实例
+ 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2
% 取模 - 返回除法的余数 b % a 输出结果 0
++ 自增 - 变量 +1的值重新赋值给变量 a++ 输出结果 11
– 自减 - 变量 -1的值重新赋值给变量 a– 输出结果 9

比较（关系）运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。 (a < b) 返回 true。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 true。

赋值运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a

复合位运算赋值(&=,|=,^=,>>=,<<=)

位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：

下表中变量 a 为 60，b 为 13，二进制格式如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011
运算符 描述 实例
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 1101
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。**~x** 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把”>>”左边的运算数的各二进位全部右移若干位，**>>** 右边的数字指定了移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111

逻辑运算符

运算符 说明 结合性 举例
&& 与运算，双目，对应数学中的“且” 左结合 1&&0、(9>3)&&(b>a)
|| 或运算，双目，对应数学中的“或” 左结合 1||0、(9>3)||(b>a)
! 非运算，单目，对应数学中的“非” 右结合 !a、!(2<5)

条件运算符

这是一个三目运算符，用于条件求值(?:)。

逗号运算符

用于把若干表达式组合成一个表达式(，)。

指针运算符

用于取内容(*)和取地址(&)二种运算。

求字节数运算符

用于计算数据类型所占的字节数(sizeof)。

特殊运算符

有括号()，下标[]，成员(→，.)等几种。

5. 初始化、计数器、复合运算符

1
2
3
4
5
6
7
8
9
10
11
 #include "stdio.h"
  main_1()
  {

	int x;//int x = 2021; //定义同时赋值，称为变量的初始化//
	x = 2021;
	x = x + 1;//计数器//
	x += 1;//复合运算//
	x++;//计数器//
	printf("%d\n", x);
}

6. 累加器，累乘器

1
2
3
4
5
6
7
8
9
10
#include "stdio.h"
   main_2()
   {
   	float x, y = 70, sum = 0;
   	x = 3.14;
   	sum = sum + x;
   	sum += x;
   	sum += y;/*累加器，累乘器*/
   	printf("%f\n", sum);
   }

第三课

0. 运算符

算术运算符 ※

以下假设变量： a=10，b=20：

运算符 描述 实例
+ 加 - 两个对象相加 a + b 输出结果 30
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -10
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 200
/ 除 - x除以y b / a 输出结果 2
% 取模 - 返回除法的余数 b % a 输出结果 0
++ 自增 - 变量 +1的值重新赋值给变量 a++ 输出结果 11
– 自减 - 变量 -1的值重新赋值给变量 a– 输出结果 9

关系运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 true.
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。 (a < b) 返回 true。
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 true。

赋值运算符

以下假设变量a为10，变量b为20：

运算符 描述 实例
= 简单的赋值运算符 c = a + b 将 a + b 的运算结果赋值为 c
+= 加法赋值运算符 c += a 等效于 c = c + a
-= 减法赋值运算符 c -= a 等效于 c = c - a
*= 乘法赋值运算符 c *= a 等效于 c = c * a
/= 除法赋值运算符 c /= a 等效于 c = c / a
%= 取模赋值运算符 c %= a 等效于 c = c % a

复合位运算赋值(&=,|=,^=,>>=,<<=)

1. 分解自然数完整程序，引入循环概念及控制语句

1
2
3
4
5
6
7
8
9
10
11
/*分解自然数完整程序，引入循环概念及控制语句*/
#include <stdio.h>
main() {
	int n, x;
	scanf_s("%d", &n);
	do {
		x = n % 10;/*取个位*/  //取余运算
		printf("%d\n", x);
		n = n / 10; /*去个位*/
	} while (n);//n=0时，表false，n>0时，表true
}

2.循环控制语句

for，while，do…while

同一个问题，往往既可以用 while语句解决，也可以用 do-while或者for语句来解决，但在实际应用中，应根据具体情况来选用不同的循环语句。选用的一般原则是：

(1) 如果循环次数在执行循环体之前就已确定，一般用 for语句。如果循环次数是由循环体的执行情况确定的，一般用 while语句或者do- while语句。

(2) 当循环体至少执行一次时，用 do-while语句，反之，如果循环体可能一次也不执行，则选用while语句。

C++/C循环语句中，for语句使用频率最高，while语句其次，do语句很少用。

三种循环语句for、while、do-while可以互相嵌套自由组合。但要注意的是，各循环必须完整，相互之间绝不允许交叉。

C语言9种控制语句

①if( )~else 条件语句

②for( )~ 循环语句

③while( )~ 循环语句

④do~while( ) 循环语句

⑤continue 结束本次循环语句

⑥break 中止执行switch或循环语句

⑦switch 多分支选择语句

⑧goto 转向语句

⑨return 从函数返回语句

3.闰年的判断(逻辑运算符)

计算闰年方法：公历纪年法中，能被4整除的大多是闰年，能
被100整除而不能被400整除的年份不是闰年。

1
2
3
4
5
6
7
8
#include <stdio.h>
mian() {
	int x;
	scanf_s("%d", &x);
	if ((x % 4 == 0 && x % 100 != 0) || (x % 400 == 0))
		printf("%c", 'Y');
	else printf("%c\n", 'N');
}
运算符 说明 结合性 举例
&& 与运算，双目，对应数学中的“且” 左结合 1&&0、(9>3)&&(b>a)
|| 或运算，双目，对应数学中的“或” 左结合 1||0、(9>3)||(b>a)
! 非运算，单目，对应数学中的“非” 右结合 !a、!(2<5)

4. 求n的阶乘

1
2
3
4
5
6
7
8
9
10
11
12
 #include "stdio.h"

main()
{
	int n, y;
	y = 1;
	scanf_s("%d", &n);
	do { y = y * n;
        n = n - 1; } 
    while (n);//阶乘器//
	printf("%d\n", y);
}

5. 阶乘求和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/*阶乘求和 by 21大数据1班多双升*/
#include <stdio.h>
main()
{
	int x, y, s, t, ss = 0;
	scanf_s("%d", &x);
	t = x;/*t计量循环次数*/
	do {/*阶乘求和*/
		y = x;
		do {/*求取阶乘*/
			y *= (x - 1);
			x -= 1;
			s = y;
		} while (x - 1);/*内循环用x计量循环次数*/
		x = t - 1;/*借助t实现外循环x的递减*/
		t--;/*t计量循环次数*/
		ss += s;
	} while (t - 1);
	printf("%d", ss + 1);/*最后‘1’未进入循环*/
}

第四课

运算符优先级

自上而下，前后分级

运算类型 运算符 说明
算数 *,/,%（取余）
+,-		 1. int、loat运算结果分别为整数、实数。
2. “%”结果的符号与被除数的符号相同。
关系 <,<=,>,>=
==,!=		 1. C语言用0表示“假”，1表示“真”，而1,0都是整型。
2. 在关系运算中，规定关系成立，则其结果为1，反之为0。
逻辑 ! not,否
&& and，与，而且
|| or，或，或者		 1.&& 和||低于关系运算，!高与算术运算（特味）。
2. C编译系线在判斯一逻辑到变量时以非0表示“真”，如a=5,则!a=0。
赋值 =，st= 1. “=”将一个数赋值给另一个变量，如：c=c+1 ，c++。
2.”=”两侧的类型不一致时进行类型转化。
3. “st=”是复合赋价运算符；“st” 可以算术或其它二目运算符，逻辑关系符（除外），注：x st = y相当于对x = x st y。

编写程序（累加）

条件循环

问题： s = 1+2+3+…+100
分析：累加
模型：s=s+t;t=t+1
程序： 

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
int main()
{
	int c = 0, s = 0;
	do {
		c += 1;
		s += c;

	} while (c < 100);
	printf("%d", s);
}

变量 → 先定义后使用
此处计数器 c 定为int
累加器看累积数据类型

此循环，循环次数已知

for循环

数控循环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
int main()
{
	int c,s = 0;
	for (c = 1; c <= 100; c++) 
	//最后一句后勿加分号 错误："c++;"(×)
	{
		s = s + c;
	};
    /*  for循环语句执行顺序
    ①c = 0 循环变量-赋初值 仅执行一次
    ②c < 100做判断
    ③{s= s+c} 然后执行循环体，循环执行
    ④c ++ 计数器
    */
    print("%d",s);
}

重点：for循环语句执行顺序

while循环

1
while(c<100){c++; s+=c;}

期待输出”#”（5*5矩阵）
字符串 %s sting
单字符 %c
实数 %f
整型 %d

putchar(); 只能输出单字符，转义字符

  1. 问题：期待输出”#”（5*5矩阵）
  2. 分析：循环
    过程分析：
  1. putchar(‘#’);
  2. for(n = 1;n <= 5;n ++)putchar(‘#’);//外循环语句为单语句时，不加“{}”
  3. putchar(‘\n’)
  4. {for(n = 1;n <= 5;n ++)putchar(‘#’);
    putchar(‘\n’);}
  5. for (m = 1; m <= 5; m++) {for (n = 1; n <= 5; n++)putchar(‘#’);putchar(‘\n’);};
  1. 程序：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    #include<stdio.h>
    main()
    {
    	int m, n;
    	for (m = 1; m <= 5; m++) {
    		for (n = 1; n <= 5; n++)putchar('#');
    		putchar('\n');
    	};
    }

第五课-巩固循环语句，嵌套

第四课课后作业

最新更新

一个语言对象的出现在语言体系中，都有其因需要而设定产生的过程，最终约定成俗，学习的过程需要知道它的来龙去脉。

for循环(点击回顾)

数控循环(点击回顾)

循环嵌套

问题:”*” 5x5矩阵

  • 模型：
    • putchar(""); //输出单字符
    • for (m = 1; m <= 5; m++){putchar('*')};
      putchar('\n')//内循环
  • 模型
    1
    2
    3
    4
    5
    6
    {
        for (n = 1; n <= 5; n++)  
    { 
        for (m = 1; m <= 5; m++){putchar('*');};   
    putchar('\n');};  
    }  //外循环，控制行数

递增型

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main()
{
	int  m, n;
	for (n = 1; n <= 5; n++)
	{
		for (m = 1; m <=  n/*内循环受外循环变量控制*/; m++) { putchar('*'); };
		putchar('\n');
	};
}

递减型

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main()
{
	int  m, n;
	for (n = 1; n <= 5; n++)
	{
		for (m = 1; m <= 6 - n/*逐渐减小*/; m++) { putchar('*'); };
		putchar('\n');
	};
}

右侧递增型

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
main() 
{
int  m = 1, n, r;
for (n = 1; n <= 5; n++)
{
    for (r = 1; r <= 6 - n /*逐渐减小*/; r++) { putchar(' '); };
    for (m = 1; m <= n/*逐渐增大*/; m++) { putchar('*'); };
    putchar('\n');
};
}

金字塔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
main()
{
    int  m, n, r;
    for (n = 1; n <= 5; n++)
    {
        for (r = 1; r <= 6 - n; r++)
        {
            putchar(' ');
        };
        for (m = 1; m <= 2 * n - 1; m++)
        {
            putchar('*');
        };
        putchar('\n');
    };
}

csanf

scanf("%f%f%f", &a, &b, &c);
%f实数 **%f%f%f 这段内容要求与输入严格对齐 **

百分之与五分制转换_if else

多次嵌套时，效率较低

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main()
{
	float score;
	scanf("%f", &score);
	if (score >= 90)putchar('A');
	else if (score >= 90)putchar('A');
	else if (score >= 80)putchar('B');
	else if (score >= 70)putchar('C');
	else if (score >= 60)putchar('D');
	else putchar('E');

}

百分之与五分制转换_switch

一次运算出结果，相比多次嵌套的if else更有效率
为实现多重判断而生

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include<stdio.h>
main() {
	int  e, grade;
	float score;
	scanf("%f", &score);
	e = (int)(score / 10.0);/*重点·强制运算*/
	switch (e)
	{
	case 10:grade = 'S'; break;
	case 9:grade = 'A'; break;
	case 8:grade = 'B'; break;
	case 7:grade = 'C'; break;
	case 6:grade = 'D'; break;
	default:grade = 'E';
	}
	printf("\n分数score:=%.2f\n\n等级grade=%c\n", score, grade);
}

第六课-代码的模块化，函数

第五课课后作业

生成99乘法表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//自编
#include <stdio.h>
main()
{
	int m, n = 1, s;
	do
	{
		for (m = 1; m <= n; m++)
		{
			s = n * m;
			printf("%d*%d=%d ", n, m, s);
		};
		printf("\n");
		n++;
	} while (n <= 9);
}
1
2
3
4
5
6
7
8
9
10
11
12
//教案
#include"stdio.h"
void main()
{
	int m, n;
	for (m = 1; m < 10; m++)
	{
		for (n = 1; n <= m; n++)
			printf("%d*%d=%d ", m, n, m * n);
		printf("\n");
	}printf("\n");
}

简单sin案例(点击回顾)

头文件

例如: #incude "math.h"

案例

求n的阶乘_1

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
main()
{
    int n, y;
    y = 1;
    scanf("%d", &n);
    do
    {
        y = y * n;
        n--;
    } while (n);
    printf("%d\n", y);
}

求n的阶乘_2

1
2
3
4
5
6
7
8
9
10
#include <stdio.h>
main()
    {
        int n,y;
        scanf("%d",&n);
        y = fac(n);
        //该程序中fac未定义,直接运行会报错
        //自定义函数的调用
        printf("%d\n",y);
    }

自定义函数

1
2
3
4
5
6
7
8
9
10
11
12
int fac(int x)
/*int fac()最终返回数据类型*/
// n为已赋值变量,int标明数据类型
{
    int y = 1;
    do
    {
        y = y * x;
        x--;
    } while (x);
    return (y); //返回运行结果y
}

自定义函数应用

求n的阶乘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <math.h>
int fac(int x)
{
    int y = 1;
    do
    {
        y = y * x;
        x--;
    } while (x);
    return (y);
}
int main()
{
    int n, y;
    scanf("%d", &n);
    y = fac(n);
    printf("%d\n", y);
}

double long (float int)-双精度浮点数

C、C++中使用到的双精度浮点数（double）类型是在IEEE二进制浮点数算术标准（ANSI/IEEE Std 754-1985）中定义的。
双精度浮点数（Double）用来表示带有小数部分的实数，一般用于计算机编程中定义变量，占用8个字节存储空间，其数值范围为-1.7E-308～1.7E+308，双精度浮点数最多有15或16位十进制有效数字。

%f和%lf分别是float类型和double类型用于格式化输入输出时对应的格式符号。
其中：

  • float，单精度浮点型，对应%f.
    double,双精度浮点型，对应%lf.
  • 在用于输出时:
    float类型可以使用%lf格式，但不会有任何好处。
    double类型如果使用了%f格式可能会导致输出错误。
  • 在用于输入时:
    double 类型使用了%f格式，会导致输入值错误。
    float类型使用double类型不仅会导致输入错误，还可能引起程序崩溃。
    所以在输入输出时，一定要区分好double和float，而使用对应的格式符号。
  • %ld用来输出长整型数。
    %d用来输出整型数。
    因为格式符指明了输出指定的起始地址开始的若干个字节的内容（把它们作为长整型数或整型数来解释），所以，如果用错了对象，就会得出意想不到的结果。如果用%d来输出长整型数，就会只取它的头上几个字节，相当于对原来的长整型数取了模；而如果用%ld来输出整型数，因为实际的数字节数少而硬要取更多的字节，就会发生“把别人家的孩子领回家”的事，把别的数据解释为当前的值了。
    摘录自CSDN

程序始终从主函数main开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <math.h>
long myfac(int n) //自定义函数
{
    int i;
    long y = 1； for (i = 1; i <= n; i++) y = y * i;
    return (y);
}
dou
main()
{
    int n;
    double y;
    long z;
    // double，long双精度数值
    scanf("%d", &n);
    y = sqrt(n);
    z = myfac(n);
printf("n=%d,y=*%lf,z= %ld \n",n,y,z);
}

函数定义角度 认识函数名

int fac (int n){}

  • int函数值的类型
  • fac函数名
  • int n参数的个数与类型
  • {}函数体

函数的调用过程

自定义函数和主函数中变量不相干扰，可以使用相同字符

1. 局部变量与全局变量

在《C语言形参和实参的区别》中提到，形参变量要等到函数被调用时才分配内存，调用结束后立即释放内存。这说明形参变量的作用域非常有限，只能在函数内部使用，离开该函数就无效了。所谓作用域（Scope），就是变量的有效范围。

不仅对于形参变量，C语言中所有的变量都有自己的作用域。决定变量作用域的是变量的定义位置。

2. 值传递和地址传递

点击标题查看 C语言中文网 对于 地址传递 的详解

3. 指针

点击标题查看 菜鸟教程 对于 指针 的详解

以上三点一定要看
以上三点一定要看
以上三点一定要看

案例-指针

未用指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <math.h>
void myswap1(int x, int y)
{
    int z;
    z = x;
    x = y;
    y = z;
    //返回y的值为x的输入值，返回x的值为y的输入值
    //注意：此自定义函数中的x，y的作用域仅为此自定义函数的范围
}
//程序总是从主函数开始执行
main()
{
    int x = 3, y = 5; // x，y为实参
    printf("x = %d,y =%d\n", x, y);
    myswap1(x, y);                  // x,y为形参
    printf("x = %d,y =%d\n", x, y); // x，y为实参
    //实参将值传递给形参，形参值发生互换后的值不能回传给主调函数。因此，主调函数中的数值不变，输出仍为“x = 3, y = 5”
}

未使用指针

采用指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <math.h>
void myswap1(int *x, int *y)
{
    int z;
    z = *x;
    *x = *y;
    *y = z;
    //返回y的值为x的输入值，返回x的值为y的输入值
}
//程序总是从主函数开始执行
int main()
{
    int x = 3, y = 5; 
    printf("x = %d,y =%d\n", x, y);
    myswap1(&x, &y); //
    printf("x = %d,y =%d\n", x, y);
}

使用指针

参考资料

https://baike.baidu.com/item/c%E8%AF%AD%E8%A8%80%E8%BF%90%E7%AE%97%E7%AC%A6%E5%8F%B7/1349432?fr=aladdin
https://www.runoob.com/python/python-operators.html
http://c.biancheng.net/
https://blog.csdn.net/danxibaoxxx/article/details/81236180

经验 > C语言经历
#C语言 #笔记
C语言学习笔记P1|第1-6课
https://liegu0317.top/2022/02/28/C语言学习笔记-长期更新/
作者
多双升
发布于
2022年2月28日
许可协议