《深入浅出C语言：从基础到指针的全面指南》

小魏冬琅2024-06-03 22:06

1. 简介

C语言是一种通用的编程语言，广泛应用于系统编程、嵌入式系统和高性能应用程序。它由Dennis Ritchie在1972年开发，并且至今仍然非常流行。C语言以其高效、灵活和强大的功能著称，是许多现代编程语言的基础。

2. 基本语法

2.1 Hello, World!程序
cpp 复制代码 
#include <stdio.h>

int main() {
    printf("Hello, World!\n");
    return 0;
}
  • #include <stdio.h>：包含标准输入输出库。
  • int main()：程序的主函数。
  • printf：输出函数，用于打印字符串。
  • return 0：返回0表示程序成功结束。
2.2 注释

C语言支持单行注释和多行注释：

cpp 复制代码 
// 这是单行注释
/*
  这是多行注释
*/

3. 数据类型和变量

3.1 基本数据类型

C语言有以下几种基本数据类型：

  • 整型（int）
  • 浮点型（float, double）
  • 字符型（char）
cpp 复制代码 
int a = 10;
float b = 5.5;
char c = 'A';
3.2 变量声明和初始化

变量声明和初始化可以在同一行完成：

cpp 复制代码 
int x = 5;
float y = 3.14;
char z = 'A';
3.3 常量

使用const关键字定义常量：

cpp 复制代码 
const int MAX = 100;
数据类型 描述
int 整型
float 浮点型
double 双精度浮点型
char 字符型
const 常量

4. 运算符

4.1 算术运算符

C语言支持以下算术运算符：

  • +：加法
  • -：减法
  • *：乘法
  • /：除法
  • %：取模
cpp 复制代码 
int a = 10, b = 3;
int sum = a + b;  // sum = 13
int diff = a - b; // diff = 7
int prod = a * b; // prod = 30
int quot = a / b; // quot = 3
int mod = a % b;  // mod = 1
4.2 关系运算符

关系运算符用于比较两个值：

  • ==：等于
  • !=：不等于
  • >：大于
  • <：小于
  • >=：大于等于
  • <=：小于等于
cpp 复制代码 
int x = 5, y = 10;
int result = (x == y); // result = 0 (false)
result = (x != y);     // result = 1 (true)
result = (x > y);      // result = 0 (false)
result = (x < y);      // result = 1 (true)
4.3 逻辑运算符

逻辑运算符用于组合多个条件：

  • &&：逻辑与
  • ||：逻辑或
  • !：逻辑非
cpp 复制代码 
int a = 1, b = 0;
int result = (a && b); // result = 0 (false)
result = (a || b);     // result = 1 (true)
result = !a;           // result = 0 (false)
4.4 赋值运算符

赋值运算符用于给变量赋值：

  • =：赋值
  • +=：加后赋值
  • -=：减后赋值
  • *=：乘后赋值
  • /=：除后赋值
  • %=：模后赋值
cpp 复制代码 
int a = 10;
a += 5;  // a = 15
a -= 3;  // a = 12
a *= 2;  // a = 24
a /= 4;  // a = 6
a %= 4;  // a = 2
4.5 位运算符

位运算符用于操作二进制位：

  • &：按位与
  • |：按位或
  • ^：按位异或
  • ~：按位取反
  • <<：左移
  • >>：右移
cpp 复制代码 
int a = 5, b = 3; // a = 0101, b = 0011
int result = a & b; // result = 0001 (1)
result = a | b;     // result = 0111 (7)
result = a ^ b;     // result = 0110 (6)
result = ~a;        // result = 11111111111111111111111111111010 (-6)
result = a << 1;    // result = 1010 (10)
result = a >> 1;    // result = 0010 (2)
4.6 其他运算符
  • ? :：三元运算符
cpp 复制代码 
int a = 10, b = 20;
int max = (a > b) ? a : b; // max = 20
运算符 描述
+, -, *, /, % 算术运算符
==, !=, >, <, >=, <= 关系运算符
&&,
=, +=, -=, *=, /=, %= 赋值运算符
&, , ^, ~, <<, >>
? : 三元运算符
4.7 综合示例
cpp 复制代码 
#include <stdio.h>

int main() {
    int a = 10, b = 20;
    int sum = a + b;
    int diff = a - b;
    int prod = a * b;
    int quot = a / b;
    int mod = a % b;

    if (a > b) {
        printf("a is greater than b\n");
    } else {
        printf("a is not greater than b\n");
    }

    int max = (a > b) ? a : b;
    printf("The maximum value is: %d\n", max);

    return 0;
}

5. 控制结构

5.1 条件语句
5.1.1 if语句
cpp 复制代码 
int x = 5;
if (x > 0) {
    printf("x is positive\n");
}
5.1.2 if-else语句
cpp 复制代码 
int x = -5;
if (x > 0) {
    printf("x is positive\n");
} else {
    printf("x is non-positive\n");
}
5.1.3 switch语句
cpp 复制代码 
int day = 3;
switch (day) {
    case 1:
        printf("Monday\n");
        break;
    case 2:
        printf("Tuesday\n");
        break;
    case 3:
        printf("Wednesday\n");
        break;
    default:
        printf("Invalid day\n");
}
5.2 循环语句

循环语句允许重复执行某段代码，直到满足特定条件。C语言支持三种主要的循环语句：for循环、while循环和do-while循环。

5.2.1 for循环

for循环通常用于需要明确知道循环次数的场景。

cpp 复制代码 
for (int i = 0; i < 5; i++) {
    printf("i = %d\n", i);
}
  • 初始化：int i = 0，在循环开始前执行。
  • 条件：i < 5，在每次循环前检查，如果条件为真，则执行循环体。
  • 迭代：i++，在每次循环结束后执行。
5.2.2 while循环

while循环在每次迭代前检查条件，如果条件为真，则执行循环体。

cpp 复制代码 
int i = 0;
while (i < 5) {
    printf("i = %d\n", i);
    i++;
}
5.2.3 do-while循环

do-while循环先执行循环体，然后再检查条件。如果条件为真，则继续循环。

cpp 复制代码 
int i = 0;
do {
    printf("i = %d\n", i);
    i++;
} while (i < 5);
循环类型 描述
for 适用于已知循环次数的情况
while 适用于循环次数不确定，但需要在每次迭代前检查条件的情况
do-while 适用于至少需要执行一次循环体的情况
5.3 跳转语句

跳转语句用于改变程序的执行流程。C语言支持以下跳转语句：break、continue和goto。

5.3.1 break

break语句用于立即退出循环或switch语句。

cpp 复制代码 
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    printf("i = %d\n", i);
}
5.3.2 continue

continue语句用于跳过当前迭代，继续下一次循环。

cpp 复制代码 
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue;
    }
    printf("i = %d\n", i);
}
5.3.3 goto

goto语句用于无条件跳转到程序中的指定标签。应谨慎使用goto，因为它可能导致代码难以理解和维护。

cpp 复制代码 
int i = 0;
start:
printf("i = %d\n", i);
i++;
if (i < 5) {
    goto start;
}
跳转语句 描述
break 立即退出循环或switch语句
continue 跳过当前迭代，继续下一次循环
goto 无条件跳转到指定标签
5.4 综合示例
cpp 复制代码 
#include <stdio.h>

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

    // while 循环示例
    int j = 0;
    while (j < 5) {
        printf("while loop: j = %d\n", j);
        j++;
    }

    // do-while 循环示例
    int k = 0;
    do {
        printf("do-while loop: k = %d\n", k);
        k++;
    } while (k < 5);

    // break 和 continue 示例
    for (int l = 0; l < 10; l++) {
        if (l == 5) {
            break; // 退出循环
        }
        if (l % 2 == 0) {
            continue; // 跳过当前迭代
        }
        printf("break and continue: l = %d\n", l);
    }

    return 0;
}

6. 函数

函数是组织代码的一种方式，能够提高代码的重用性和可读性。C语言中的函数包括函数定义和函数声明。

6.1 函数的定义和声明

函数定义包括函数的返回类型、函数名、参数列表和函数体。函数声明则是在函数使用前声明其类型和参数。

cpp 复制代码 
// 函数声明
int add(int x, int y);

// 函数定义
int add(int x, int y) {
    return x + y;
}

int main() {
    int result = add(3, 4);
    printf("Result: %d\n", result);
    return 0;
}
6.2 函数参数和返回值

函数可以接受参数并返回值。参数在函数定义时指定，调用时传递。

cpp 复制代码 
int multiply(int a, int b) {
    return a * b;
}

int main() {
    int result = multiply(5, 6);
    printf("Result: %d\n", result);
    return 0;
}
6.3 递归函数

递归函数是指一个函数在其定义中调用自身。递归需要一个终止条件，否则会导致无限递归。

java 复制代码 
int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int result = factorial(5);
    printf("Factorial: %d\n", result);
    return 0;
}
6.4 函数指针

函数指针是指向函数的指针，可以用来调用函数。

cpp 复制代码 
#include <stdio.h>

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

int main() {
    int (*func_ptr)(int, int) = add;
    int result = func_ptr(3, 4);
    printf("Result: %d\n", result);
    return 0;
}
函数类型 描述
普通函数 定义和声明函数，接受参数并返回值
递归函数 在函数定义中调用自身
函数指针 指向函数的指针，用于调用函数
6.5 综合示例
cpp 复制代码 
#include <stdio.h>

// 函数声明
int add(int x, int y);
int multiply(int a, int b);
int factorial(int n);

// 函数定义
int add(int x, int y) {
    return x + y;
}

int multiply(int a, int b) {
    return a * b;
}

int factorial(int n) {
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

int main() {
    int sum = add(3, 4);
    int product = multiply(5, 6);
    int fact = factorial(5);

    printf("Sum: %d\n", sum);
    printf("Product: %d\n", product);
    printf("Factorial: %d\n", fact);

    // 函数指针
    int (*func_ptr)(int, int) = add;
    int result = func_ptr(7, 8);
    printf("Function pointer result: %d\n", result);

    return 0;
}

7. 数组

数组是存储相同类型数据的集合。C语言支持一维数组和多维数组。

7.1 一维数组

一维数组是最简单的数组形式，用于存储一组相同类型的数据。

cpp 复制代码 
int arr[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
    printf("arr[%d] = %d\n", i, arr[i]);
}
7.2 多维数组

多维数组是数组的数组，可以用于存储更复杂的数据结构。

cpp 复制代码 
int matrix[2][3] = {
    {1, 2, 3},
    {4, 5, 6}
};

for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);
    }
}
7.3 字符串（字符数组）

字符串在C语言中表示为字符数组，以空字符\0结尾。

cpp 复制代码 
char str[] = "Hello, World!";
printf("%s\n", str);
7.4 数组与指针的关系

数组名实际上是一个指向数组首元素的指针。

cpp 复制代码 
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;  // 数组名即为数组首元素的地址
for (int i = 0; i < 5; i++) {
    printf("arr[%d] = %d, *(p + %d) = %d\n", i, arr[i], i, *(p + i));
}
数组类型 描述
一维数组 存储一组相同类型的数据
多维数组 数组的数组，用于存储更复杂的数据结构
字符串 字符数组，以空字符\0结尾
数组与指针 数组名是指向数组首元素的指针
7.5 综合示例
cpp 复制代码 
#include <stdio.h>

int main() {
    // 一维数组示例
    int arr[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    // 多维数组示例
    int matrix[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);
        }
    }

    // 字符串示例
    char str[] = "Hello, World!";
    printf("%s\n", str);

    // 数组与指针的关系示例
    int *p = arr;  // 数组名即为数组首元素的地址
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d, *(p + %d) = %d\n", i, arr[i], i, *(p + i));
    }

    return 0;
}

8. 指针

指针是C语言中非常重要的概念，用于存储变量的地址。指针的灵活性和强大功能使其在C语言编程中广泛应用。

8.1 指针的基本概念

指针是一个变量，其值为另一个变量的地址。

cpp 复制代码 
int a = 10;
int *p = &a;  // p是一个指针，存储了变量a的地址
printf("a = %d, *p = %d\n", a, *p);  // *p表示指针p指向的变量的值
8.2 指针的声明和初始化

指针的声明和初始化如下：

cpp 复制代码 
int a = 10;
int *p = &a;  // 声明一个指向int类型的指针，并初始化为变量a的地址
8.3 指针运算

指针可以进行加减运算和比较运算。

  • 指针加减运算
cpp 复制代码 
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;
p = p + 2;  // 指针指向第三个元素
printf("*p = %d\n", *p);  // 输出3
  • 指针比较运算
cpp 复制代码 
int *p1 = arr;
int *p2 = arr + 2;
if (p1 < p2) {
    printf("p1 points to an earlier element than p2\n");
}
8.4 指针与数组

指针和数组有着密切的关系，数组名实际上是一个指向数组首元素的指针。

cpp 复制代码 
int arr[5] = {1, 2, 3, 4, 5};
int *p = arr;  // 数组名即为数组首元素的地址
for (int i = 0; i < 5; i++) {
    printf("arr[%d] = %d, *(p + %d) = %d\n", i, arr[i], i, *(p + i));
}
8.5 函数中的指针参数

指针可以作为函数参数传递，允许函数修改调用者的变量。

cpp 复制代码 
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);  // 输出x = 20, y = 10
    return 0;
}
8.6 指向指针的指针

指针不仅可以指向普通变量，还可以指向其他指针。

cpp 复制代码 
int a = 10;
int *p = &a;
int **pp = &p;  // pp是一个指向指针p的指针
printf("a = %d, *p = %d, **pp = %d\n", a, *p, **pp);
8.7 动态内存分配

C语言提供了一组函数用于动态分配和释放内存。

  • malloc：分配指定字节数的内存
  • calloc：分配指定数量的内存块，并初始化为零
  • realloc：重新分配内存
  • free：释放内存
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

int main() {
    // 使用malloc分配内存
    int *arr = (int *)malloc(5 * sizeof(int));
    if (arr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }

    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }

    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    // 释放内存
    free(arr);

    return 0;
}
指针类型 描述
普通指针 存储变量的地址
指向指针的指针 存储指针的地址
动态内存分配 使用malloc, calloc, realloc, free进行内
8.8 综合示例
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 函数声明
void swap(int *a, int *b);

int main() {
    // 指针基本操作
    int a = 10;
    int *p = &a;
    printf("a = %d, *p = %d\n", a, *p);

    // 指针运算
    int arr[5] = {1, 2, 3, 4, 5};
    p = arr;
    for (int i = 0; i < 5; i++) {
        printf("arr[%d] = %d, *(p + %d) = %d\n", i, arr[i], i, *(p + i));
    }

    // 函数中的指针参数
    int x = 10, y = 20;
    swap(&x, &y);
    printf("x = %d, y = %d\n", x, y);

    // 指向指针的指针
    int **pp = &p;
    printf("a = %d, *p = %d, **pp = %d\n", a, *p, **pp);

    // 动态内存分配
    int *dynamicArr = (int *)malloc(5 * sizeof(int));
    if (dynamicArr == NULL) {
        printf("Memory allocation failed\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        dynamicArr[i] = i + 1;
    }
    for (int i = 0; i < 5; i++) {
        printf("dynamicArr[%d] = %d\n", i, dynamicArr[i]);
    }
    free(dynamicArr);

    return 0;
}

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

结论

本文详细介绍了C语言的基础知识，从基本语法、变量、控制结构、函数、数组一直到指针。通过代码示例和表格总结，帮助你更好地理解各个知识点。希望这些内容能够为你打下坚实的基础，进一步深入学习C语言。

综合示例

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>

// 函数声明
// add 函数用于返回两个整数的和
int add(int x, int y);

// swap 函数用于交换两个整数的值
void swap(int *a, int *b);

// factorial 函数用于计算一个整数的阶乘
int factorial(int n);

// printArray 函数用于打印数组的内容
void printArray(int *arr, int size);

// initializeMatrix 函数用于初始化一个2x3的矩阵
void initializeMatrix(int matrix[2][3]);

int main() {
    // 基本数据类型和变量
    int a = 10;          // 整型变量
    float b = 5.5;       // 浮点型变量
    char c = 'A';        // 字符型变量
    const int MAX = 100; // 常量，值不可改变

    // 算术运算符和关系运算符的使用
    int sum = add(a, 5); // 调用 add 函数计算 a 和 5 的和
    if (sum > MAX) {     // 使用关系运算符比较 sum 和 MAX
        printf("Sum is greater than MAX\n");
    } else {
        printf("Sum is less than or equal to MAX\n");
    }

    // 逻辑运算符
    if (a > 0 && b > 0) { // 使用逻辑运算符检查 a 和 b 是否都为正数
        printf("a and b are positive\n");
    }

    // 控制结构
    // 条件语句
    if (a > 0) {                   // if 语句检查条件是否为真
        printf("a is positive\n");
    } else if (a == 0) {           // else if 语句检查另一个条件
        printf("a is zero\n");
    } else {                       // else 语句处理所有其他情况
        printf("a is negative\n");
    }

    // switch 语句
    switch (c) {                   // 根据变量 c 的值执行相应的 case 语句
        case 'A':
            printf("Character is A\n");
            break;                 // break 语句用于退出 switch 语句
        case 'B':
            printf("Character is B\n");
            break;
        default:                   // default 语句处理所有未匹配的情况
            printf("Character is not A or B\n");
    }

    // 循环语句
    // for 循环
    for (int i = 0; i < 5; i++) {  // for 循环用于重复执行代码块，直到条件为假
        printf("for loop: i = %d\n", i);
    }

    // while 循环
    int j = 0;
    while (j < 5) {                // while 循环在每次迭代前检查条件
        printf("while loop: j = %d\n", j);
        j++;
    }

    // do-while 循环
    int k = 0;
    do {                           // do-while 循环先执行代码块，然后检查条件
        printf("do-while loop: k = %d\n", k);
        k++;
    } while (k < 5);

    // 跳转语句
    for (int l = 0; l < 10; l++) {
        if (l == 5) {
            break; // 退出循环
        }
        if (l % 2 == 0) {
            continue; // 跳过当前迭代
        }
        printf("break and continue: l = %d\n", l);
    }

    // 数组和指针
    int arr[5] = {1, 2, 3, 4, 5};  // 定义一个包含5个整数的一维数组
    printArray(arr, 5);            // 调用 printArray 函数打印数组内容

    // 函数中的指针参数
    int x = 10, y = 20;
    swap(&x, &y);                  // 调用 swap 函数交换 x 和 y 的值
    printf("After swap: x = %d, y = %d\n", x, y);

    // 递归函数
    int fact = factorial(5);       // 调用 factorial 函数计算 5 的阶乘
    printf("Factorial of 5: %d\n", fact);

    // 多维数组
    int matrix[2][3];              // 定义一个2x3的二维数组
    initializeMatrix(matrix);      // 调用 initializeMatrix 函数初始化矩阵
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            printf("matrix[%d][%d] = %d\n", i, j, matrix[i][j]);
        }
    }

    // 字符串
    char str[] = "Hello, World!";  // 定义一个字符串（字符数组）
    printf("%s\n", str);

    // 动态内存分配
    int *dynamicArr = (int *)malloc(5 * sizeof(int)); // 使用 malloc 分配内存
    if (dynamicArr == NULL) {       // 检查内存分配是否成功
        printf("Memory allocation failed\n");
        return 1;
    }
    for (int i = 0; i < 5; i++) {
        dynamicArr[i] = i + 1;      // 初始化动态数组
    }
    printArray(dynamicArr, 5);      // 打印动态数组内容
    free(dynamicArr);               // 释放动态分配的内存

    return 0;
}

// 函数定义
int add(int x, int y) {
    // 返回两个整数的和
    return x + y;
}

void swap(int *a, int *b) {
    // 交换两个整数的值
    int temp = *a;
    *a = *b;
    *b = temp;
}

int factorial(int n) {
    // 递归计算整数 n 的阶乘
    if (n == 0) {
        return 1;
    }
    return n * factorial(n - 1);
}

void printArray(int *arr, int size) {
    // 打印数组的内容
    for (int i = 0; i < size; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }
}

void initializeMatrix(int matrix[2][3]) {
    // 初始化一个2x3的矩阵
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            matrix[i][j] = i * 3 + j + 1; // 按顺序赋值
        }
    }
}

相关推荐
南东山人4 分钟前
python问题解决-外部模块明明安装了，却总是无法找到
开发语言·python
ThetaarSofVenice16 分钟前
【Java从入门到放弃 之 Java程序基础】
java·开发语言·python
夏子曦24 分钟前
java——Tomcat调优策略
java·开发语言·tomcat
In 202932 分钟前
矩阵【Lecode_HOT100】
java·算法·矩阵
qystca34 分钟前
洛谷 P1722 矩阵 II C语言 记忆化搜索
算法
ashane131436 分钟前
回溯算法实现矩阵最小权重路径-Java版本
线性代数·算法·矩阵
会编程的果子君1 小时前
Python语法基础（一）
开发语言·python·html
重生之我在字节当程序员1 小时前
c++中的lambda表达式！
开发语言·c++
zz40_1 小时前
C++ 多态作业练习
c++·算法
ᝰꫝꪉꪯꫀ3611 小时前
JavaWeb——Mybatis
java·开发语言·后端·mybatis
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02玄机平台应急响应—webshell查杀03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【软考经验分享】软考-中级-嵌入式备考05Docker 夺命连环 15 问06PyTorch机器学习实现液态神经网络0704 - matlab m_map地学绘图工具基础函数 - 设置网格08支付宝短视频平台创作分成激励项目09RAG 实践- Ollama+RagFlow 部署本地知识库10基于微信小程序的自习室预约系统的设计与实现