1小时速成计算机考研408中的C语言

1小时速成计算机考研408中的C语言

前言

本C语言笔记是笔者听B站UP主五道口一只鸭《1小时速成计算机考研408中的C语言|小黄鸭》时整理的，因此建议搭配小黄鸭up主的视频使用本笔记，如有问题可以在评论区指出！

一、C语言概述

#include //引入头文件
int main() {//main函数，程序的入口
    printf("He11o，wor1d!"); //输出一行文本
    return 0; //表示程序成功结束
}

二、变量与常量

1、变量

int a; //声明一个整型变量a
char b; //声明一个字符型变量b
float c; //声明一个浮点型变量c
double d; //声明一个双精度浮点型变量d

int a = 10;//声明整型变量a，并初始化为10
char b = 'a';//声明字符型变量b，并初始化为'a'
float c = 3.14f;//声明浮点型变量c，并初始化为3.14
double d = 3.14159265358979323846;//声明双精度浮点型变量d，并初始化为π

int a, b, c; //声明多个整型变量
char x, y, z = 'z'; //声明多个字符型变量，其中z被初始化为'z'

注意：声明变量时，尽量反映出变量的用途！

2、常量

const int AGE = 30; //定义一个整型常量AGE
const char GENDER = 'M'; //定义一个字符常量GENDER
const float PI = 3.14f; //定义一个浮点常量PI

const char* NAME = "Tom"; //定义一个字符串常量NAME

三、数据类型

• 整型(int) :用于存储整数，例如-1、0、100等。

• 浮点型(float) :用于存储小数，例如3.14。

• 双精度浮点型(double):用于存储比float更精确的小数。

• 字符型(char):用于存储单个字符，例如’a’、'1’等。

int age = 30;
//定义整型变量age，并初始化为30
float weight = 70.5f;
//定义浮点型变量weight，并初始化为70.5
double pi = 3.14159265358979323846;
//定义双精度浮点型变量pi，并初始化为i
char gender = 'M;
//定义字符型变量gender，并初始化为"M'

四、输入输出

1、输入

printf( "format string", arguments. . .);

int a = 5;
f1oat b = 3.14;
char c = 'A';
printf("a=%d，b=%.2f，c=%c\n", a, b,c);

• \n表示换行;

• %.2f表示输出一个浮点数并且保留两位小数

---

2、输出

scanf( "format string", arguments. . .);

int a;f1oat b;char c;
scanf("%d %f %c",&a,&b,&c);

注：&符号表示引用地址

char str[20];
scanf("%s", str);

注：读入数组、字符串不需要&符号，str本质上就是一个地址

五、运算

1、算术运算

int a = 10， b = 3;
int sum = a + b; //算术运算:加法
int diff = a - ;//算术运算:减法
int product = a * b; //算术运算:乘法
int quotient = a / b; //算术运算:除法
int remainder = a % b; //算术运算:取余

注：两个整数间除法只能得到整数结果；取余只能在整数间使用；

2、比较运算符

int isEqual = (a == b); //比较运算:等于
int isNotEqual = (a !=b); //比较运算:不等于
int isGreater = (a > b); //比较运算:大于
int isLess = (a < b); //比较运算:小于
int isGreaterEqual = (a >= b); //比较运算:大于等于
int isLessEquai = (a <= b); //比较运算:小于等于

注：=表示赋值；==表示相等

3、逻辑运算

int isBothTrue = (isEqual && isGreater); //逻辑运算:与
int isEitherTrue = (isEqual || isGreater); //逻辑运算:或
int isNotEqual = !isEqual;//逻辑运算:非

4、位运算

int bitAnd = a & b; //位运算:与
int bitor = a \ b; //位运算:或
int bitxor = a ^ b; //位运算:异或
int bitNot = ~a; //位运算:非
int leftShift = a << 1; //位运算:左移
int rightShift = a >> 1; //位运算:右移

口诀：与运算【同为1才为1，否则为0】；或运算【有1就是1，否则为0】；异或运算【相同为0，不同为1】

5、赋值运算

a += b;	//赋值运算:加等于
a -= b;	//赋值运算:减等于
a *= b;	//赋值运算:乘等于
a /= b;	//赋值运算:除等于
a %= b;	//赋值运算:取余等于
a <<= 1;	//赋值运算:左移等于
a >>= 1;	//赋值运算:右移等于
a &= b;	//赋值运算:按位与等于
a |= b;	//赋值运算:按位或等于
a ^=b;	//赋值运算:按位异或等于

六、条件分支

1、if

int a = 10;
if(a > 5) {
	printf( "a 是大于5的\n" );
}

2、if…else…

int a = 1;
if(a > 5) {
	printf( "a 是大于5的\n" );
}else{
    printf( "a 是小于或等于5的\n" );
}

3、if…else if…else…

if(a > 10){
    printf("a 大于 10\n");
}else if(a > 5){
    printf("a 大于 5 但小于等于 10\n");
}else {
    printf("a 小于等于 5\n");
}

七、循环

1、for循环

for(初始化;条件;更新){
	//循环体
}

// 这段代码是一个简单的for循环，打印从0到4的数字。
for(int i = 0; i < 5; i++) {
    printf("%d ", i);
}

// 这段代码是一个for循环，从0到10以步长2迭代。
// 每次迭代打印'i'的值。
for(int i = 0; i <= 10; i += 2) {
    printf("%d ", i);
}

// 这段代码是一个for循环，从1到10进行迭代。
// 它使用条件i % 2 == 1来检查当前数字是否为奇数。
// 如果数字是奇数，它使用printf打印该数字。
// 输出将是从1到10的奇数。
for(int i = 1; i <=10; i++) {
    if(i % 2 == 1) {
        printf("%d ", i);
    }
}

// 这段代码是一个嵌套循环，打印了从1到5的乘法表。
// 外部循环从1到5进行迭代，内部循环也从1到5进行迭代。
// 在内部循环中，打印当前i和j的乘积。
// 在打印完内部循环后，打印一个换行字符以换行到下一行。
// 这个过程会一直重复，直到外部循环完成。
for(int i = 1; i <= 5; i++) {
    for(int j = 1; j <= 5; j++) {
        printf("%d ", i * j);
    }
    printf("\n");
}

2、while循环

while(条件){
    //循环体
}

int i = 0;
while (i < 5) {
printf("%d ",i);
    i++;
}

char input;
while (input != 'q') {
    printf("Enter a character: ");
    scanf("%c", &input);
}

int i = 0;
while (1) {
    printf("%d ", i);
    i++;
    if (i >= 5) {
        break;
    }
}

int i = 0;
while (i < 10) {
    i++;
    if (i % 2 == 0) {
        continue;
    }
    printf("%d ", i);
}

注：注意break和continue的区别！

八、数组

1、一维数组

以下是用C语言编写的，它定义了一个整型数组numbers,并初始化为包含1到5的五个元素。然后，使用一个for循环遍历这个数组，并使用printf函数打印出每个元素的值。

int numbers[5] = {1, 2, 3, 4, 5}; // 定义一个包含5个元素的整型数组，并初始化元素为1、2、3、4、5
for (int i = 0; i < 5; i++) { // 使用for循环从0开始遍历数组，直到i小于5为止
    printf("%d ", numbers[i]); // 使用printf函数打印数组中的第i个元素的值，并在末尾添加一个空格
}

注：数组元素必须是同一类型

2、二维数组

#include 

int main() {
    int matrix[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
    return 0;
}

以上代码是一个简单的C语言程序，它声明了一个3x3的整数矩阵并初始化了它的值。然后使用两个嵌套的for循环遍历矩阵中的每个元素，并将它们打印出来。

3、数组的输入

#include 

int main() {
    int numbers[5];
    for (int i = 0; i < 5; i++) {
        printf("Enter a number: ");
        scanf("%d", &numbers[i]);
    }
    return 0;
}

以上代码是一个简单的C语言程序，它声明了一个包含5个整数元素的数组 numbers,然后使用循环从用户输入中读取5个数字，并将它们存储在数组中。

4、数组大小

#include 

int main() {
    int numbers[5] = {1,2,3,4,5};
    int length = sizeof(numbers)/sizeof(numbers[0]);
    printf("The length of the array is: %d", length);
    return 0;
}

以上代码声明了一个包含5个整数元素的数组 numbers,并使用 sizeof 运算符计算数组的总字节数和单个元素的字节数。然后将总字节数除以单个元素的字节数，得到数组中元素的个数，即数组的长度。最后使用 printf 函数打印出数组的长度。

九、函数

1、函数的定义

函数的定义包括函数名、参数列表、返回类型和函数体。下面是一个简单的C语言函数的定义示例：

int add(int a, int b) {
    int sum = a + b;
    return sum;
} 

在这个示例中，函数名为 add,它接受两个整数类型的参数 a 和 b,并返回一个整数类型的值。函数体中的代码计算了两个参数的和，并将结果存储在变量 sum 中，最后使用 return 语句将结果返回给调用者。

2、函数的调用

int result = add( 10,20);
printf("The sum is: %d", result);

这段代码调用了之前定义的 add 函数，并将参数 10 和 20 传递给它。函数返回两个参数的和，然后将结果存储在变量 result 中。最后使用 printf 函数打印出结果。

3、无返回值函数

以下代码定义了一个名为 printwelcomeMessage 的函数，它没有参数，也没有返回值。函数体中的代码使用 printf 函数打印出一条欢迎消息。

void printwelcomeMessage() {
    printf("welcome to our program!\n");
}

在C语言中，函数参数传递有两种方式：值传递和引用传递。

1. 值传递(Pass by Value):
   当一个函数被调用时，实参的值会被复制到形参中。这样，在函数内部对形参进行修改不会影响到实参的值。值传递的方式适用于基本数据类型和较小规模的结构体。

2. 引用传递(Pass by Reference):
   当一个函数被调用时，实参的引用会被复制到形参中。这样，在函数内部对形参进行修改会影响到实参的值。引用传递的方式适用于大型结构体和指针类型。

下面是一个示例代码，演示了值传递和引用传递的区别：

#include 

void modifyValue(int x) {
    x = 20; // 修改值传递的实参x
}

void modifyReference(int &y) {
    *y = 30; // 修改引用传递的实参y所指向的值
}

int main() {
    int num = 10;
    printf("Before function call: %d\n", num);
    
    modifyValue(num); // 值传递
    printf("After value pass: %d\n", num);
    
    int y = 20;
    printf("Before reference pass: %d\n", y);
    
    modifyReference(&y); // 引用传递
    printf("After reference pass: %d\n", y);
    
    return 0;
}

输出结果为：

Before function call: 10
After value pass: 10
Before reference pass: 20
After reference pass: 30

可以看到，在值传递的情况下，对实参进行修改不会影响到外部变量的值；而在引用传递的情况下，对实参进行修改会影响到外部变量的值。

4、函数的声明

这是一个函数声明，它定义了一个名为 add 的函数，该函数接受两个整数类型的参数 a 和 b,并返回一个整数类型的值。

int add(int a, int b);

在C语言中，函数声明包括函数名、返回类型和参数列表。在这个例子中，函数名是 add,返回类型是 int,参数列表是 (int a, int b),表示该函数接受两个整数类型的参数。

5、函数的作用域

这段代码首先声明了一个名为 func1 的全局函数，该函数没有参数和返回值。然后在 main 函数中调用了这个全局函数。最后，在 func1 函数中使用 printf 函数打印一条消息。

#include 

void func1(); // 声明全局函数

int main() {
    func1(); // 调用全局函数
    return 0;
}

void func1() { // 定义全局函数
    printf("This is a global function.\n");
}

十、指针

1、如何声明一个指针？

int var = 10;
int *ptr; // 声明一个指向整数类型的指针
ptr = &var; // 将指针指向变量 var 的地址

在C语言中，声明一个指针需要指定指针所指向的数据类型。可以使用 * 符号来表示指针。

printf( "%d", *ptr);

这段代码使用了 printf 函数和指针来输出指针所指向的变量的值。

*ptr 表示取指针 ptr 所指向的变量的值，然后使用 printf 函数将其打印出来。

需要注意的是，在使用 printf 函数输出指针所指向的变量的值之前，需要确保指针已经指向了一个有效的内存地址，并且该地址上存储的数据类型是可以被 printf 函数正确解析的。

*ptr = 20;

这段代码使用了指针和取地址运算符 & 将指针所指向的变量的值修改为 20。

*ptr 表示取指针 ptr 所指向的变量的值，然后使用赋值运算符 = 将该值修改为 20。

需要注意的是，在使用 *ptr = 20; 修改指针所指向的变量的值之前，需要确保指针已经指向了一个有效的内存地址，并且该地址上存储的数据类型是可以被赋值操作正确解析的。

int arr[3] = {10，20，30};
int *ptr = arr;
for(int i = 0; i < 3; i++) {
    printf("%d ",*(ptr + i));
}

这段代码定义了一个整型数组 arr,并将其初始化为 {10, 20, 30}。然后定义了一个指向整型的指针 ptr,并将其指向数组 arr 的首元素。

接下来使用 for 循环遍历数组中的每个元素，通过指针和偏移量计算出每个元素的地址，并使用 printf 函数将该元素的值打印出来。

void swap(int *a, int*b) {
    int temp = *a;
    *a=*b;
    *b= temp ;
}
int main() {
    int x = 5, 
    y = 10;
    swap(&x，&y);
    printf( "x = %d， y = %d", x,y);
    return 0;
}

这段代码定义了一个名为 swap 的函数，用于交换两个整型变量的值。该函数接受两个指向整型的指针作为参数，并使用一个临时变量来实现值的交换。

在 main 函数中，定义了两个整型变量 x 和 y,并将它们的初始值分别设置为 5 和 10。然后调用 swap 函数，将 &x 和 &y 作为参数传递给它，以交换它们的值。最后使用 printf 函数打印出交换后的变量值。

输出结果为：

x = 10, y = 5

这段代码的作用是演示如何使用指针和函数来交换两个整型变量的值。

2、多级指针

多级指针是指一个指针变量的指针变量，也就是说，它是一个指针，这个指针所指向的值又是一个指针。例如，定义一个二级指针：int *q; q 的前面有两个,这个该如何理解呢？与一级指针相比，二级指针多了一层间接寻址 。

以下是一个 C 语言多级指针的例子：

#include 
int main()
{
    int a = 10;
    int *p = &a;
    int **q = &p;
    printf("a=%d,*p=%d,**q=%d
", a, *p, **q);
    return 0;
}

这个例子中，我们定义了一个整型变量 a,然后定义了一个指向整型变量的指针 p,并将 &a 赋值给它。接着，我们定义了一个指向指针的指针 q,并将 &p 赋值给它。最后，我们使用 printf 函数输出了变量 a、*p 和 **q 的值。

十一、结构体定义

//结构体定义语法
struct struct_name {
    data_type1 member1;
    data_type2 member2;
    //more members
};

以下代码定义了一个名为 Student 的结构体类型，它包含了三个成员变量：name、roll 和 marks。

• name 是一个长度为 50 的字符数组，用于存储学生的姓名。
• roll 是一个整型变量，用于存储学生的学号。
• marks 是一个浮点型变量，用于存储学生的分数。

通过定义结构体类型，我们可以方便地组织和管理相关的数据，并在程序中使用结构体来表示复杂的数据结构。

struct Student {
    char name[ 50];
    int roll;
    float marks;
};

1、创建结构体实例

struct struct_name variable_name;
struct student s1;
strcpy(s1.name，"Tom");
s1.roll = 101;
s1.marks = 89.5;

这段代码定义了一个名为 struct_name 的结构体类型，并声明了一个该类型的变量 variable_name。接着，它定义了一个名为 s1 的 student 结构体类型的实例，并使用 strcpy 函数将字符串 “Tom” 复制到 s1.name 中。然后，它分别给 s1.roll 和 s1.marks 分别赋值为 101 和 89.5。

通过这段代码，我们可以创建一个 student 类型的实例，并对其成员变量进行初始化和赋值操作。这对于管理学生信息等场景非常有用。

2、初始化结构体变量

struct Student {
    char name[ 50];
    int roll;
    float marks;
}s2 = { "Jerry",102,92.5};

这段代码定义了一个名为 Student 的结构体类型，并声明了一个该类型的变量 s2。接着，它使用花括号初始化了 s2 的三个成员变量：name、roll 和 marks,分别赋值为 “Jerry”、102 和 92.5。

通过这种方式，我们可以在声明结构体变量的同时对其进行初始化，避免了在程序中多次重复相同的初始化操作。这可以提高代码的可读性和可维护性。

3、结构体变量与函数

void printstudent(struct student s) {
    printf("Name: %s\n", s.name);
    printf("Ro11: %d\n", s.roll);
    printf( "Marks: %.2f\n", s.marks);
}

这段代码定义了一个名为 printstudent 的函数，该函数接受一个 student 结构体类型的参数 s,并输出该学生的姓名、学号和分数。

在函数内部，使用 printf 函数分别输出了 s.name、s.roll 和 s.marks 的值。其中，%s、%d 和 %.2f 是格式化字符串，用于指定输出的数据类型和格式。

通过这个函数，我们可以方便地将学生信息输出到控制台或文件中，以便进行后续处理和管理。

4、结构体与指针

struct Node {
    int value;
    struct Node *next;
};

这段代码定义了一个名为 Node 的结构体类型，它包含了两个成员变量：value 和 next。

• value 是一个整型变量，用于存储节点的值。
• next 是一个指向 Node 类型的指针，用于指向下一个节点。

通过定义结构体类型，我们可以方便地组织和管理相关的数据，并在程序中使用结构体来表示复杂的数据结构。在这个例子中，Node 类型可以用来表示链表中的一个节点。

5、结构体与结构体

struct Family {
    struct student_parents[2];
    struct student_children[5];
    int numchildren;
};

这段代码定义了一个名为 Family 的结构体类型，它包含了三个成员变量：

• student_parents 是一个长度为 2 的 student 结构体数组，用于存储家庭中父母的信息。
• student_children 是一个长度为 5 的 student 结构体数组，用于存储家庭中子女的信息。
• numchildren 是一个整型变量，用于存储家庭中子女的数量。

通过这个结构体类型，我们可以方便地组织和管理相关的数据，并在程序中使用结构体来表示复杂的数据结构。在这个例子中，Family 类型可以用来表示一个家庭，其中包括父母和子女的信息。

---

感谢大家的阅读，如果觉得不错欢迎点赞！