C++基础语法和内存管理

# 1. C语言基础简介

## 1.1 C语言概述
C语言是一种通用的高级语言，由美国贝尔实验室的Dennis Ritchie在20世纪70年代初设计出来。C语言是一种广泛使用的计算机编程语言，它可以用于系统软件的编写，以及应用软件的开发。C语言具有高效、灵活、功能丰富等特点，被认为是程序员必备的基本功之一。

## 1.2 C语言的特点
- C语言具有源代码级的可移植性，一个用C语言编写的程序可以在不同的计算机上进行编译，而不需要修改任何代码。
- C语言提供了丰富的运算符和表达式，可以进行灵活的计算和逻辑操作。
- C语言支持低级内存访问，可以直接操作内存地址，实现底层细节的控制。

## 1.3 C语言的发展历史
C语言的发展历史可以分为以下几个阶段：
- 1972年，Dennis Ritchie设计出最初版本的C语言，并用于Unix操作系统的重写工作。
- 1978年，美国国家标准协会（ANSI）开始着手制定C语言的标准，最终于1989年发布了ANSI C标准，即C89。
- 1999年，ANSI C标准进行了修订，新的标准称为C99，增加了一些新特性和改进。

以上是C语言基础简介部分的内容，后续章节将深入探讨C语言的基础语法、函数与指针、内存管理、结构体与联合体、文件操作与输入输出等方面的知识。

# 2. C语言基础语法

### 2.1 数据类型和变量
C语言中的数据类型和变量是基础的概念，是我们编写程序的基础。数据类型决定了变量所占用的内存空间，以及变量能够存储的值的范围和类型。

#### 2.1.1 基本数据类型
在C语言中，基本数据类型包括整型、浮点型、字符型和布尔型。以下是常用的基本数据类型及其在内存中的大小。

- 整型：int、short、long、unsigned int、unsigned short、unsigned long
- 浮点型：float、double
- 字符型：char
- 布尔型：bool

#### 2.1.2 变量的声明和定义
在C语言中，我们需要先声明一个变量，然后才能使用它。变量的声明将变量的名称和数据类型告诉编译器，而变量的定义则为变量分配内存空间。

// 变量的声明
int num;
float pi;

// 变量的定义
int num = 10;
float pi = 3.14;

#### 2.1.3 变量的命名规则
在C语言中，变量的命名需要遵循一定的规则：

- 变量名由字母、数字和下划线组成，不能以数字开头。
- 变量名区分大小写。
- 变量名不能与C语言的关键字重复。
- 变量名要具有描述性，能够清楚地表示变量的用途。

### 2.2 运算符和表达式
C语言中的运算符和表达式是用来进行各种数学和逻辑运算的工具。

#### 2.2.1 数学运算符
C语言提供了常见的数学运算符，包括加法、减法、乘法、除法、取模等。

int a = 10;
int b = 5;

int sum = a + b;        // 加法
int diff = a - b;       // 减法
int product = a * b;    // 乘法
int quotient = a / b;   // 除法
int remainder = a % b;  // 取模

#### 2.2.2 关系运算符和逻辑运算符
在C语言中，我们可以使用关系运算符进行比较操作，使用逻辑运算符进行逻辑判断。

int a = 10;
int b = 5;

bool isEqual = (a == b);     // 相等
bool isNotEqual = (a != b);  // 不相等
bool isGreater = (a > b);    // 大于
bool isLess = (a < b);       // 小于
bool isGreaterOrEqual = (a >= b);   // 大于等于
bool isLessOrEqual = (a <= b);      // 小于等于

bool logicalAnd = (a > 0 && b > 0);      // 逻辑与
bool logicalOr = (a > 0 || b > 0);       // 逻辑或
bool logicalNot = !(a > 0);              // 逻辑非

### 2.3 控制语句（if、switch、while、for等）
控制语句是用来控制程序执行流程的工具，能够根据条件选择不同的路径执行。

#### 2.3.1 if语句
if语句用于根据条件选择执行不同的代码块。

int num = 5;

if (num > 0) {
    printf("num是正数");
} else if (num == 0) {
    printf("num是零");
} else {
    printf("num是负数");
}

#### 2.3.2 switch语句
switch语句用于根据表达式的值选择执行不同的代码块。

int dayOfWeek = 2;

switch (dayOfWeek) {
    case 1:
        printf("星期一");
        break;
    case 2:
        printf("星期二");
        break;
    case 3:
        printf("星期三");
        break;
    default:
        printf("其他");
        break;
}

#### 2.3.3 while循环和for循环
while循环和for循环用于重复执行一段代码，直到达到退出条件。

// while循环
int i = 0;
while (i < 5) {
    printf("%d\n", i);
    i++;
}

// for循环
for (int i = 0; i < 5; i++) {
    printf("%d\n", i);
}

以上是C语言基础语法的概述，包括数据类型和变量、运算符和表达式，以及控制语句。掌握了这些基础知识，我们就可以开始编写简单的C语言程序了。

# 3. C语言函数与指针
## 3.1 函数的定义与调用
函数是C语言中最基本的程序单元，它可以执行一系列的操作，并且可以被其他代码多次调用。在C语言中，函数的定义由函数头和函数体组成，函数名、参数列表和返回值类型都需要在函数头中进行声明。

#include <stdio.h>

// 函数的定义
int sum(int a, int b) {
    return a + b;
}

int main() {
    int num1 = 5;
    int num2 = 7;

    // 函数的调用
    int result = sum(num1, num2);
    printf("Sum: %d\n", result);

    return 0;
}

**代码解析：**
- 在上面的代码中，我们定义了一个求和函数`sum`，它接受两个整型参数`a`和`b`，并返回它们的和。
- 在`main`函数中，我们声明了两个整型变量`num1`和`num2`，并将它们的值分别设为5和7。
- 通过调用`sum`函数，将`num1`和`num2`作为参数传递进去，并将返回的结果保存到`result`变量中。
- 最后，使用`printf`函数打印出结果。

## 3.2 函数参数传递
函数参数的传递方式有两种：值传递和地址传递。值传递是指将参数的值复制一份给函数中的变量，地址传递是指将参数的地址传递给函数中的指针变量。

#include <stdio.h>

void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
}

void swapByPtr(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int num1 = 5;
    int num2 = 7;

    printf("Before swap: num1 = %d, num2 = %d\n", num1, num2);
    swap(num1, num2);
    printf("After swap (by value): num1 = %d, num2 = %d\n", num1, num2);

    printf("Before swap: num1 = %d, num2 = %d\n", num1, num2);
    swapByPtr(&num1, &num2);
    printf("After swap (by address): num1 = %d, num2 = %d\n", num1, num2);
    return 0;
}

**代码解析：**
- 在上面的代码中，我们定义了两个函数：`swap`和`swapByPtr`。
- `swap`函数根据传入的两个参数`a`和`b`交换它们的值，但由于是值传递，所以只会在函数内部交换，对外部的变量没有影响。
- `swapByPtr`函数使用指针作为参数，通过修改指针指向的内存地址的值实现变量交换。通过传递变量的地址，能够在函数内部修改外部变量的值。
- 在`main`函数中，我们声明了两个整型变量`num1`和`num2`，并将它们的值分别设为5和7。
- 通过先后调用`swap`和`swapByPtr`函数，我们展示了值传递和地址传递的不同效果。

## 3.3 指针的基本概念
指针是C语言中一种特殊的变量类型，它存储了一个内存地址，可以通过该地址访问到存储在该地址处的值。指针变量需要通过取地址运算符`&`来获取一个变量的地址，通过解引用运算符`*`来获取指针所指向的值。

#include <stdio.h>

int main() {
    int num = 5;
    int* ptr;

    ptr = &num; // 指针指向num变量的地址
    printf("Value of num: %d\n", num);
    printf("Value of num through pointer: %d\n", *ptr);

    return 0;
}

**代码解析：**
- 在上面的代码中，我们声明了一个整型变量`num`和一个整型指针`ptr`。
- 通过`&num`获取`num`变量的地址，并将地址赋值给`ptr`，即指针`ptr`指向`num`变量。
- 使用`*ptr`可以获取指针所指向的值，即`num`的值。
- 在`printf`函数中，我们分别打印出`num`的值和通过指针获取的值。

## 3.4 指针与数组
在C语言中，数组名被视为数组的首元素的地址，通过指针操作数组可以方便地进行遍历和修改。

#include <stdio.h>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int* ptr = arr;

    printf("Elements of array: ");
    for (int i = 0; i < 5; i++) {
        printf("%d ", *(ptr + i));
    }

    return 0;
}

**代码解析：**
- 在上面的代码中，我们声明了一个包含5个整型元素的数组`arr`，并初始化元素的值。
- 将数组的首元素的地址赋值给指针`ptr`。
- 使用指针访问数组的元素时，可以通过`*(ptr + i)`的方式来获取元素的值，其中`i`为索引。
- 在`for`循环中，我们遍历数组并打印出数组的元素值。

以上是第三章的内容，涵盖了C语言中函数的定义与调用、函数参数传递、指针的基本概念以及指针与数组的关系。希望对您有所帮助！

# 4. 内存管理

#### 4.1 内存分配与释放

在C语言中，内存的分配和释放是非常重要的。C语言提供了一些内置的函数来帮助我们进行内存管理。其中，最常用的是`malloc()`和`free()`函数。

##### 4.1.1 `malloc()`函数

`malloc()`函数用于在内存中动态分配一块指定大小的连续内存空间。其语法如下：

void* malloc(size_t size);

这里，`size`参数表示需要分配的内存空间大小，单位为字节。`malloc()`函数会返回一个指向分配的内存空间的指针，如果分配失败，则返回`NULL`。

下面是一个简单的示例，演示了如何使用`malloc()`函数动态分配内存空间：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    ptr = (int*)malloc(5 * sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败\n");
    }
    else {
        printf("内存分配成功\n");
        // 使用完内存空间后，必须通过free函数释放
        free(ptr);
    }
    return 0;
}

##### 4.1.2 `free()`函数

`free()`函数用于释放之前动态分配的内存空间，使其可以被系统重新使用。其语法如下：

void free(void* ptr);

这里，`ptr`参数是之前使用`malloc()`函数分配的内存空间的指针。

下面是一个示例，演示了如何使用`malloc()`和`free()`函数配合使用：

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr;
    ptr = (int*)malloc(5 * sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败\n");
    }
    else {
        printf("内存分配成功\n");
        // 释放内存空间
        free(ptr);
        printf("内存已被释放\n");
    }
    return 0;
}

通过合理地使用`malloc()`和`free()`函数，我们可以更加灵活地管理内存空间，防止内存泄漏和内存溢出等问题。

#### 4.2 堆内存与栈内存

在C语言中，存在两种不同的内存分配方式：堆内存和栈内存。

##### 4.2.1 堆内存

堆内存是动态分配的内存空间，它的大小和生命周期是在程序运行时动态确定的。我们可以使用`malloc()`函数来在堆内存中分配指定大小的内存空间。堆内存的好处是可以灵活地分配和释放，但需要手动管理内存，容易出现内存泄漏和内存泄漏问题。

##### 4.2.2 栈内存

栈内存是由编译器自动分配和释放的，它的大小和生命周期是静态确定的。在C语言中，函数中的局部变量通常存储在栈内存中。

#include <stdio.h>

void func() {
    int num = 10; // num存储在栈内存中
    // ...
}

int main() {
    func();
    // ...
    return 0;
}

栈内存的优点是分配和释放简单方便，但不适合存储大量的动态数据。

#### 4.3 内存泄漏和内存溢出

在C语言中，内存泄漏和内存溢出是两个常见的内存管理问题。

##### 4.3.1 内存泄漏

内存泄漏是指在程序运行过程中，动态分配的内存空间未被正确释放的情况。这会导致程序运行过程中占用的内存空间越来越大，最终导致系统内存耗尽。

void func() {
    int *ptr = (int*)malloc(10 * sizeof(int));
    // ...
    // 忘记释放内存
}

##### 4.3.2 内存溢出

内存溢出是指程序试图访问超出其分配的内存空间范围的情况。这会导致程序崩溃或产生不可预测的行为。

int arr[5];
arr[5] = 10; // 越界访问，可能导致内存溢出

#### 4.4 动态内存分配函数

除了`malloc()`和`free()`函数之外，C语言还提供了一些其他动态内存分配函数，如`calloc()`、`realloc()`等，它们可以更灵活地满足不同场景下的内存管理需求。

# 5. 结构体与联合体

结构体和联合体是 C 语言中用来表示复合数据类型的两种重要方式，它们可以用来封装不同类型的数据。本章将详细介绍结构体和联合体的定义、使用及其在实际应用中的情景。

#### 5.1 结构体的定义与使用

在 C 语言中，结构体是一种用户自定义的数据类型，它允许我们将不同类型的数据组合在一起，形成一个新的数据类型。结构体通常用于描述一组相关的数据，比如表示一个学生的信息或者一个图形的属性等。

以下是一个结构体的简单示例：

// 定义一个表示学生的结构体
struct Student {
    int id;
    char name[20];
    float gpa;
};

我们可以通过上面定义的结构体创建具体的学生对象，并操作其属性：

int main() {
    // 创建结构体对象
    struct Student stu1 = {101, "Tom", 3.8};
    // 访问结构体成员
    printf("学生信息：\n");
    printf("学号：%d\n", stu1.id);
    printf("姓名：%s\n", stu1.name);
    printf("GPA：%f\n", stu1.gpa);
    return 0;
}

上面的代码中，我们定义了一个名为 `Student` 的结构体，包含了学生的学号、姓名和 GPA。然后在 `main` 函数中，我们创建了一个 `stu1` 的结构体对象，并访问了其成员信息。

#### 5.2 结构体的嵌套和指针

结构体可以嵌套定义，也可以包含指向自身类型的指针。这样的设计可以用于构建复杂的数据结构，比如树、图等。下面是一个简单的嵌套结构体示例：

// 定义一个表示日期的结构体
struct Date {
    int year;
    int month;
    int day;
};

// 嵌套结构体
struct Student {
    int id;
    char name[20];
    struct Date birth;
};

在这个例子中，`Student` 结构体包含了另一个结构体 `Date`，用来表示学生的出生日期。我们也可以使用指向自身类型的指针来构建链表等数据结构，但这部分内容留待后续深入讨论。

#### 5.3 联合体的概念和用法

与结构体类似，联合体也是一种用户自定义的数据类型。不同的是，联合体的成员共享同一块内存空间，因此联合体的大小由最大成员的大小决定。联合体常用于需要节省内存空间或者表示多种形式的数据的情况。

以下是一个简单的联合体示例：

// 定义一个联合体
union Number {
    int intValue;
    float floatValue;
};

int main() {
    // 创建并访问联合体对象
    union Number num;
    num.intValue = 10;
    printf("整数值：%d\n", num.intValue);
    num.floatValue = 3.14;
    printf("浮点数值：%f\n", num.floatValue);
    return 0;
}

在上面的示例中，我们定义了一个联合体 `Number`，它可以表示整数或者浮点数。在 `main` 函数中，我们分别给联合体赋值，并访问其成员。需要注意的是，联合体的不同成员共享同一块内存，因此在赋值后会覆盖原有的值。

希望以上内容能帮助您更好地理解结构体与联合体在 C 语言中的使用。

# 6. 文件操作与输入输出

### 6.1 文件的基本操作

文件的输入输出是程序与外部存储介质之间交换数据的方式，可以是文本文件或二进制文件。在C语言中，可以使用标准库提供的文件操作函数来实现文件的基本操作。

文件的基本操作包括创建文件、打开文件、关闭文件和删除文件等操作。

#### 创建文件

在C语言中，可以使用`fopen()`函数来创建文件。`fopen()`函数的原型如下：

FILE* fopen(const char* filename, const char* mode);

- `filename`：字符串类型，表示要创建的文件名。
- `mode`：字符串类型，表示打开文件的模式，如`"r"`表示只读模式，`"w"`表示写入模式，`"a"`表示追加模式等。

下面的示例演示了如何创建一个名为`test.txt`的文本文件：

#include <stdio.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "w");

   if (file == NULL) {
      printf("无法创建文件\n");
      return 1;
   }

   printf("文件创建成功\n");
   fclose(file);
   return 0;
}

#### 打开文件

在C语言中，可以使用`fopen()`函数来打开文件。`fopen()`函数的原型已在上面的示例中给出。

下面的示例演示了如何打开一个已存在的名为`test.txt`的文本文件：

#include <stdio.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   printf("文件打开成功\n");
   fclose(file);
   return 0;
}

#### 关闭文件

在C语言中，可以使用`fclose()`函数来关闭已打开的文件。`fclose()`函数的原型如下：

int fclose(FILE *file);

- `file`：指向已打开的文件的指针。

下面的示例演示了如何关闭一个已打开的文件：

#include <stdio.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   printf("文件打开成功\n");

   if (fclose(file) != 0) {
      printf("无法关闭文件\n");
      return 1;
   }

   printf("文件关闭成功\n");
   return 0;
}

#### 删除文件

在C语言中，可以使用`remove()`函数来删除文件。`remove()`函数的原型如下：

int remove(const char *filename);

- `filename`：字符串类型，表示要删除的文件名。

下面的示例演示了如何删除一个名为`test.txt`的文件：

#include <stdio.h>

int main() {
   if (remove("test.txt") != 0) {
      printf("无法删除文件\n");
      return 1;
   }

   printf("文件删除成功\n");
   return 0;
}

### 6.2 文件的打开与关闭

文件的打开和关闭是文件操作中非常重要的两个步骤。在C语言中，可以使用`fopen()`函数打开文件，使用`fclose()`函数关闭文件。

#### 打开文件

在C语言中，可以使用`fopen()`函数来打开文件。`fopen()`函数的原型已在前面的内容中给出。

下面的示例演示了如何打开一个已存在的名为`test.txt`的文本文件：

#include <stdio.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   printf("文件打开成功\n");
   fclose(file);
   return 0;
}

#### 关闭文件

在C语言中，可以使用`fclose()`函数来关闭已打开的文件。`fclose()`函数的原型已在前面的内容中给出。

下面的示例演示了如何关闭一个已打开的文件：

#include <stdio.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   printf("文件打开成功\n");

   if (fclose(file) != 0) {
      printf("无法关闭文件\n");
      return 1;
   }

   printf("文件关闭成功\n");
   return 0;
}

### 6.3 文件的读写操作

在C语言中，可以使用`fprintf()`函数将数据写入文件，使用`fscanf()`函数从文件中读取数据。

#### 写入数据

在C语言中，可以使用`fprintf()`函数将数据写入文件。`fprintf()`函数的原型如下：

int fprintf(FILE *file, const char *format, ...);

- `file`：指向要写入数据的文件的指针。
- `format`：字符串类型，表示格式化输出的格式。

下面的示例演示了如何向文件中写入数据：

#include <stdio.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "w");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   fprintf(file, "Hello, World!");

   printf("数据写入成功\n");

   fclose(file);
   return 0;
}

#### 读取数据

在C语言中，可以使用`fscanf()`函数从文件中读取数据。`fscanf()`函数的原型如下：

int fscanf(FILE *file, const char *format, ...);

- `file`：指向要从中读取数据的文件的指针。
- `format`：字符串类型，表示格式化输入的格式。

下面的示例演示了如何从文件中读取数据：

#include <stdio.h>

int main() {
   FILE *file;
   char buffer[100];

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   fscanf(file, "%s", buffer);

   printf("读取的数据：%s\n", buffer);

   fclose(file);
   return 0;
}

### 6.4 错误处理与文件指针

在进行文件操作时，需要注意错误处理。在C语言中，可以使用`errno`变量和`perror()`函数来处理文件操作的错误。

#### 错误处理

在C语言中，可以使用`errno`变量来获取发生错误的原因代码。`errno`变量的类型是整型，其值可以通过`<errno.h>`头文件中定义的常量来确定。

下面的示例演示了如何使用`errno`变量来处理文件操作的错误：

#include <stdio.h>
#include <errno.h>

int main() {
   FILE *file;

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("发生错误：%d\n", errno);
      perror("错误信息");
      return 1;
   }

   fclose(file);
   return 0;
}

#### 文件指针

在C语言中，文件指针是用来操作文件的数据类型。在打开文件时，可以使用`fopen()`函数返回的文件指针进行文件的读写操作。

下面的示例演示了如何使用文件指针来进行文件操作：

#include <stdio.h>

int main() {
   FILE *file;
   char buffer[100];
   int data;

   file = fopen("test.txt", "r");

   if (file == NULL) {
      printf("无法打开文件\n");
      return 1;
   }

   // 读取文件中的字符串
   fscanf(file, "%s", buffer);
   printf("读取的数据：%s\n", buffer);

   // 定位到文件的开头
   rewind(file);

   // 读取文件中的整数
   fscanf(file, "%d", &data);
   printf("读取的数据：%d\n", data);

   fclose(file);
   return 0;
}

希望这一章的内容能够帮助您理解文件操作与输入输出在C语言中的基本使用方法。