第一周笔记分享

[Gdd]

第一周-C语言

第一讲

一. 转义序列

• ① \ + 字母 组成 转义序列
• ② \n 表 换行

printf("Hello 米醋\nHello G_dd");

二. 占位符

1. %d 用于 int 类型
2. %f 用于 float 类型
3. %c 用于 字符 类型
4. 最小栏宽
   %n.md ：n 表示 最小栏宽。m 表示 有效位数，补0.
   %n.mf ：m 表示 小数点后有效位数

计算长方体体积（初始版）：

#include <stdio.h>  
#include <stdlib.h>  
  
int length = 2;  
int width = 3;  
int high = 4;  
int volum;  
  
int main(int argc, char *argv[]) {  
volum = length*width*high;  
printf("体积 = %d",volum);  
return 0;  
}

计算长方体体积（进阶版）：

#include <stdio.h>  
#include <stdlib.h>  
  
/* 变量声明区 */  
int length = 2;                //长  
int width = 3;                //宽  
int high = 4;                //高  
int volum;                    //体积  
  
/* 主函数 */  
int main(int argc, char *argv[]) {  
    printf("请输入长度：");    //格式化输出  
    scanf("%d",&length);    //格式化输入  
    printf("请输入宽度：");  
    scanf("%d",&width);  
    printf("请输入高度：");  
    scanf("%d",&high);  
    volum = length*width*high;  
    printf("体积 = %d",volum);  
    return 0;                //返回  
}

三. 读取用户输入

scanf("%d", &length); //注意变量名前需要加 & (取地址符) 
scanf("%d", &width); 
scanf("%d", &high);

四. 宏定义

• ①.#define

#define PI 3.14f // 定义常量PI，值为3.14

五.随堂练习

1. 输入圆半径，计算体积。
2. 输入两个不同圆的半径，分别计算体积。
3. 在2的基础上，将圆周率精度提升至3.14159。

#include <stdio.h>  
#define PI 3.14159  
  
/* 变量声明区 */  
int r1;  
float volum1;  
int r2;  
float volum2;  
  
/* 主函数 */  
int main(int argc, char *argv[]) {  
    printf("请输入球1的半径：");  
    scanf("%d",&r1);  
    volum1 = 4.0f * PI * r1 * r1 * r1 / 3.0f;  
    printf("球1的体积：%f\n",volum1);  
    printf("请输入球2的半径：");  
    scanf("%d",&r2);  
    volum2 = 4.0f * PI * r2 * r2 * r2 / 3.0f;  
    printf("球2的体积：%f",volum2);  
    return 0;                //返回  
}

第二讲

一. 自增自减运算符

int i = 2,j = 3;
i = j++;  //i = 3,j = 4先赋值再加加
i = ++j;  //i = 4.j = 4先加加再赋值

二. 选择语句

1. 布尔值 (__Bool)表示
   在条件判断中，结果只有两种，用数字表示时，真为 1，假为 0。
2. 关系与判等

• 关系运算符（>、<、>=、<=）用于比较大小。
• 判等运算符（==、!=）用于判断相等或不相等。
• 它们的计算结果直接输出为 1 或 0。

3. 逻辑运算规则

• 逻辑与 &&：全真才真，有假即假。
• 逻辑或 ||：有真即真，全假才假。

4. 条件表达式

• 格式：表达式1 ? 表达式2 : 表达式3
• 规则：如果表达式1为真，就选择表达式2，否则就选择表达式3

5. switch 语句

• 基本格式：

switch(表达式)
    {
        case 常量表达式 : 语句
        case 常量表达式 : 语句
        ............
        case 常量表达式 : 语句
        default :语句
    }

三. 随堂练习

• 1.设计一个C程序，提示用户输入一个数，并判断这个数是奇数还是偶数，如果是奇数，就乘3再显示，如果是偶数，就乘5再显示

#include "stdio.h"  
  
int a;  
  
int main()  
{   
	printf("请输入一个数：");  
    scanf("%d",&a);  
    if(a%2 == 0)  
    {  
        a = a*5;  
        printf("这个数是偶数\n%d",a);  
    }  
        else  
        {  
            a = a*3;  
            printf("这个数是奇数\n%d",a);  
        }  
     return 0;  
}

• 2.10分为满分，7-9分为优秀，6分是及格，0-5分是不及格，输入其它分数显示成绩输入有误

#include "stdio.h"  
  
int a;  
  
int main()  
{     printf("请输入如成绩:");  
    scanf("%d",&a);  
    if(a == 10)  
    {  
        printf("满分");  
    }  
    else if(7 <= a && a <= 9)  
    {  
        printf("优秀");        }  
    else if(a == 6)  
    {  
        printf("及格");        }  
    else if(0 <= a && a <= 5)  
    {  
        printf("不及格");        }  
    else  
    {  
        printf("成绩输入有误");            }  
    return 0;  
}

第三讲

**一.while 循环中的 i-- 与 `–i

• while(i--) : 先判断 i 是否为真（非0），再执行 i--。因此，若初始 i=5，会循环5次（i值变化：5,4,3,2,1,0结束）。
• while(--i) : 先将 i 减1，再判断新值是否为真。因此，若初始 i=5，会循环4次（i值变化：4,3,2,1,0结束）。

二.do...while 循环

特点：无论条件是否满足，循环体至少会被执行一次。

其中while(条件)，一旦满足括号内条件，将继续循环下去。

#include "stdio.h"  
  
int num;  
int i;  
  
int main()  
{  
    printf("请输入一个整数:");  
    scanf("%d",&num);  
        do  
    {  
        num = num/10;  
        i ++;  
    }while(num>0);  
        printf("输入的数字有%d位",i);  
        return 0;  
}

三. for 语句

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

• 表达式1：初始化，只在循环开始前执行一次，可省略。
• 表达式2：循环条件，非 0 为真，0 为假；为假时退出循环，可省略。
• 表达式3：更新表达式，每次循环体执行完后执行，可省略。

四.continue 语句

continue 用于跳过本次循环中剩余的语句，直接开始下一次循环的判断（而不是结束整个循环）。

第四讲

一、数制

1. 常见数制（纯数学层面）
包含：2进制、8进制、10进制、16进制

• 10进制：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
• 8进制：1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20
• 16进制：1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20

2. 位权

以数字 632.45 为例：

数字: 6 3 2 . 4 5
位权: 10^2 10^1 10^0 10^-1 10^-2
位值: 610^2 + 310^1 + 210^0 + 410^-1 + 510^-2
科学计数法: 6.3245 10^2

3. 二进制计算示例

二进制数：0110.1100

展开计算：
02^3 + 12^2 + 12^1 + 02^0 + 12^-1 + 12^-2
= 0 + 4 + 2 + 1/2 + 1/4
= 6.75

4. 进制转换技巧

直接用程序员计算器。

• HEX 旁边加：16进制（或 十六进制）
• DEC 旁边加：10进制（或 十进制）
• OCT 旁边加：8进制（或 八进制）
• BIN 旁边加：2进制（或 二进制）

二、计算机存储体系

1. 二进制

• 0 / 1
• 对应硬件状态：高电平 / 低电平

2. 字 字节

• 字/位：1 0 1
• 字节：0101 0101

4. CPU字长 (注：原图编号跳过了3)

• 定义：中央处理器能一次处理的数据长度
• 常见位数：8位、16位、32位、64位

三、 码制基础

1. 存储一个正整数（无符号数）

• 存储空间：一个字节（8位）
• 二进制表示：0000 0000 到 1111 1111
• 十进制范围：0 到 255（28−128−1）
• 示例（以 18 为例）：
  • 逻辑层面：18，十六进制 0x12
  • 编码格式：进制转换直接对应（十进制转二进制）
  • 物理实在（内存中的实际存储）：0001 0010

2. 存储带正负的整数（有符号数）

• 核心概念：正负（符号）、有符号数
• 规则：最高位为符号位（0表示正数，1表示负数）
  • 0 000 0000：最高位为0，表示正数
  • 1 000 0000：最高位为1，表示负数
• 示例（以 -6 为例）：
  • 逻辑层面：-6
  • 编码格式与物理实在（内存中的实际存储）：
    • 原码：1 000 0110 （最高位为符号位1，其余位为6的绝对值二进制）
    • 反码：1 111 1001 （符号位不变，其余位按位取反）
    • 补码（常用）：1 111 1010 （反码 + 1。计算机底层均使用补码存储整数）

二、int 类型

• 大小：通常为 4字节（32位系统）。2字节是旧式16位系统的标准，现代编程环境下应为4字节。请参考后面的“错题”部分。
• 范围：4字节时，范围为 -2,147,483,648 到 2,147,483,647。

三、char 类型

1. 有符号 char：

   • 字长：1字节
   • 范围：-128 到 127

2. 无符号 unsigned char：

   • 字长：1字节
   • 范围：0 到 255

3. 占位符：%c

4. 表示方法：用单引号 '' 包裹，如 'a', 'Z'。

第五讲

一.数组

• 一.单维数组

int student[3] = {0};   //0 1 2  
int main()  
{  
    for(i = 0;i < 3;i++)  
    {  
        printf("请输入学员学号：");  
        scanf("%d",&j);  
        printf("请输入学员成绩：");  
        scanf("%d",&student[j - 1]);  
    }

• 二.多维数组

#include <stdio.h>
int a[2][3]={ {1,2,3},
              {4,5,6}
            };
int main()
{
    printf("%d",a[0][1]);
    return 0;
}

二.字符与字符串

• 一.字符串：用双引号 " " 括起来，如 "hello"。本质是以 \0 结尾的字符数组。
• 二.字符：用单引号 ' ' 括起来，如 'a', 'b'。
• 声明方式：

char string1[3] = {'a', 'b', 'c'}; 
// 字符数组，未自动添加 '\0' 
char string2[] = "abc"; 
// 字符串，编译器会自动添加 '\0'，大小为4

• 三.占位符：
  • 字符串：%s
  • 字符：%c
• 四.例子：

#include <stdio.h>  
  
char string[3] = {'a','b','c'};  
char string1[] = "abc";  
  
int main()  
{  
    printf("%c\n",string[2]);  
    printf("%s\n",string1);  
    printf("%c",string1[2]);  
        return 0;  
}

三.指针

• 概念：指针是一个变量，其值为另一个变量的内存地址。
• 关键点：数组名本身就是一个指向数组首元素的常量指针。

#include <stdio.h>  
  
int a = 1;  
int* p = NULL; 
// 声明一个指向int类型的指针，并初始化为空  
  
int main()  
{  
     p = &a;      
     // 将变量a的地址赋值给指针p  
     *p = 5;      
     // 通过解引用操作符 *，修改p所指向的内存单元的值，即a的值变为5  
          printf("%d", a); // 输出结果为 5  
        return 0;  
}

第六讲

一.函数

#include <stdio.h>  
  
int a = 3,b = 6,c;  
  
int pingjun(int x,int y)  
{  
    int f;  
    f = (x + y)/3;  
    return f;  
}  
  
int main()  
{  
        c = pingjun(a,b);  
    printf("%d",c);  
        return 0;  
}

二、函数传指针（实现交换）

#include <stdio.h>  
  
int a = 10,b = 20;  
  
void jiaohuan(int* x,int* y)  
{  
    int j;  
    j  = *x;  
    *x = *y;  
    *y = j;  
 
}  
  
int main()  
{  
    jiaohuan(&a,&b);  
    printf("a = %d,b = %d",a,b);  
    return 0;  
}

• j = *x;
  • 右边 *x：拿着钥匙 x，打开 a 的房间，把里面的东西（10）拿出来。
  • 左边 j：把拿出来的 10，放进普通的瓶子 j 里。
  • 结果：瓶子 j 里装上了 10。所以这里 j 不需要 *，因为它只是个接东西的瓶子。
• *x = *y;
  • 右边 *y：打开 b 的房间，拿出 20。
  • 左边 *x：打开 a 的房间，把 20 塞进去。
  • 结果：a 房间里变成了 20。
• *y = j;
  • 右边 j：直接从普通的瓶子 j 里拿出 10（不需要钥匙，不需要 *）。
  • 左边 *y：打开 b 的房间，把 10 塞进去。
  • 结果：b 房间里变成了 10。

三.递归

函数调用自身的编程技巧。必须有明确的终止条件，否则会无限递归导致栈溢出。

int fun2(int n)  
{  
    if(n <= 1)  
        return 1;  
    else         
	    return n*fun2(n-1);  
    }

测试题错题

题目1：在32位计算机上，int型变量常见的大小是（ ）字节，（ ）位。

正确答案：4，32
解析**：32位系统中int通常占4字节，即32位。

题目2：在C语言循环语句中，用于跳出当前循环的语句是（ ），用于跳出当前循环剩余代码进入下一次循环的语句是（ ）。

正确答案：break，continue
解析**：break终止整个循环；continue跳过本次循环剩余部分，进入下一次循环。

题目3:设 a,b,c 都是 int 型变量，且 a=6,b=10,c=12。则表达式 c+=((a>b)||c) 的 c 的结果为（ ），表达式 !(a<b)&&!c||1 的结果为（ ）

正确答案：13，1
解析：a>b为0，0||12为1，c+=1得c=13；此时c=13，a<b为1，!1为0，!c为!13为0，0&&0为0，0||1为1。

题目4：以下变量名合法的是（ ）。

A. 67num B. _32student C. float D. 32_student
正确答案：B
解析**：C语言变量命名规则：只能由字母、数字和下划线组成，且不能以数字开头，也不能与C语言关键字（如 float, int, if 等）重名。

题目5：设 w,x,y,z,m 均为 int 型，w=1, x=1, y=3, z=4，执行以下程序段后，m 的值为（ ）。**

m=(w<x)?w:x;
m=(m<y)?m:y;
m=(m<z)?m:z;
A.1 B.2 C.3 D.4
正确答案：A. 1
解析：w<x为假，m=x=1；m<y为真，m=1；m<z为真，m=1。最终m=1。

题目6：以下程序运行后，输出的结果是（ ）**

A.7 B.4 C.2 D.3

void main()
{
    int a=1,b=2,c=3;
    a+=b;
    switch(a)
    {
        case 1:c++;
        case 2:c--;
        case 3:c+=4;
        case 4:c-=5;
    }
    printf("%d",c);
}

正确答案：C. 2

解析：a+=b 等价于 a=a+b，所以 a=1+2=3。switch(3) 匹配 case 3，执行 c+=4，c 从 3 变为 7。由于没有 break，继续穿透执行 case 4 的 c-=5，c 从 7 变为 2。最终输出 2。

题目7:在C语言中，可以将一个整数赋值给一个字符变量 （ ）

正确答案：√（正确）

char c = 65;  
// 合法，此时 c 存储的是字符 'A'（ASCII码为65）

题目8：在C语言中，switch只能测试整型表达式的值 （ ）

正确答案：√（正确）

大题1：编写一个猜数游戏，让用户有5次机会猜该数字，每次猜完提示猜大了还是猜小了，猜错和猜对要有相应的提示，5次猜错结束游戏，也要有相应的提示，该中奖数字应方便调试修改.

#include <stdio.h>

int a;
int zjs = 32;


int main()
{
	printf("你有5次机会猜该数字，请猜测这个数字：");
	scanf("%d",&a);
	
	for(int i = 0;i<=3;i++)
	{
		if(a < zjs)
		{
			
			printf("这个数字小了\n");
			printf("请再次猜测这个数字：");
			scanf("%d",&a);
		
		}
		else if(a > zjs)
		{
			printf("这个数字大了\n");
			printf("请再次猜测这个数字：");
			scanf("%d",&a);
		
		}
		else if(a == zjs)
		{
			printf("恭喜你猜对了");
			break;
		}
		
	}
	
	if (a != zjs)
	{
		printf("很遗憾你没找出这个数字\n");
	}
	
	
	
	return 0;
}

大题2：设计一个C程序，计算从1到N的所有整数的和，其中N由用户输入，需要有相关提示，例如，如果用户输入的是5，则计算1+2+3+4+5的结果并输出。

#include <stdio.h>  
  
int N;  
int sum;  
  
int main()  
{  
    printf("请输入N的值:");  
    scanf("%d",&N);  
        for(int i=0;i<=N;i++)  
    {  
        sum += i;  
                    }  
    printf("%d",sum);  
        return 0;  
}

大题3：设置一个进制转换程序，用户输入0-255的十进制数，然后输出十六进制0x** 和2进制 。如输入12，输出0X0C,0000 1100。

#include <stdio.h>

int main()
{
	int num;
	printf("请输入一个0-255的十进制数：");
	scanf("%d", &num);
	
	if (num < 0 || num > 255)
	{
		printf("输入超出范围！\n");
		return 1;
	}
	
	// 输出十六进制，%02X 表示大写、两位、不足补0
	printf("0X%02X\n", num);
	
	// 输出二进制，8位，中间空格
	for (int i = 7; i >= 0; i--)
	{
		printf("%d", (num >> i) & 1);
		if (i == 4)          // 第4位后加空格，分成两组4位
			printf(" ");
	}
	printf("\n");
	
	return 0;
}

大题4：设计一个C程序，提示用户输入10个整数，范围0-9999，将用户输入的10个数字排序，形如a<b<c<…或者a>b>c>…

#include <stdio.h>
int main()
{
    int arr[10];
    int i, j, temp;
    printf("请输入10个0-9999之间的整数：\n");
    for (i = 0; i < 10; i++)
    {
        printf("第%d个数：", i + 1);
        scanf("%d", &arr[i]);
        // 检查范围，如果超范围就重新输入当前数
        if (arr[i] < 0 || arr[i] > 9999)
        {
            printf("输入超出范围，请重新输入。\n");
            i--;  // 让循环重新执行这一次
        }
    }
    // 冒泡排序（升序）
    for (i = 0; i < 9; i++)
    {
        for (j = 0; j < 9 - i; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    // 输出升序：a < b < c ...
    printf("升序排列：\n");
    for (i = 0; i < 10; i++)
    {
        printf("%d", arr[i]);
        if (i < 9) printf(" < ");
    }
    printf("\n");
    // 输出降序：a > b > c ...
    printf("降序排列：\n");
    for (i = 9; i >= 0; i--)
    {
        printf("%d", arr[i]);
        if (i > 0) printf(" > ");
    }
    printf("\n");
    return 0;
}