好学近乎知o
好学近乎知o

Linux C的一些经典问题

1.什么是嵌入式

嵌入式就是在已有的硬件平台上移植了操作系统，降低软硬件之间的耦合度，移植性高；使开发者无需考虑硬件结构参与项目，通过操作系统提供的API就可以完成大部分工作，提高了产品的开发效率,提高了用户体验率。

2.什么样的操作系统可以做为嵌入式操作系统？

嵌入式操作系统？
就是一种用途广泛的系统软件；负责系统全部的软硬件资源分配，任务管理，控制协调各个进程；使软硬件之间的耦合度降低，使其依赖于一个不变的体系；将软硬件分离开来，推动项目进度，提高产品的开发效率。

(1)可移植性强的，但不一定开源；
（2）强实时性
（3）统一的接口
（4）操作方便
（5）轻量级
（6）可定制

3.运行时语言 vs 解释语言 vs 静态语言

运行时语言 ：编译出来的可执行文件是直接可以被识别执行的，不需要第三方插入的。
解释语言：运行时解释给第三方，第三方再去做操作。（shell脚本、java、python）
静态语言 ：编译时已经固定好了，不需要做太多变化。（fpga）

4.C语言特点

C语言是一种广泛使用的编程语言，具有许多特点和优势。以下是C语言的主要特点：

  1. 简洁而高效： C语言设计简洁，语法相对简单，易于学习和使用。它直接映射到机器代码，执行效率高，适合开发性能要求较高的应用。
  2. 面向过程： C语言是一种面向过程的编程语言，注重函数和过程的设计。它支持模块化编程，使代码更易于组织和维护。
  3. 系统级编程： C语言广泛用于系统级编程和操作系统开发。它允许直接访问内存和硬件，提供了对计算机底层的强大控制能力。
  4. 可移植性： C语言的标准化使得大部分C代码可以在不同的平台和操作系统上运行，只需要进行少量的修改。
  5. 大量库支持： C语言拥有丰富的标准库和第三方库，提供了各种功能的函数和工具，方便开发人员快速构建应用。
  6. 指针： C语言支持指针，允许直接访问内存地址，使得底层操作更加灵活和高效。
  7. 低级控制： C语言提供了对计算机硬件的底层控制，如位操作和直接访问寄存器，适用于嵌入式开发和驱动程序编写。
  8. 广泛应用： C语言广泛应用于系统软件、嵌入式系统、游戏开发、网络编程等多个领域。
  9. 可扩展性： C语言可以通过调用汇编语言或与其他高级语言混合编程，实现更高级的功能和性能优化。

尽管C语言具有许多优势，但也有一些不足之处，如没有内置的面向对象编程特性，相对较弱的动态内存管理等。然而，由于其简洁、高效和可移植性，C语言仍然是许多编程领域的首选语言之一。

5.C语言的语法标准有哪些？

最早的C语言标准有ANSI/C89/C90，由美国国家标准协会（ANSI）于1989年和1990年发布。它定义了C语言的基本语法和功能，并成为后续标准的基础。这个标准通常被称为"ANSI C"或"C89/C90"。

国际标准化组织(ISO)发布的C99标准，C99标准增加了一些新的功能，如变长数组、内联函数、bool类型和复数支持等。

C11： C11是C语言的最新标准，于2011年发布。C11标准在C99的基础上进行了扩展，增加了一些新的特性，如泛型选择、多线程支持和_Atomic关键字等。

6.编译器有哪些?

编译器是一种将高级语言（如C、C++等）代码转换为目标代码（通常是机器码）的软件工具。它将程序员编写的源代码转换成计算机可以执行的指令，从而使得程序能够在计算机上运行。

“GCC”（GNU Compiler Collection）是一个开源的编译器集合，由GNU计划开发。GCC最初是为C语言编写的，但后来扩展到支持多种编程语言，包括C++、Objective-C、Fortran、Ada等。GCC是一个功能强大且广泛使用的编译器，支持多种平台，如Linux、macOS、Windows等。

"Clang"是LLVM项目的一部分，作为LLVM的编译器前端，用于C、C++、Objective-C和Objective-C++编程语言。Clang的目标是提供更快的编译速度、更好的错误信息和更严格的代码检查。它也成为了流行的C/C++编译器之一。

除了GCC和Clang，还有其他编译器，如Microsoft Visual C++编译器（Windows平台）、Intel C++编译器、Oracle Solaris Studio编译器等。每个编译器都有其独特的特点和优势，选择合适的编译器取决于项目的需求、目标平台和开发人员的偏好。

PS:Visual Studio（VS）是一个集成开发环境（IDE），不是一个单独的编译器。 它包含了多种编程语言的编译器和其他开发工具。

7.C语言的数据类型有哪些？

C语言具有多种数据类型，可以分为基本数据类型和复合数据类型。

基本数据类型：

  1. 整数类型：
    • char：字符类型，通常用于表示单个字符。
    • int：整数类型，通常占用4个字节（取决于编译器和平台）。
    • short：短整数类型，通常占用2个字节。
    • long：长整数类型，通常占用4个字节或8个字节。
  2. 浮点类型：
    • float：单精度浮点类型，通常占用4个字节。
    • double：双精度浮点类型，通常占用8个字节。
  3. 布尔类型：
    • _Bool：布尔类型，表示逻辑值，可以是true或false（0或非零值）。
  4. 空类型：
    • void：空类型，通常用于函数返回类型或指针类型。

复合数据类型：

  1. 数组： 一组具有相同数据类型的元素的有序集合。
  2. 结构体： 自定义数据类型，可以包含不同数据类型的成员。
  3. 枚举： 定义一组相关的常量值。

指针类型：
指针是一种特殊的数据类型，用于存储变量的内存地址。可以用指针来间接访问变量的值。

C语言的数据类型可以根据不同编译器和平台有所不同，但上述是C语言中的常见数据类型。在使用这些数据类型时，开发人员需要根据项目需求和变量的特性来选择适当的数据类型。

8.补码的作用

补码（Two’s complement）在计算机中有着重要的作用，特别是在处理带符号整数时。补码是一种表示有符号整数的方法，它解决了使用原码或反码表示带符号整数时出现的一些问题。

作为计算机中表示带符号整数的标准方法，补码有以下几个重要的作用：

表示负数： 补码能够简洁有效地表示负数。在补码表示中，最高位（最左边的位）为符号位，为1表示负数，为0表示非负数（包括0）。这使得计算机可以处理负数和非负数的整数运算。

无需额外操作： 在补码表示中，负数的表示方式和正数基本一致，无需对符号位进行特殊处理。这简化了计算机硬件的设计和运算逻辑，使得计算机可以使用相同的算术运算器来处理正数和负数。

运算方便： 补码可以简化整数的加法和减法运算。在补码中，负数的加法变成了减法操作，即两个数的补码相加后，如果产生了进位，可以将进位丢弃，最后结果就是两个数的差的补码。

表示范围： 使用n位补码，可以表示-2^(n-1) 到 2^(n-1) - 1的整数范围。例如，使用8位补码可以表示整数范围为-128到127。

总体来说，补码在计算机中提供了一种有效的表示带符号整数的方法，并简化了带符号整数的运算和处理。它是计算机硬件和软件中表示和操作带符号整数的基础。

9.sizeof()和strlen()的区别

sizeof()和strlen()是C语言中两个不同的函数，它们分别用于获取变量或数据的大小和计算字符串的长度。它们的区别如下：

  1. sizeof()：
    sizeof()是一个编译时运算符，而不是函数。它用于获取指定数据类型或变量所占用的字节数。它在编译时执行，返回一个常量值，不需要执行时计算。可以用于任何数据类型、变量、结构体等。

    示例：

    int num = 10;
size_t size = sizeof(num); // size将是整数类型的字节数，通常是4

  2. strlen()：
    strlen()是一个函数，用于计算C风格字符串的长度，即字符串中的字符数（不包括空字符’\0’）。它在运行时执行，需要遍历整个字符串才能确定长度。

    示例：

    char str[] = "Hello, World!";
size_t length = strlen(str); // length将是字符串的长度，不包括空字符，为12

请注意，sizeof()返回的是数据类型或变量占用的字节数，而strlen()返回的是字符串的实际长度。在使用这两个操作时，需要注意它们的不同用途和返回结果类型。而且，strlen()要求字符串必须以空字符’\0’结尾，否则可能导致不正确的结果。在处理字符串时，务必注意字符串的结尾字符。

10.C语言的内存空间布局，Linux内存空间布局

C语言的内存空间布局通常包括以下几个部分：

  1. 代码段（Text Segment）： 也称为只读段，用于存储程序的机器码。这个部分是存放编译后的可执行代码，通常是只读的，不允许对其进行写操作。
  2. 数据段（Data Segment）： 用于存储全局变量和静态变量。这些变量在程序执行过程中保持存在，其值在程序运行期间可以修改。
  3. 堆（Heap）： 堆是动态分配的内存区域，用于存储动态分配的内存。在C语言中，使用malloc()、calloc()等函数从堆中分配内存。程序员需要手动管理堆中的内存，确保在不需要时及时释放。
  4. 栈（Stack）： 栈是用于函数调用和局部变量存储的一种内存区域。每当调用一个函数时，函数的局部变量和返回地址都会被压入栈中，当函数执行完毕后会自动从栈中弹出。
  5. 命令行参数和环境变量： 用于存储程序运行时传递的命令行参数和环境变量。

关于Linux操作系统的内存空间，它涉及更广泛的概念：

  1. 内核空间（Kernel Space）： 内核空间是操作系统内核运行的区域，它拥有对整个系统的完全访问权限，可以直接访问硬件设备和底层资源。
  2. 用户空间（User Space）： 用户空间是应用程序运行的区域，应用程序在用户空间执行，不能直接访问硬件资源，必须通过操作系统提供的系统调用来访问内核空间。

Linux采用虚拟地址空间，将不同的内存区域隔离开来，每个进程都有自己的用户空间，进程间不会互相干扰。用户空间和内核空间是相互独立的。

在Linux中，用户空间和内核空间是相互独立的，它们各自占用不同的虚拟内存地址范围。具体的大小可以根据不同的系统架构和配置而有所不同。

通常情况下，Linux的虚拟内存空间被划分如下：

  1. 用户空间（User Space）：在32位Linux系统中，用户空间的大小通常为3GB，即从0x00000000到0xBFFFFFFF。在64位Linux系统中，用户空间的大小通常为128TB，即从0x0000000000000000到0x00007FFFFFFFFFFF。
  2. 内核空间（Kernel Space）：内核空间是由操作系统内核使用的区域，它具有对整个系统硬件和资源的完全访问权限。在32位Linux系统中，内核空间的大小通常是1GB，即从0xC0000000到0xFFFFFFFF。在64位Linux系统中，内核空间通常会更大。

需要注意的是，这些大小可以通过内核的配置选项进行修改，具体的数值可能会因Linux版本、系统架构和配置而有所不同。因此，在实际应用中，建议使用操作系统提供的宏或函数（如PAGE_SIZE、getrlimit等）来动态获取用户空间和内核空间的大小，而不是依赖于固定的数值。

区别：

  • C语言的内存空间布局指的是在单个进程的内存中，用于存储代码、数据、堆、栈等的不同区域。它主要关注一个进程内存的组织结构和使用方式。
  • Linux操作系统的内存空间指的是整个操作系统内存的划分，将用户空间和内核空间进行了隔离。用户空间用于运行用户程序，而内核空间用于操作系统内核运行和管理。操作系统通过虚拟内存技术将不同的内存区域映射到物理内存中，从而实现进程之间的隔离和保护。

11.局部变量和全局变量

局部变量：

  1. 声明在函数内部或代码块内部：局部变量只能在声明它的函数内部或代码块内部使用，函数外部无法访问它。
  2. 生命周期：局部变量在其所属的函数或代码块执行期间存在，当函数或代码块执行完毕时，局部变量的内存将被释放，其值将不再有效。
  3. 作用域：局部变量的作用域是从声明它的位置开始，到其所属函数或代码块的结束。它只在所属范围内可见，超出范围后无效。
  4. 初始值：局部变量在声明时不会自动初始化，它的值是不确定的，除非在声明时进行了初始化。

全局变量：

  1. 声明在函数外部或文件顶部：全局变量是在函数外部或文件的顶部声明的，因此在整个文件中都可见。
  2. 生命周期：全局变量在程序运行期间始终存在，直到程序结束才会被销毁，其值持久保存。
  3. 作用域：全局变量的作用域是整个文件，因此可以在文件中的任何函数中访问和修改它。
  4. 初始值：全局变量在声明时如果没有显式初始化，将被自动初始化为零或空值（对于静态全局变量和外部链接的全局变量）。

静态局部变量：

静态局部变量是在函数内部声明的一种特殊类型的变量。与普通的局部变量不同，静态局部变量在函数执行结束后并不会被销毁，其值在函数调用之间保持不变。在C语言中，使用static关键字可以将局部变量声明为静态局部变量。

静态局部变量的主要特点和用途如下：

  1. 生命周期延长： 静态局部变量的生命周期超出了其所属函数的执行范围。它在函数第一次执行时被初始化，并在后续的函数调用中保持其值。这意味着，静态局部变量在函数调用之间保持状态，可以记录函数之间的状态信息。
  2. 保持值的持久性： 静态局部变量的值在函数调用之间保持不变。这使得静态局部变量非常适合用于需要保留历史数据的场景，例如计数器、累加器或缓存数据等。
  3. 初始化一次： 静态局部变量只在第一次函数执行时进行初始化，之后的函数调用将保持其值。如果未显式初始化静态局部变量，它将被自动初始化为零（对于数字类型）或空（对于指针类型）。
  4. 局部可见性： 静态局部变量的作用域仍然是局部的，只在声明它的函数内部可见。这使得静态局部变量不会与其他函数的变量产生命名冲突。

全局变量和局部变量的比较：

  • 全局变量具有全局可见性，可以被整个文件中的任何函数访问和修改，但容易引起命名冲突和不必要的耦合。因此，在使用全局变量时，应该避免滥用，只在确实需要全局共享状态时使用。
  • 局部变量具有局部作用域，只在声明它的函数内部可见，更加安全，不容易被其他函数意外修改。使用局部变量可以提高代码的可维护性和可读性，因为变量的作用范围更加明确。

12.static关键字的作用

在C语言中，static关键字具有不同的作用，它可以用于不同的上下文中，包括局部变量、全局变量、函数和函数参数。以下是static关键字的主要作用：

  1. 静态局部变量： 当static关键字用于局部变量时，它将变量声明为静态局部变量。静态局部变量的生命周期超出其所属函数的执行范围，它在第一次执行时初始化，并在后续的函数调用中保持其值。

    示例：

    void function() {
    static int count = 0; // 这是一个静态局部变量
    count++;
}

  2. 静态全局变量： 当static关键字用于全局变量时，它将变量声明为静态全局变量。静态全局变量具有文件作用域，只在当前文件中可见，不会与其他文件中同名的全局变量产生冲突。

    示例：

    static int globalVar; // 这是一个静态全局变量

void function() {
    globalVar = 20; // 可以在当前文件的任何函数中使用和修改 globalVar
}

  3. 静态函数： 当static关键字用于函数时，它将函数声明为静态函数。静态函数具有文件作用域，只在当前文件中可见，不会被其他文件调用。

    示例：

    static void helperFunction() {
    // 这是一个静态函数，只在当前文件内可见
}

void main() {
    helperFunction(); // 可以调用静态函数
}

  4. 静态函数参数： 在函数声明时使用static关键字，可以将函数参数声明为静态参数。静态函数参数在函数调用之间保持其值不变，类似于静态局部变量的特性。

    示例：

    void function(static int param) {
    // 这是一个带有静态参数的函数
}

13.extern关键字作用

extern关键字在C语言中有两种主要作用：

  1. 声明外部变量： 在一个文件中使用extern关键字来声明一个在另一个文件中定义的全局变量。这样做是为了告诉编译器，该变量是在其他地方定义的，编译器在当前文件中只是对它的声明，而不会为它分配内存空间。

    示例：

    // File1.c
int globalVar = 10;

// File2.c
extern int globalVar; // 声明在另一个文件中定义的全局变量

    在上述示例中，File2.c中的extern int globalVar;声明了globalVar是在File1.c文件中定义的全局变量。

  2. 声明外部函数： 在一个文件中使用extern关键字来声明一个在另一个文件中定义的函数。这样做是为了告诉编译器，在当前文件中只是对函数的声明，函数的定义在其他文件中。

    示例：

    // File1.c
int add(int a, int b) {
    return a + b;
}

// File2.c
extern int add(int a, int b); // 声明在另一个文件中定义的函数

    在上述示例中，File2.c中的extern int add(int a, int b);声明了add函数是在File1.c文件中定义的。

需要注意的是，extern关键字只是进行变量或函数的声明，并不会为其分配内存或定义函数体。它是为了告诉编译器，在其他地方已经定义了这个变量或函数，当前文件只是对它的声明。这样，在编译时，编译器就知道这些标识符在其他文件中定义，并能正确地链接它们。

14.register关键字

register是C语言中的一个关键字，用于给编译器提供一个提示，建议将指定的变量存储在寄存器中，以便在频繁访问的情况下提高变量的访问速度。然而，需要注意的是，register关键字仅仅是一个建议，编译器是否真正将变量存储在寄存器中取决于编译器的实现和优化策略。在现代编译器中，由于编译器已经具有强大的优化能力，通常不再需要显式使用register关键字。

C++中已经弃用。

15.const

const关键字在C语言中用于创建常量、修饰指针、修饰函数参数、修饰结构体成员等，能够提高程序的安全性和可维护性。合理使用const关键字有助于编写更加健壮和清晰的代码。

1. 常量定义：
const用于定义常量，常量一旦被定义，其值在程序执行过程中不能被修改。常量可以用于表示不变的数值、固定的参数等。

const int MAX_VALUE = 100; // 定义一个常量 MAX_VALUE，并初始化为100
const float PI = 3.14159; // 定义一个常量 PI，并初始化为3.14159

2. 常量指针：
const用于修饰指针，表示指针所指向的值是常量，不能通过该指针修改所指向的值。

int num = 10;
const int* ptr = # // 定义一个指向常量整数的指针
*ptr = 20; // 错误！不能通过ptr修改num的值

3. 指针常量：
const用于修饰指针，表示指针本身是常量，不能修改指针所指向的地址。

int num = 10;
int* const ptr = # // 定义一个指针常量，不可修改ptr的值
*ptr = 20; // 可以通过ptr修改num的值

4. 常量指针常量：
const同时用于修饰指针和指针指向的值，表示指针本身是常量，指针指向的值也是常量，即指针和指针指向的值都不能修改。

const int num = 10;
const int* const ptr = # // 定义一个常量指针常量
*ptr = 20; // 错误！不能通过ptr修改num的值
ptr = &anotherNum; // 错误！不能修改ptr的值

测试

#include 

int main() {
    int num = 10;
    int anotherNum = 100;

    // 指针常量（Pointer to Constant）
    const int* ptrToConst = # // 定义一个指向常量整数的指针常量
    printf("Pointer to Constant:\n");
    printf("*ptrToConst: %d\n", *ptrToConst); // 输出：*ptrToConst: 10
    //*ptrToConst = 20; // 错误！不能通过ptrToConst修改num的值
    ptrToConst = &anotherNum; // 正确！可以修改指针指向的地址
    printf("*ptrToConst after reassignment: %d\n", *ptrToConst); // 输出：*ptrToConst after reassignment: 100
    printf("\n");

    // 常量指针（Constant Pointer）
    int* const constPtr = # // 定义一个常量指针
    printf("Constant Pointer:\n");
    printf("*constPtr: %d\n", *constPtr); // 输出：*constPtr: 10
    *constPtr = 20; // 可以通过constPtr修改num的值
    printf("num after modification: %d\n", num); // 输出：num after modification: 20
    //constPtr = &anotherNum; // 错误！不能修改常量指针的地址
    printf("\n");

    // 常量指针常量（Constant Pointer to Constant）
    const int* const constPtrToConst = # // 定义一个常量指针常量
    printf("Constant Pointer to Constant:\n");
    printf("*constPtrToConst: %d\n", *constPtrToConst); // 输出：*constPtrToConst: 20
    //*constPtrToConst = 30; // 错误！不能通过constPtrToConst修改num的值
    //constPtrToConst = &anotherNum; // 错误！不能修改常量指针的地址
    printf("\n");

    return 0;
}

5. 函数参数中的const：
const用于修饰函数的参数，表示函数内部不会修改该参数的值。这样可以增加函数的安全性和可读性。

void printValue(const int value) {
    printf("Value: %d\n", value);
}

int num = 100;
printValue(num); // 可以传递变量作为参数
printValue(42);  // 也可以传递常量作为参数

6. const与数组：
const用于定义常量数组，这样数组的元素值在程序执行过程中不能被修改。

const int SIZE = 5;
const int arr[SIZE] = {1, 2, 3, 4, 5}; // 定义一个常量数组
arr[0] = 10; // 错误！不能修改数组元素的值

7. const与函数返回值：
const用于修饰函数的返回值，表示函数返回的值是常量。

const int getConstantValue() {
    return 100; // 函数返回一个常量值
}

int num = getConstantValue();
num = 200; // 错误！函数返回值是常量，不能修改

8. const与结构体：
const用于修饰结构体，表示结构体内的成员值是常量，不能修改。

struct Point {
    const int x;
    const int y;
};

struct Point p1 = {1, 2};
p1.x = 10; // 错误！不能修改结构体成员的值

注意事项：

  • const关键字可以用于任何基本数据类型和自定义数据类型（结构体、枚举等）。
  • const定义的常量必须在声明时初始化，且初始化后不能再修改。
  • const定义的常量在编译时即被确定，存储在符号表中，不占用存储空间。
  • 在多文件编程中，若一个全局变量要在多个文件中共享，通常需要在一个文件中定义该全局变量，并在其他文件中使用extern声明，同时可以使用const关键字修饰来防止被修改。
// File1.c
const int MAX_VALUE = 100;

// File2.c
extern const int MAX_VALUE; // 声明在另一个文件中定义的全局常量

16.typedef关键字的作用？（应用场景：函数指针和函数指针数组）

当使用typedef定义函数指针类型和函数指针数组类型时，可以将较为复杂的类型声明简化为更直观的类型别名。下面将给出一个详细的例子来说明这两个用法。

1. 使用typedef定义函数指针类型：

#include 

// 原始的函数指针声明
int (*ptrToFunction)(int, int);

// 使用typedef定义函数指针类型
typedef int (*FunctionPointer)(int, int);

// 定义一个函数，用于加法操作
int add(int a, int b) {
    return a + b;
}

int main() {
    // 使用原始函数指针声明方式
    ptrToFunction = add;
    int result1 = (*ptrToFunction)(5, 3);
    printf("Result 1: %d\n", result1);

    // 使用typedef定义的函数指针类型
    FunctionPointer myFunctionPtr = add;
    int result2 = myFunctionPtr(10, 20);
    printf("Result 2: %d\n", result2);

    return 0;
}

在上述代码中，我们先使用原始的函数指针声明方式int (*ptrToFunction)(int, int);，然后使用typedef定义了一个名为FunctionPointer的函数指针类型。在main函数中，我们分别使用这两种方式声明了函数指针变量，并将其指向了add函数。然后通过两种方式调用函数指针并得到了不同的计算结果。

2. 使用typedef定义函数指针数组类型：

#include 

// 原始的函数指针数组声明
int (*ptrArray[3])(int, int);

// 使用typedef定义函数指针数组类型
typedef int (*FunctionPointer)(int, int);
typedef FunctionPointer FunctionPointerArray[3];

// 定义一些函数，用于加法、减法和乘法操作
int add(int a, int b) {
    return a + b;
}

int subtract(int a, int b) {
    return a - b;
}

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

int main() {
    // 使用原始函数指针数组声明方式
    ptrArray[0] = add;
    ptrArray[1] = subtract;
    ptrArray[2] = multiply;

    // 使用typedef定义的函数指针数组类型
    FunctionPointerArray myFunctionPtrArray = { add, subtract, multiply };

    // 通过循环调用函数指针数组中的函数
    int a = 10, b = 5;
    for (int i = 0; i < 3; i++) {
        int result = ptrArray[i](a, b);
        printf("Result %d: %d\n", i + 1, result);
    }

    printf("\n");

    // 通过循环调用typedef定义的函数指针数组中的函数
    for (int i = 0; i < 3; i++) {
        int result = myFunctionPtrArray[i](a, b);
        printf("Result %d: %d\n", i + 1, result);
    }

    return 0;
}

在上述代码中，我们先使用原始的函数指针数组声明方式int (*ptrArray[3])(int, int);，然后使用typedef定义了一个名为FunctionPointer的函数指针类型和一个名为FunctionPointerArray的函数指针数组类型。在main函数中，我们分别使用这两种方式声明了函数指针数组，并将其指向了add、subtract和multiply三个不同的函数。然后通过循环调用函数指针数组中的函数，得到了不同的计算结果。

通过这两个例子，我们可以看到，使用typedef定义函数指针类型和函数指针数组类型可以使代码更加清晰和简洁，增加了代码的可读性和可维护性。

17.break、continue区别

break和continue是两个用于控制流程的关键字，它们在循环语句中的作用有所不同。

1. break：

break关键字用于立即终止循环（for、while、do-while）的执行，并跳出循环体。当程序执行到break语句时，循环内剩余的代码将不再执行，而是直接跳出整个循环，继续执行循环之后的代码。

for (int i = 1; i <= 10; i++) {
    if (i == 5) {
        break; // 当i等于5时，立即终止循环
    }
    printf("%d ", i);
}
// 输出结果：1 2 3 4

在上述代码中，当i等于5时，break语句被执行，导致循环立即终止，因此只输出了1、2、3、4四个数字。

2. continue：

continue关键字用于跳过循环中余下的代码，直接进入下一次循环的判断条件。当程序执行到continue语句时，循环体中剩余的代码将被跳过，但循环条件会重新进行判断，从而决定是否进行下一次循环迭代。

for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue; // 当i等于3时，跳过循环内的剩余代码，进行下一次循环迭代
    }
    printf("%d ", i);
}
// 输出结果：1 2 4 5

在上述代码中，当i等于3时，continue语句被执行，导致循环内剩余的代码（即printf("%d ", i);）被跳过，直接进入下一次循环的判断条件。因此，输出结果中没有数字3。

总结：

  • break用于立即终止循环，跳出循环体，执行循环之后的代码。
  • continue用于跳过循环内余下的代码，直接进行下一次循环迭代。

18.使用异或交换两个变量的值vs四则运算交换

在C语言中，可以使用异或运算和四则运算来交换两个变量的值。下面分别介绍这两种方法的实现：

1. 使用异或运算交换两个变量的值：

异或运算有一个重要的性质：对于任意整数a和b，有a ^ b ^ b = a，即连续两次异或同一个值会得到原来的值。基于这个性质，可以使用异或运算来交换两个变量的值。

使用异或运算的方法相比使用四则运算的方法更加巧妙，因为它不需要借助额外的临时变量，从而节省了内存空间。

#include 

void swapUsingXOR(int* a, int* b) {
    if (a != b) { // 确保a和b不是同一个地址
        *a = *a ^ *b;
        *b = *a ^ *b;
        *a = *a ^ *b;
    }
}

int main() {
    int x = 10, y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);

    swapUsingXOR(&x, &y);

    printf("After swap: x = %d, y = %d\n", x, y);

    return 0;
}

在上述代码中，swapUsingXOR函数使用异或运算交换两个变量的值。首先，通过*a = *a ^ *b;将a和b的值异或，并将结果保存到a中；然后，通过*b = *a ^ *b;将a和b的值异或，并将结果保存到b中；最后，通过*a = *a ^ *b;将a和b的值异或，并将结果保存到a中，此时a的值就变成了原来b的值，b的值就变成了原来a的值，完成了变量的交换。

2. 使用四则运算交换两个变量的值：

除了使用异或运算，还可以使用四则运算来交换两个变量的值。这种方法需要借助一个临时变量。

#include 

void swapUsingArithmetic(int* a, int* b) {
    if (a != b) { // 确保a和b不是同一个地址
        int temp = *a;
        *a = *b;
        *b = temp;
    }
}

int main() {
    int x = 10, y = 20;
    printf("Before swap: x = %d, y = %d\n", x, y);

    swapUsingArithmetic(&x, &y);

    printf("After swap: x = %d, y = %d\n", x, y);

    return 0;
}

在上述代码中，swapUsingArithmetic函数使用四则运算交换两个变量的值。首先，通过int temp = *a;将a的值保存到一个临时变量temp中；然后，通过*a = *b;将b的值赋给a；最后，通过*b = temp;将临时变量temp的值赋给b，此时a的值就变成了原来b的值，b的值就变成了原来a的值，完成了变量的交换。

19.位运算的作用？

位运算在计算机底层编程、嵌入式开发、算法设计等方面发挥着重要作用。位运算主要是直接操控二进制数时使用 ，主要目的是节约内存，使程序速度更快，还有就是在对内存要求苛刻的地方使用。

20.谈谈你对指针的理解（什么是指针？指针的作用？指针的运算？指针变量的大小为什么是固定大小？为什么会有不同类型的指针？）

指针是用来存储其他变量的内存地址的变量。指针的出现使得程序可以间接地访问和操作内存中的数据，极大地增强了程序的灵活性和效率。

什么是指针？

指针是一个存储其他变量地址的变量。它包含了一个内存地址，指向另一个变量在内存中的存储位置。通过指针，可以间接地访问和修改这个地址所指向的变量的值。指针的类型必须与它所指向的变量类型相匹配。

指针的作用？

  1. 动态内存分配： 使用指针可以在运行时动态地分配内存，这对于创建灵活的数据结构和处理不确定大小的数据非常有用。
  2. 传递参数： 通过指针可以实现函数之间的数据传递，包括传递大型数据结构或多个值。
  3. 数组和字符串操作： 指针与数组紧密相关，通过指针可以遍历数组元素或进行字符串操作。
  4. 指针与函数： 可以使用函数指针来动态选择要调用的函数，从而实现回调功能。
  5. 优化性能： 使用指针可以减少数据的拷贝和传递，提高程序的执行效率。
  6. 数据结构的灵活性： 指针为数据结构提供了灵活性，允许在堆上分配内存并建立动态数据结构，如链表、树等。这些动态数据结构在插入、删除和调整时更加高效。

指针的运算？

指针可以进行一些基本的运算，包括：

  1. 指针加法和减法： 可以对指针进行加法和减法运算，用于访问数组中的元素。
  2. 指针的自增和自减： 可以通过自增和自减运算来遍历数组或链表等数据结构。

指针变量的大小为什么是固定大小？

指针变量的大小在不同的架构和操作系统中是固定的，通常是与系统的寻址能力相关的。在32位系统中，指针的大小通常是4字节（32位），而在64位系统中，指针的大小通常是8字节（64位）。这是因为指针必须能够存储一个完整的内存地址，而内存地址的大小由系统的寻址能力决定。

为什么会有不同类型的指针？

不同类型的指针是为了处理不同类型的数据而存在的。指针的类型必须与它所指向的变量类型相匹配，这样才能正确地访问和操作内存中的数据。例如，指向整数的指针必须是int*类型，指向字符的指针必须是char*类型，指向结构体的指针必须是相应结构体类型的指针等。不同类型的指针可以用于处理各种数据类型，使得程序更加灵活和通用。同时，不同类型的指针也要求开发人员在使用时要注意类型匹配，避免出现潜在的错误。

21.万能指针的作用及注意事项

万能指针（void*）是C语言中一种特殊类型的指针，它可以指向任意类型的数据。由于其灵活性，它被称为"万能指针"。

万能指针可以接受任何指针变量的值，函数的返回值和形参使用万能指针可以提高通配性。使用时要注意不能通过*来获取指向空间。

编程时需要注意以下事项：

1. 无类型指针： void*是一种无类型指针，它没有指向具体类型的信息。因此，在使用万能指针时，必须明确指定其指向的数据类型。

2. 需要显式转换： 由于void*是无类型指针，无法直接进行指针运算和解引用。在使用之前，必须将其转换为特定类型的指针。转换时要确保指向的数据类型与实际数据类型匹配，否则可能导致未定义的行为。

3. 内存泄漏风险： 由于void*丧失了类型信息，容易导致内存泄漏。如果使用void*进行内存分配（例如，使用malloc返回void*），在释放内存时需要注意转换回正确的类型。

4. 潜在错误： 由于万能指针无法提供类型检查，如果误用或不正确地转换指针类型，可能导致程序运行时出现意想不到的错误，如数据错误、段错误等。

5. 慎用万能指针： 虽然万能指针在某些场景下非常有用，但在一般情况下，应该避免频繁使用它。最好使用类型安全的指针，这样可以在编译时进行类型检查，减少错误的发生。

6. 使用场景： 万能指针通常用于处理未知类型的数据或在不同类型之间进行通用的数据传递。在使用万能指针时，最好有充分的理由，并且需要仔细检查类型转换的正确性。

示例：

#include 

int main() {
    int num = 42;
    double pi = 3.14159;

    void* ptr;

    // ptr指向int类型的数据
    ptr = #
    int* intPtr = (int*)ptr; // 转换为int指针
    printf("Value of num: %d\n", *intPtr);

    // ptr指向double类型的数据
    ptr = π
    double* doublePtr = (double*)ptr; // 转换为double指针
    printf("Value of pi: %lf\n", *doublePtr);

    return 0;
}

在上述示例中，我们使用void*指针分别指向int类型和double类型的数据，并在使用前显式转换为相应的指针类型。这个例子展示了void*指针的基本用法。然而，需要特别注意在实际应用中避免滥用万能指针，以确保代码的类型安全性和稳定性。

22.什么是野指针？如何避免野指针？如何检测野指针？

什么是野指针？

野指针是指指向无效内存地址的指针。这种指针指向的内存地址可能是未初始化的、已释放的或者超出了其作用域的，因此访问这个指针指向的内存会导致未定义的行为。野指针通常是由于不正确地使用指针引起的，是一种常见的编程错误。

如何避免野指针？

  1. 初始化指针： 在声明指针变量时，尽量初始化为NULL或者一个有效的内存地址。避免在声明时不给指针赋值，以免产生未知的初始值。
  2. 避免悬空指针： 在指针不再需要时，及时将其赋值为NULL或者释放指向的内存，避免指针悬空。
  3. 注意指针的作用域： 确保指针的作用域不会超出其有效范围。尽量在需要指针的地方声明和使用它，避免在多个函数之间共享指针而引发问题。
  4. 避免指针运算错误： 对指针进行加减运算时，要确保操作后的指针仍指向有效的内存位置。
  5. 慎用动态内存分配： 使用动态内存分配（如malloc、calloc等）时，要确保适时释放内存，并避免产生内存泄漏。

如何检测野指针？

检测野指针是一项重要的防御性编程措施，以及确保程序的安全性和稳定性的手段。可以通过以下方法检测野指针：

  1. NULL检查： 在使用指针前，始终进行NULL检查。在对指针进行解引用操作（如*ptr）之前，先判断指针是否为NULL。如果指针为NULL，说明它是一个野指针。
  2. 指针作用域： 确保指针的作用域在合理的范围内，并在指针不再使用时及时赋值为NULL或释放内存。
  3. 静态代码分析工具： 使用静态代码分析工具可以帮助检测潜在的野指针问题。这些工具能够静态分析代码并找出可能的指针错误。
  4. 运行时检测： 有些调试工具或编程语言提供运行时检测功能，可以检测指针是否超出范围或指向无效内存。
  5. 编程经验和代码审查： 充分的编程经验和代码审查可以帮助发现并修复潜在的野指针问题。

23.memcpy、strcpy、strncpy 和 memmove 函数的整理和区别：

当谈及字符串和内存复制函数时，C语言提供了几个不同的函数，它们有不同的特点和用途。以下是 memcpy、strcpy、strncpy 和 memmove 函数的整理和区别：

1. memcpy：

  • 函数原型：void *memcpy(void *dest, const void *src, size_t n);
  • 功能：将一块内存的内容复制到另一块内存，适用于复制任意类型的数据。
  • 注意事项：不会添加字符串结束符，只是简单地按字节复制数据。要确保源和目标内存块的数据类型匹配。

2. strcpy：

  • 函数原型：char *strcpy(char *dest, const char *src);
  • 功能：将一个以空字符结尾的字符串复制到另一个字符数组中，确保目标数组是以空字符结尾的有效字符串。
  • 注意事项：不会检查目标数组的大小，如果源字符串超过了目标数组的容量，可能会导致缓冲区溢出问题。

3. strncpy：

  • 函数原型：char *strncpy(char *dest, const char *src, size_t n);
  • 功能：将一个字符串的一部分（最多n个字符）复制到目标字符数组中，确保目标数组是以空字符结尾的有效字符串。
  • 注意事项：如果源字符串长度小于n，目标数组的剩余部分将用空字符\0填充。不会自动添加字符串结束符。

4. memmove：

  • 函数原型：void *memmove(void *dest, const void *src, size_t n);
  • 功能：与memcpy类似，也用于内存复制，但可以处理源和目标内存块有重叠的情况。
  • 注意事项：适用于处理可能重叠的内存块，选择合适的复制策略。

使用这些函数时需要注意以下事项：

  • 在使用strcpy、strncpy和memcpy时，要确保目标数组有足够的空间来存储复制的内容，避免缓冲区溢出问题。
  • 在使用strncpy时，需要特别注意源字符串的长度和目标数组的大小，确保目标数组有足够的空间来存储复制的内容。手动添加字符串结束符是一个常见的做法。
  • 在处理可能重叠的内存块时，应该优先考虑使用memmove函数而不是memcpy函数。

24.strtok、strcpsn等特殊字符串处理函数的作用？

特殊字符串处理函数在C语言中用于对字符串进行特定的操作和处理。以下是一些常见的特殊字符串处理函数及它们的作用：

1. strtok：

  • 作用：用于将字符串分割成子字符串。
  • 函数原型：char *strtok(char *str, const char *delim);
  • 用法：第一次调用时传入待分割的字符串str，后续调用传入NULL。delim是一个包含分隔符的字符串，用于指定分隔符。函数会返回一个指向下一个子字符串的指针，当返回NULL时表示没有更多的子字符串。

2. strcspn：

  • 作用：计算字符串开头连续不包含指定字符集中的字符的长度。
  • 函数原型：size_t strcspn(const char *str, const char *reject);
  • 用法：strcspn会从str中查找连续不包含在reject中的字符的长度，并返回这个长度。

3. strspn：

  • 作用：计算字符串开头连续包含指定字符集中的字符的长度。
  • 函数原型：size_t strspn(const char *str, const char *accept);
  • 用法：strspn会从str中查找连续包含在accept中的字符的长度，并返回这个长度。

4. strstr：

  • 作用：在一个字符串中查找子字符串。
  • 函数原型：char *strstr(const char *haystack, const char *needle);
  • 用法：strstr会在haystack字符串中查找needle字符串的第一次出现，并返回指向这个位置的指针。

5. strchr和strrchr：

  • 作用：分别用于在字符串中查找字符的第一次和最后一次出现的位置。
  • 函数原型：char *strchr(const char *str, int c); 和 char *strrchr(const char *str, int c);
  • 用法：strchr查找字符c在str中的第一次出现，并返回指向这个位置的指针；strrchr查找字符c在str中的最后一次出现，并返回指向这个位置的指针。

6. strcmp和strncmp：

  • 作用：用于字符串比较。
  • 函数原型：int strcmp(const char *str1, const char *str2); 和 int strncmp(const char *str1, const char *str2, size_t n);
  • 用法：strcmp用于比较两个字符串是否相等，返回值为0表示相等；strncmp比较两个字符串的前n个字符是否相等，返回值为0表示相等。

7. strlen：

  • 作用：计算字符串的长度，不包括字符串结束符\0。
  • 函数原型：size_t strlen(const char *str);
  • 用法：strlen返回str字符串的字符数，不包括字符串结束符\0。

25.一维数组名的作用？一维数组的地址取值的意义？

一维数组名的作用：

  1. 表示数组的首元素地址：一维数组名实际上是指向数组第一个元素的指针。当使用一维数组名时，它会自动转换为指向数组第一个元素的指针，即数组的首元素地址。
  2. 数组名作为指针常量：在大多数情况下，一维数组名被视为指针常量，即不能再修改数组名的值。例如，arr++; 是非法的，因为数组名 arr 是指针常量，不能被赋值或修改。

一维数组的地址取值的意义：

  1. 获取数组元素的地址：可以通过数组名加上索引来获取特定元素的地址。例如，对于一维数组 int arr[5]，&arr[0]、&arr[1] 等表示数组中不同元素的地址。
  2. 传递整个数组给函数：在函数中，可以通过将数组名作为参数传递，来传递整个数组的地址。通过传递数组的地址，函数可以直接操作数组的内容，而不需要复制整个数组。
  3. 动态内存分配：在动态内存分配中，可以使用数组的地址来获取数组的指针，并根据需要分配内存空间。
  4. 指针运算：数组的地址取值也可以用于进行指针运算，例如将指针向后移动，来遍历数组元素。
int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    printf("Array address: %p\n", &arr);        // 表示整个一维数组 arr 的地址
    printf("Array address: %p\n", arr);        // 数组的首元素地址
    printf("Element 0 address: %p\n", &arr[0]); // 数组第一个元素的地址
    printf("Element 1 address: %p\n", &arr[1]); // 数组第二个元素的地址

    return 0;
}

26.二维数组名的作用？二维数组地址取值的意义？

二维数组名的作用：

  1. 表示整个二维数组的首元素地址： 二维数组名在大多数情况下会被解释为指向整个二维数组的首元素的指针。这个指针类型是 int (*)[n]，其中 n 是数组的第二维大小（列数）。因此，二维数组名代表整个二维数组的起始地址。

二维数组地址取值的意义：

  1. 获取整个二维数组的地址： 使用二维数组名 arr 可以获取整个二维数组 arr 的地址，即数组的首元素地址。这在函数参数传递、动态内存分配等场景中非常有用。

具体来说：


示例：

#include 

int main() {
    int arr[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};

    printf("Array address: %p\n", &arr);      // 整个二维数组的地址
    printf("Array address: %p\n", arr);      // 二维数组的首元素地址
    printf("Array address: %p\n", &arr[0]);      // 二维数组的首元素地址
    printf("Address of first row: %p\n", arr[0]); // 第一行的地址

    return 0;
}

arr 表示整个二维数组的首元素地址：
arr 是一个指向包含 4 个元素的一维数组的指针。在指针运算中，arr + 1 会指向二维数组的下一行，即第二行的首元素地址。

&arr[0] 表示二维数组中的第一行的地址：
&arr[0] 是一个指向包含 4 个元素的一维数组的指针。在指针运算中，&arr[0] + 1 会指向二维数组中的下一行，即第二行的首元素地址。

总结：

  • arr 是指向二维数组中第一行的指针，表示整个二维数组的首元素地址。
  • &arr[0] 是指向二维数组中第一行的地址，它也是一个指向包含 4 个元素的一维数组的指针。

27.数组指针变量的作用？使用场景？

数组指针变量是指向数组的指针，它可以指向一维数组、二维数组或更高维度的数组。数组指针变量的类型取决于它所指向的数组的类型和维度。使用数组指针可以方便地操作数组元素，而无需知道数组的具体维度和大小。

数组指针变量的作用：

  1. 方便数组元素的访问： 数组指针可以通过指针运算来访问数组的元素，不需要使用下标索引。
  2. 作为函数参数： 可以将数组指针作为函数的参数传递，这样可以在函数内部直接访问和修改数组的内容，而无需复制整个数组。
  3. 动态内存分配： 可以使用数组指针来动态分配内存空间，特别适用于多维数组的动态分配。
  4. 处理多维数组： 数组指针可以更方便地处理多维数组，无需指定所有维度的大小。

使用场景：

  • 在函数中传递数组指针作为参数，以便在函数内部直接处理数组。
  • 动态分配多维数组的内存空间。
  • 在处理多维数组时，使用数组指针可以更高效地遍历数组元素。
  • 用于处理不同大小的数组，因为数组指针的类型可以根据指向的数组的类型和维度来灵活适应不同的情况。

示例：

#include 

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

int main() {
    int arr1[5] = {1, 2, 3, 4, 5};
    int arr2[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    int *ptr1 = arr1; // 数组指针指向一维数组
    int (*ptr2)[3] = arr2; // 数组指针指向二维数组的一维数组

    printArray(ptr1, 5); // 通过数组指针传递一维数组
    for (int i = 0; i < 3; i++) {
        printArray(ptr2[i], 3); // 通过数组指针传递二维数组的每个一维数组
    }

    return 0;
}

输出：

1 2 3 4 5 
1 2 3 
4 5 6 
7 8 9

在上面的示例中，ptr1 是指向一维数组 arr1 的数组指针变量，ptr2 是指向二维数组 arr2 的数组指针变量。通过这些数组指针变量，我们可以方便地传递数组给函数并遍历数组的元素。

28.什么是动态数组？什么是零长数组？应用场景？

动态数组：
动态数组是在程序运行时根据需要动态分配内存空间的数组。它的大小可以在运行时确定，并且可以根据实际需求进行动态调整。在 C 语言中，动态数组通常通过使用 malloc、calloc 或 realloc 函数来分配内存空间，并通过 free 函数来释放内存空间。

零长数组：
零长数组是指数组的长度为0的数组。在 C 语言中，零长数组通常用于占位或作为某些数据结构的末尾标志。虽然零长数组本身不占用内存空间，但它通常用于占位，以便在需要时在同一块内存中动态分配实际的数组长度。

应用场景：

  • 动态数组的应用场景主要是在需要根据输入数据的大小动态调整数组大小的情况下。例如，读取用户输入的数据并存储在数组中，但用户可能输入不同大小的数据。
  • 动态数组还可以用于避免固定数组大小带来的内存浪费。如果数组的大小事先不确定，使用动态数组可以节省内存空间。
  • 零长数组通常用于数据结构中的柔性数组成员，这种成员允许在同一块内存中存储不同大小的数据。例如，在动态链表中，可以使用零长数组作为可变长度的数据块。

29.数组的特点

数组是一种具有固定大小、连续存储、相同数据类型和快速访问特性的数据结构。由于其固定大小和连续存储的特点，数组适用于随机访问和有序数据。然而，数组的大小是固定的，无法在运行时动态调整，这可能限制了其灵活性。在需要动态大小的情况下，可以使用动态数组或其他数据结构来替代数组。

数组做指针的注意事项

在 C 语言中，数组名在某些情况下会被隐式地转换为指针，因此需要注意一些与数组和指针相关的细节和注意事项。下面是数组做指针时需要注意的几点：

  1. 数组名是指针常量： 数组名在大多数情况下会被隐式地转换为指向数组首元素的指针，但是数组名本身是一个常量指针，它存储了数组的地址，且不可更改。例如，对于 int arr[5]，arr 表示指向数组 arr 的第一个元素的指针，但不能修改 arr 的值。

  2. 数组名作为函数参数： 当数组作为函数的参数传递时，数组名会退化为指向数组首元素的指针。在函数内部，形参看起来像一个指针变量，并不是数组。因此，函数内部无法获取数组的大小。通常，我们需要通过额外的参数传递数组大小。在函数内部使用 sizeof 运算符来获取数组的大小时，返回的是指针的大小，而不是整个数组的大小

    示例：

    void printArray(int arr[], int size) {
    // 在函数内部，arr 类似于指针 int* arr
    // 无法获取数组的大小，需要额外的参数 size
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    printArray(arr, 5); // 1 2 3 4 5
    return 0;
}

  3. sizeof 运算符与数组名： 在 sizeof 运算符中，数组名会被解释为数组，返回整个数组的字节大小。例如，sizeof(arr) 返回整个数组 arr 的字节大小，而不是指针的大小。

  4. 数组名与指针运算： 数组名可以进行指针运算，如 arr + 1 将得到数组中下一个元素的地址。但要注意，数组名不能被赋值或修改，因为它是一个常量指针。

    示例：

    int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr;  // 数组名被隐式转换为指向数组首元素的指针

// 数组名可以进行指针运算
printf("%d\n", *(ptr + 1)); // 输出 2

// 但是数组名本身不能被赋值或修改
// arr = ptr; // 错误：不能修改数组名 arr

总结：在使用数组做指针时，需要注意数组名是指针常量，无法修改；在函数参数传递中，数组名会退化为指针，无法在函数内部获取数组大小；在 sizeof 运算符中，数组名表示整个数组的字节大小；数组名可以进行指针运算，但本身不能被赋值或修改。理解这些细节有助于避免数组操作中的错误和误解。

30.指针数组、数组指针;使用注意事项、作为参数传递如何定义形参

指针数组和数组指针：

  1. 指针数组：
    • 指针数组是一个数组，其中的每个元素都是指针。
    • 每个指针可以指向不同类型的数据或相同类型的数据，但它们的大小不一定相同。
    • 声明格式：data_type *array_name[size];
  2. 数组指针：
    • 数组指针是一个指针，它指向一个数组。
    • 数组指针的类型取决于指向的数组的类型和维度。
    • 声明格式：data_type (*ptr_name)[size];

使用注意事项：

  1. 在使用指针数组时，需要先为每个指针元素分配内存，否则它们将是野指针，导致未定义的行为。
  2. 数组指针在声明时需要指定指向的数组类型和维度，否则会导致类型不匹配的错误。
  3. 在使用指针数组或数组指针时，务必确保指针不会越界或指向无效的内存地址，以避免访问非法内存导致的问题。
  4. 当数组作为参数传递时，通常使用指针来接收数组，因为数组传递给函数时会退化为指针，这样可以避免发生数组拷贝。

作为参数传递如何定义形参：

  1. 指针数组作为参数：
    • 当将指针数组作为参数传递给函数时，可以使用以下方式定义形参：
      void functionName(data_type *array_name[], int size)
{
    // Function body
}
  2. 数组指针作为参数：
    • 当将数组指针作为参数传递给函数时，可以使用以下方式定义形参：
      void functionName(data_type (*ptr_name)[size], int rows)
{
    // Function body
}

示例：

#include 

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

void print2DArray(int (*arr)[3], int rows) {
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int arr1[5] = {1, 2, 3, 4, 5};
    int arr2[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

    printIntArray(arr1, 5);     // 传递指针数组
    print2DArray(arr2, 3);      // 传递数组指针

    return 0;
}

31.传值与传地址的区别（如何选择）

传值和传地址是在函数调用过程中传递参数的两种方式。它们有不同的特点和适用场景，选择哪种方式取决于需求和性能考虑。

传值（Pass by Value）：

  1. 传值是将实际参数的值拷贝给函数形参，函数中对形参的修改不会影响到实际参数。
  2. 传值对于函数内部的计算不会影响原始数据，适用于简单数据类型或需要保护原始数据的情况。
  3. 传值会在函数调用时创建形参的副本，所以可能会导致内存消耗较大，特别是在传递大型数据结构时。

传地址（Pass by Address，也称为传引用）：

  1. 传地址是将实际参数的地址传递给函数形参，函数中对形参的修改会影响到实际参数。
  2. 传地址适用于需要在函数中修改原始数据的情况，可以避免拷贝大量数据而带来的内存开销。
  3. 传地址避免了在函数调用时复制数据，因此效率较高。但需要注意，如果在函数内部不小心修改了地址指向的内容，可能会影响到其他部分的代码。

选择使用传值还是传地址：

  1. 如果数据量较小且不需要在函数中修改原始数据，可以选择传值，因为它简单、安全且不会对原始数据造成影响。
  2. 如果数据量较大，或者需要在函数中修改原始数据，可以选择传地址，以避免不必要的数据拷贝和内存开销。
  3. 对于复杂的数据结构（如数组、字符串、结构体等），传地址通常是更好的选择，因为它避免了在函数调用时复制大量数据。
  4. 需要注意在传地址时，要确保函数中正确处理了指针的边界情况，避免指针为空或野指针引起的问题。

31.传出参数的作用？

传出参数是指在函数调用中，通过函数的形参将数据从函数内部传递给函数外部，从而实现函数对外部数据的修改。传出参数的作用主要在于让函数能够返回多个值或修改外部数据。

在函数中，我们可以使用传出参数来将函数内部的计算结果传递给函数外部，而不仅仅是通过返回值来返回一个结果。这样可以简化函数的返回类型，避免使用复杂的数据结构或多个返回值。

传出参数的作用如下：

  1. 返回多个值： 有些情况下，函数需要返回多个值。使用传出参数可以让函数返回多个结果，而不是将这些结果封装在一个复杂的数据结构中。
  2. 修改外部数据： 有时需要在函数内部修改外部数据，通过传出参数可以实现这个目的。这样可以避免全局变量的使用，提高代码的可维护性。
  3. 避免使用全局变量： 使用传出参数可以避免使用全局变量，减少了函数间的耦合性，使代码更加模块化和可重用。
  4. 提高函数灵活性： 传出参数可以使函数更加灵活，使得函数可以适用于不同的场景和数据。

需要注意的是，在使用传出参数时，应确保传入的指针不为空，并在函数内部正确处理指针的边界情况，以避免出现指针为空或野指针引起的问题。

示例：

#include 

// 传出参数实现返回多个值
void calculateSumAndProduct(int a, int b, int *sum, int *product) {
    *sum = a + b;
    *product = a * b;
}

// 传出参数实现修改外部数据
void incrementNumber(int *num) {
    *num = *num + 1;
}

int main() {
    int x = 5, y = 10;
    int sum, product;

    calculateSumAndProduct(x, y, &sum, &product);
    printf("Sum: %d, Product: %d\n", sum, product);

    int number = 10;
    printf("Before increment: %d\n", number);
    incrementNumber(&number);
    printf("After increment: %d\n", number);

    return 0;
}

输出：

Sum: 15, Product: 50
Before increment: 10
After increment: 11

在上述示例中，calculateSumAndProduct 函数使用传出参数 sum 和 product 实现返回多个值；incrementNumber 函数使用传出参数 num 实现修改外部数据。这样可以避免使用全局变量，并提高函数的灵活性。

32.如何让函数返回多个值

在 C 语言中，函数本身只能返回一个值。如果需要让函数返回多个值，可以通过以下几种方式实现：

  1. 使用指针参数： 函数可以接受指针作为参数，并通过指针参数将多个结果传递给函数外部。
  2. 使用结构体： 可以定义一个结构体，将多个需要返回的值封装在结构体中，然后将结构体作为函数的返回值。
  3. 使用全局变量： 将需要返回的值保存在全局变量中，函数内部对全局变量进行赋值，然后在函数外部读取这些值。
  4. 使用数组： 可以定义一个数组，将多个需要返回的值存储在数组中，然后将数组作为函数的返回值或通过指针参数传递给函数。

33.主函数的形参代表的意义

在 C 语言中，主函数是程序的入口点，它具有以下形式：

int main(int argc, char *argv[])

主函数的形参代表的意义：

  1. int argc：表示命令行参数的数量（Argument Count）。argc 是一个整数，用于记录命令行参数的个数。至少为 1，因为第一个参数始终是程序的名称。
  2. char *argv[] 或 char **argv：表示命令行参数的字符串数组（Argument Vector）。argv 是一个指向指针的指针，每个指针指向一个命令行参数的字符串。

主函数运行前要进行预处理、编译、汇编、链接操作，链接结束后会将启动代码链接进去。主函数被启动代码调用，而启动代码是由编译器添加到程序中的，也是程序和操作系统的桥梁，事实上，int main()描述的是main()是操作系统之间的接口。

事实证明main函数只是一个程序的入口，也相当于一个普通的函数，也能被自身调用，也能被其他函数调用。这和一般的函数之间互相调用的概念是一样的。不过需要注意的是，main函数不管是自身的调用还是被其他函数调用，都要设置函数终止的条件，这个递归函数有点相似，不然就会陷入死循环。


34.resrtict关键字

restrict是c99新增的关键字，restrict指针是限定指针指向不同内存空间的，是一个限定符，是编译器用来优化的。使用者可以通过restrict限定符提示调用者某些指针是指向不同空间的，相同空间会被优化成不同空间。
使用时要注意编译器并不能完全优化不同的空间，谨慎使用restrict。

在使用 restrict 关键字时，需要遵循以下几个注意事项：

  1. 指针别名： restrict 关键字用于告知编译器，通过这个指针访问的内存区域不会与其他指针重叠。因此，使用 restrict 关键字时要确保指针指向的内存区域没有被其他指针别名访问。
  2. 指针赋值： 不能将一个指针赋值给 restrict 修饰的指针，否则可能导致别名规则被破坏。
  3. 别名检查： 编译器不会对 restrict 关键字进行别名检查，它假设程序员已经正确使用了 restrict 关键字。

示例：

#include 

void addArrays(int n, int * restrict a, int * restrict b, int * restrict result) {
    for (int i = 0; i < n; i++) {
        result[i] = a[i] + b[i];
    }
}

int main() {
    int a[] = {1, 2, 3, 4, 5};
    int b[] = {5, 4, 3, 2, 1};
    int result[5];

    addArrays(5, a, b, result);

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

    return 0;
}

35.操作可变参数的宏有哪些？操作流程

操作可变参数的宏，可以根据传入的不定个数的参数进行不同的操作。C 语言提供了一些预定义的宏来操作可变参数，主要有以下几个：

  1. va_start： 该宏用于初始化可变参数列表。它接受两个参数，第一个是 va_list 类型的变量，用于保存参数列表信息；第二个是最后一个固定参数的名称。
  2. va_arg： 该宏用于获取可变参数列表中的参数值。它接受两个参数，第一个是 va_list 类型的变量；第二个是要获取的参数的类型。每次调用 va_arg，它会返回一个指定类型的参数，并将指针移动到下一个参数。
  3. va_end： 该宏用于结束对可变参数的操作。它接受一个 va_list 类型的变量，用于释放参数列表相关的资源。

下面是一个使用这些宏的简单例子：

#include 
#include 

// 可变参数宏，计算多个整数的平均值
double average(int num, ...) 
{
    va_list args;
    va_start(args, num);

    int sum = 0;
    for (int i = 0; i < num; i++)
    {
        sum += va_arg(args, int);
    }

    va_end(args);

    return (double)sum / num;
}

int main() 
{
    double result1 = average(3, 10, 20, 30);
    printf("Average 1: %.2f\n", result1);//Average 1: 20.00

    double result2 = average(5, 5, 10, 15, 20, 25);
    printf("Average 2: %.2f\n", result2);//Average 2: 15.00

    return 0;
}

操作流程：

  1. 在宏中定义一个 va_list 类型的变量，用于保存参数列表信息。
  2. 使用 va_start 宏初始化 va_list 变量，传入最后一个固定参数的名称。
  3. 使用 va_arg 宏获取可变参数列表中的参数值，每次调用 va_arg 可以取得一个指定类型的参数，并将指针移动到下一个参数。
  4. 操作完所有可变参数后，使用 va_end 宏结束对可变参数的操作，释放参数列表相关的资源。

35.return 0;语句的作用？return vs exit（1）

return 0; 语句的作用是在 C 语言中用于表示程序执行成功，并向调用该程序的进程返回一个退出状态码。在 C 语言中，主函数 main 的返回类型为 int，并且规定主函数必须以 return 语句结束，返回一个整数值作为程序的退出状态码。通常情况下，返回 0 表示程序执行成功，返回其他非零值表示程序执行出现异常或错误。

return 和 exit(1) 都可以用于终止程序的执行，但它们有以下区别：

  1. 使用场景：
    • return 用于从函数中返回一个值，并结束该函数的执行。
    • exit(1) 用于立即终止整个程序的执行，不会执行后续的代码。
  2. 终止位置：
    • return 语句用于从函数中返回一个值，并将控制权返回给调用该函数的代码处，继续执行后续代码。
    • exit(1) 函数用于立即终止程序的执行，并返回操作系统，不会继续执行任何后续代码。
  3. 退出状态码：
    • return 语句可以返回一个整数值作为退出状态码，表示程序的执行结果。通常情况下，返回 0 表示程序执行成功，返回其他非零值表示程序执行出现异常或错误。
    • exit(1) 函数的参数表示程序的退出状态码，一般来说，非零的状态码表示程序执行出现错误，而 0 表示程序执行成功。

函数指针，指针函数

  1. 函数指针：
    • 定义： 函数指针是指向函数的指针变量。它可以存储函数的地址，使得我们可以通过函数指针来调用特定的函数。函数指针的定义需要与目标函数的签名（参数列表和返回值类型）匹配。
    • 作用： 函数指针的主要作用是动态调用函数。它允许我们在运行时根据需要选择调用不同的函数，提高代码的灵活性和可扩展性。(函数指针体现了C面向对象编程的思维逻辑，多态。)
    • 使用场景： 函数指针常用于以下情况：
      • 回调函数：将函数指针作为参数传递给其他函数，以实现回调机制。
      • 函数映射：通过函数指针数组实现根据索引调用不同的函数。
      • 排序和查找算法：使用函数指针实现通用的排序和查找算法，可在不同的场景下使用不同的比较函数。
    • 注意事项：
      • 函数指针的类型必须与目标函数的签名匹配，否则会导致错误。
      • 函数指针可以为空指针（NULL），在调用函数指针之前，最好检查它是否为空。

示例：

#include 

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

int subtract(int a, int b) {
    return a - b;
}

int main() {
    int (*operation)(int, int); // 声明一个函数指针变量

    operation = add; // 将函数 add 的地址赋值给函数指针
    printf("Result of add: %d\n", operation(5, 3)); // 输出 8

    operation = subtract; // 将函数 subtract 的地址赋值给函数指针
    printf("Result of subtract: %d\n", operation(5, 3)); // 输出 2

    return 0;
}
  1. 指针函数：
    • 定义： 指针函数是指返回指针的函数。它的返回类型是一个指针类型，表示返回指向某个数据类型的指针。
    • 作用： 指针函数可以用于返回动态分配的内存空间，从而实现在函数外部访问函数内部动态分配的内存。
    • 使用场景： 指针函数常用于以下情况：
      • 动态内存分配：通过指针函数返回动态分配的内存空间，避免在函数外部使用静态数组或全局变量。
      • 返回数组：在函数内部创建数组，通过指针函数返回数组的首地址。
    • 注意事项：
      • 在使用指针函数返回的指针之前，确保指针指向的内存空间是有效的，避免出现悬挂指针或内存泄漏的问题。
      • 在函数调用结束后，需要释放通过指针函数返回的动态分配的内存，以免造成内存泄漏。

示例：

#include 
#include 

int* createIntArray(int size) {
    int* arr = (int*)malloc(size * sizeof(int));
    return arr;
}

int main() {
    int* array = createIntArray(5);

    for (int i = 0; i < 5; i++) {
        array[i] = i * 2;
        printf("%d ", array[i]); // 输出 0 2 4 6 8
    }

    free(array); // 释放动态分配的内存

    return 0;
}

在上述示例中，createIntArray 是一个指针函数，它返回一个指向动态分配整型数组的指针。在 main 函数中，我们调用 createIntArray 函数来获取一个动态分配的整型数组，并在使用完后释放了这段内存。

总结：

  • 函数指针允许动态调用不同的函数，提高代码的灵活性。
  • 指针函数用于返回指针类型，通常用于动态内存分配或返回数组。
  • 使用函数指针和指针函数时，要确保正确匹配函数的签名和释放动态分配的内存，避免出现错误和内存泄漏。

函数指针数组的定义及初始化？及作用？

函数指针数组是一个数组，其元素是函数指针。函数指针数组的定义和初始化方式如下：

定义和初始化：

#include 

// 假设有两个函数原型：
int add(int a, int b);
int subtract(int a, int b);

// 定义函数指针数组，数组元素为指向函数的指针
int (*operation[])(int, int) = {add, subtract};

上述代码中，我们定义了一个名为 operation 的函数指针数组，该数组的元素是指向函数的指针。在这个例子中，我们假设有两个函数 add 和 subtract，它们都接受两个整型参数并返回一个整型结果。然后，我们将这两个函数的地址分别存储在 operation 数组中，使得 operation[0] 指向 add 函数，operation[1] 指向 subtract 函数。

作用：

函数指针数组的主要作用是实现函数映射或函数调度表。通过函数指针数组，我们可以根据索引或其他条件选择性地调用不同的函数。这样可以提高代码的灵活性和可扩展性。

使用函数指针数组的典型场景包括：

  1. 函数调度表： 可以根据输入的索引或条件，在函数指针数组中选择合适的函数来执行特定的操作。
  2. 回调函数： 将函数指针数组作为参数传递给其他函数，在其他函数中根据不同的情况选择性地调用不同的回调函数。
  3. 状态机： 将函数指针数组作为状态机的转换表，根据当前状态和输入选择性地调用不同的状态处理函数。

示例：

#include 

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

int subtract(int a, int b) {
    return a - b;
}

int main() {
    // 定义函数指针数组，包含两个函数指针
    int (*operation[])(int, int) = {add, subtract};

    int choice;
    int a = 10, b = 5;

    printf("Enter 0 for add, 1 for subtract: ");
    scanf("%d", &choice);

    // 根据用户输入的选择调用相应的函数
    int result = operation[choice](a, b);

    printf("Result: %d\n", result);

    return 0;
}

在上述示例中，根据用户输入的选择，我们使用函数指针数组 operation 调用了不同的函数（add 或 subtract）。这样，在运行时可以根据用户的选择执行不同的函数操作，实现了函数调度表的功能。

总结：

  • 函数指针数组是一个数组，其元素是函数指针。
  • 函数指针数组的作用主要是实现函数映射或函数调度表，使得程序在运行时可以根据索引或条件选择性地调用不同的函数，提高代码的灵活性和可扩展性。

数组做指针的注意事项

在 C 语言中，数组名在某些情况下会被隐式地转换为指针，因此需要注意一些与数组和指针相关的细节和注意事项。下面是数组做指针时需要注意的几点：

  1. 数组名是指针常量： 数组名在大多数情况下会被隐式地转换为指向数组首元素的指针，但是数组名本身是一个常量指针，它存储了数组的地址，且不可更改。例如，对于 int arr[5]，arr 表示指向数组 arr 的第一个元素的指针，但不能修改 arr 的值。

  2. 数组名作为函数参数： 当数组作为函数的参数传递时，数组名会退化为指向数组首元素的指针。在函数内部，形参看起来像一个指针变量，并不是数组。因此，函数内部无法获取数组的大小。通常，我们需要通过额外的参数传递数组大小。

    示例：

    void printArray(int arr[], int size) {
    // 在函数内部，arr 类似于指针 int* arr
    // 无法获取数组的大小，需要额外的参数 size
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]);
    }
}

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    printArray(arr, 5); // 1 2 3 4 5
    return 0;
}

  3. sizeof 运算符与数组名： 在 sizeof 运算符中，数组名会被解释为数组，返回整个数组的字节大小。例如，sizeof(arr) 返回整个数组 arr 的字节大小，而不是指针的大小。

  4. 数组名与指针运算： 数组名可以进行指针运算，如 arr + 1 将得到数组中下一个元素的地址。但要注意，数组名不能被赋值或修改，因为它是一个常量指针。

    示例：

    int arr[] = {1, 2, 3, 4, 5};
int* ptr = arr;  // 数组名被隐式转换为指向数组首元素的指针

// 数组名可以进行指针运算
printf("%d\n", *(ptr + 1)); // 输出 2

// 但是数组名本身不能被赋值或修改
// arr = ptr; // 错误：不能修改数组名 arr

总结：在使用数组做指针时，需要注意数组名是指针常量，无法修改；在函数参数传递中，数组名会退化为指针，无法在函数内部获取数组大小；在 sizeof 运算符中，数组名表示整个数组的字节大小；数组名可以进行指针运算，但本身不能被赋值或修改。理解这些细节有助于避免数组操作中的错误和误解。

为什么需要内存管理，内存管理的方式？优缺点？

内存管理的根本目的是解决运行时的错误，特别是由于内存资源有限而导致的内存相关问题。确保内存的高效合理使用可以提高系统的性能和稳定性。

内存管理方式主要分为用户管理和系统管理（垃圾回收机制）两种：

  1. 用户管理： 用户管理是指由程序员手动管理内存的分配和释放，通常在低级语言中使用，如 C 和 C++。优点是效率高，因为程序员可以精确控制内存的分配和释放，避免了垃圾回收器的开销。然而，用户管理容易出错，容易引起内存泄漏和悬挂指针等问题，需要更多的注意和谨慎。
  2. 系统管理（垃圾回收机制）： 系统管理是指由编程语言或运行时环境提供的自动内存管理机制。优点是简化了开发，程序员无需手动管理内存，减少了出错的可能性。垃圾回收器可以自动回收不再使用的内存，避免了内存泄漏。然而，垃圾回收机制可能会带来一定的性能开销，并且可能导致应用暂停执行，影响实时性要求高的应用。

C语言分配内存方式有哪些？

C语言的分配内存方式分为栈上的静态分配和堆上的动态分配。
静态分配一般通过数组和alloca函数，栈上分配内存需要注意栈空间的大小是有限的。
动态分配一般是通过指针，堆上分配容易照成内存泄漏。

动态分配内存的函数

以下函数通常用于在堆上分配内存，可以通过指针来访问这些内存。

  1. malloc：
    函数原型：void* malloc(size_t size);
    功能：用于分配指定大小的内存块，并返回一个指向该内存块的指针。分配的内存块不会被初始化，其内容是未定义的。如果分配失败，返回空指针（NULL）。
    注意：使用 malloc 分配的内存在使用之前需要手动进行初始化，否则可能会包含随机值。
  2. calloc：
    函数原型：void* calloc(size_t num_elements, size_t element_size);
    功能：用于分配指定数量和大小的内存块，并返回一个指向该内存块的指针。分配的内存块会被初始化为全零。如果分配失败，返回空指针（NULL）。
  3. realloc：
    函数原型：void* realloc(void* ptr, size_t new_size);
    功能：用于重新分配已经分配的内存块大小，可以扩大或缩小内存块的大小。如果内存块被扩大，新分配的内存区域中的内容是未定义的（需要手动初始化）。如果分配失败，返回空指针（NULL）。如果 ptr 是空指针，则 realloc 的行为等同于 malloc(new_size)。
  4. free：
    函数原型：void free(void* ptr);
    功能：用于释放之前通过 malloc、calloc 或 realloc 分配的内存块。释放内存后，指向该内存块的指针不再有效，应该避免继续使用该指针。

通过这些动态内存分配函数，可以根据实际需要在程序运行时动态地管理内存，从而提高程序的灵活性和资源利用率。同时，需要特别注意在使用这些函数时，正确地管理内存的分配和释放，避免内存泄漏和悬挂指针等问题。

内存池的作用

内存池是一种内存管理技术，其作用是在程序运行时预先分配一定数量的内存块，并将这些内存块组织成池（或缓冲区）。程序在需要内存时，可以直接从内存池中获取已经分配好的内存块，而不是每次都使用动态内存分配函数（如 malloc 或 calloc）来申请新的内存，从而减少内存分配的开销和碎片化，并提高内存分配和释放的效率。

在一些实际的实现中，malloc 函数为了提高内存分配和释放的效率，通常会按照一定的策略进行内存管理。这可能导致实际分配的内存块大小比用户请求的大小要大(会多分配40-60个字节)，以便在内存块中维护一些额外的信息，如内存块的大小、状态等。这种额外的内存空间用于管理和跟踪内存块，以便在释放内存时能够准确地找到并回收内存。

这样做的好处是避免了频繁地进行小内存块的分配和释放，从而减少了内存分配的开销，并降低了内存碎片。一旦用户使用完毕后，内存管理系统可以将这些内存块归还到内存池中，供后续请求使用，从而减少了对操作系统内存管理的频繁调用，提高了内存分配和释放的效率。

内存池的确是一个常用的技术手段，旨在减少 malloc 函数的调用次数，避免频繁的动态内存分配，从而降低内存管理的开销，提高程序的性能和稳定性。通过合理设计内存池的大小和管理策略，可以在一定程度上避免空间的浪费，减少了内存分配的时间和开销，特别适用于需要频繁分配和释放固定大小内存块的场景。

源文件到可执行文件经历那几个步骤？

将源文件（如 C/C++ 文件）编译成可执行文件的过程涉及多个步骤。以下是通常的步骤：

  1. 预处理（Preprocessing）： 在这一阶段，编译器对源文件进行预处理。预处理器会处理源文件中的预处理指令（以 # 开头的指令），如宏定义、头文件包含等，并将其替换成相应的内容。预处理后的文件称为预处理文件。
  2. 编译（Compilation）： 在这一阶段，预处理后的文件（即预处理文件）会被编译器翻译成汇编代码。编译器会将源代码转换为汇编代码，这是一个与具体硬件架构相关的低级别代码，但仍保留了源代码的结构。
  3. 汇编（Assembly）： 在这一阶段，汇编器将汇编代码翻译成机器代码，也就是目标文件。目标文件包含了处理器可以直接执行的二进制指令，但还没有链接到最终的可执行文件。
  4. 链接（Linking）： 在这一阶段，链接器将目标文件与其他可能需要的目标文件或库文件进行链接。链接器的主要作用是解析目标文件之间的符号引用，并将它们关联到正确的地址。最终生成的可执行文件包含了所有所需的目标代码以及标准库或其他依赖库的代码。

最终，经过上述步骤，源文件就会被编译成一个可执行文件，可以在相应的操作系统上运行。在不同的编程语言和编译器中，可能会有一些细微的差异，但基本的编译过程通常都遵循上述的步骤。

宏定义的作用？

宏定义是 C 和 C++ 编程语言中的一种预处理指令，它允许程序员在代码中定义一些简单的文本替换规则。宏定义的作用是在编译过程中将指定的文本片段替换为预定义的内容。宏定义通常用于定义常量、函数或代码块的缩写，以及在编译时进行简单的代码替换。

宏定义的主要作用有以下几点：

  1. 定义常量： 宏定义可以用于定义常量，在代码中使用宏名称时会被替换为其对应的值。这样可以提高代码的可读性和可维护性，同时便于修改常量的值。

    示例：

    #define MAX_SIZE 100
int arr[MAX_SIZE];

  2. 代码块缩写： 宏定义可以用于定义代码块的缩写，将一组代码片段替换为一个宏名称。这样可以简化代码，使其更加简洁易读。

    示例：

    #define SQUARE(x) ((x) * (x))
int result = SQUARE(5); // 将会被替换为 int result = ((5) * (5));

  3. 条件编译： 宏定义可以用于条件编译，在预处理阶段根据条件判断是否包含某段代码。这在处理不同平台或配置下的代码时非常有用。

    示例：

    #define DEBUG
#ifdef DEBUG
// 在调试模式下执行的代码
#endif

  4. 函数宏： 宏定义还可以用于定义函数宏，即将宏定义替换为一段代码块。函数宏在使用时类似于函数调用，但是避免了函数调用的开销。

    示例：

    #define MIN(a, b) ((a) < (b) ? (a) : (b))
int min_value = MIN(x, y);

宏函数和自定义函数的优缺点？

宏函数是用编译时间换取内存空间，它的优点是省去了函数调用返回一系列操作，省去了形参的内存空间，提高了程序的运行效率，缺点就是傻瓜式替换，不安全，复杂的功能无能为力。

自定义函数是用内存空间换取运行时间，它的优点是在编译时能够及时检测出语法的问题，可以实现复杂的功能。缺点是函数运行返回释放需要一定的运行时间，对于形参还会去开辟内存空间，运行效率较慢。

宏（Macro）和 typedef 的区别

总的来说，宏主要用于定义常量和缩写代码块，其定义是简单的文本替换，不做参数 检查；而 typedef 主要用于给数据类型起别名，提高代码的可读性和可维护性，具有类型安全性。

inline 是 C 和 C++ 中的一个关键字，用于对编译器提出函数内联的建议。函数内联是一种编译器优化技术，它通过将函数调用处直接替换为函数体，以减少函数调用的开销，从而提高程序的执行效率。inline 关键字可以向编译器建议将指定的函数进行内联展开。

inline 关键字的作用和优势主要有以下几点：

  1. 减少函数调用开销： 函数调用涉及到保存现场、跳转、返回等操作，这些开销在函数调用次数较多时可能成为性能瓶颈。使用 inline 关键字可以将函数的实际代码插入到函数调用处，减少了函数调用的开销。
  2. 避免函数调用栈： 函数内联展开可以避免函数调用栈的创建和销毁，特别是当函数递归调用或嵌套调用较深时，可以避免栈溢出等问题。
  3. 优化短小函数： inline 关键字特别适用于短小的函数，这些函数的调用开销相对较大，将它们进行内联展开可以显著提高程序的执行效率。
  4. 空间换时间： inline 关键字实际上是一种空间换时间的优化策略。将函数内联展开会增加代码的体积，但可以减少函数调用的开销，从而在一定程度上提高程序的运行速度。

inline关键字的作用？

需要注意的是，inline 关键字只是向编译器提出内联展开的建议，编译器是否真正对函数进行内联展开取决于编译器的优化策略和实际情况。通常，编译器会根据函数的大小、复杂度和调用频率等因素来决定是否进行内联展开。在使用 inline 关键字时，应该注意以下几点：

  1. 函数定义通常应该放在头文件中，以便在多个源文件中进行内联展开。
  2. 不要滥用 inline 关键字，过度使用内联可能会导致代码体积增大，反而降低了缓存命中率，从而降低了性能。
  3. 在一些复杂的函数、递归函数或包含循环、递归等控制结构的函数上，inline 关键字可能不会生效，编译器可能会忽略内联展开的建议。

总的来说，inline 关键字是一种优化技术，通过在一定程度上增加代码体积来减少函数调用开销，从而提高程序的执行效率。但在使用时需要根据实际情况进行合理的优化，并避免滥用。

container_of宏的作用及使用场景

container_of宏的作用是通过结构体内某个成员变量的地址和该变量名，以及结构体类型，找到该主结构体的地址。函数在定义时，会给形参开辟空间，如果传整个结构体会导致空间过大，如果使用container_of宏传递某个成员变量的地址，就可以节约形参的开辟空间。

container_of 宏的定义一般如下：

#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - offsetof(type, member)))

其中，ptr 是结构体成员的指针，type 是包含该成员的结构体类型，member 是结构体成员的名称。

C语言有哪些常见的内置宏及作用

C语言中常见的内置宏一般用于调试程序，常见的内置宏有：
LINE:打印所在的行号
func：打印函数名
TIME：打印编译时刻的时间
DATE：打印编译时时刻的日期
FILE:打印文件名

如何解决头文件重复包含导致重复定义问题？

头文件重复包含导致重复定义问题可以通过使用预处理器指令来解决，常用的解决方法有以下几种：

  1. 头文件保护（Header Guards）： 在头文件的开头和结尾使用预处理器指令，可以防止头文件被重复包含。常见的头文件保护格式如下：
#ifndef HEADER_NAME_H
#define HEADER_NAME_H

// 头文件内容

#endif // HEADER_NAME_H

HEADER_NAME_H 是一个自定义的宏名称，可以根据头文件的名称自行命名。在第一次包含头文件时，HEADER_NAME_H 会被定义，防止头文件内容重复包含。在后续的包含中，由于 HEADER_NAME_H 已经被定义，预处理器会跳过头文件的内容，避免了重复定义问题。

  1. #pragma once 指令（仅限部分编译器）： 一些编译器支持 #pragma once 指令，它也可以用来避免头文件的重复包含。使用 #pragma once 指令的头文件会在第一次被包含时，标记为“已包含”，之后的包含会被忽略。
#pragma once

// 头文件内容

需要注意的是，#pragma once 并非 C/C++ 标准规范，虽然大多数编译器都支持该指令，但并不是所有编译器都支持。为了确保代码的可移植性，通常推荐使用头文件保护的方法。

通过以上方法，可以有效避免头文件重复包含导致的重复定义问题，提高代码的可维护性和可移植性。在编写头文件时，建议养成良好的头文件保护习惯，以确保头文件在包含时能够正确地工作。

#include<> vs #include""如何指定第三方搜索路径？

  1. #include ：
    • 这种形式用于包含标准库头文件或系统提供的头文件。
    • 编译器在搜索头文件时会从系统的标准库路径中查找
    • 使用 #include 形式时，编译器不会在用户指定的搜索路径中查找头文件，只会在系统标准库路径中查找。
  2. #include "filename"：
    • 这种形式用于包含用户自定义的头文件或第三方库的头文件。
    • 编译器首先在当前源文件所在目录下查找头文件，如果找不到，则会在用户指定的搜索路径中查找。
    • 用户可以通过编译器的命令行选项或环境变量来指定第三方库头文件的搜索路径。具体的方法和命令行选项会因不同的编译器而有所差异。

在 GCC 编译器中，可以使用 -I 选项来指定头文件搜索路径。例如，假设有一个名为 libfoo 的第三方库，其头文件位于 /path/to/libfoo/include 目录下，那么可以使用以下命令来编译包含该库的源文件：

gcc -o main.o -c main.c -I/path/to/libfoo/include

这样编译器在包含头文件时就会在指定的路径下查找。如果头文件被包含在多个源文件中，可以在编译命令中的每个源文件都加上 -I 选项，也可以将路径添加到 C_INCLUDE_PATH 或 CPLUS_INCLUDE_PATH 环境变量中。

总结：#include 用于标准库或系统提供的头文件，搜索路径为系统标准库路径；#include "filename" 用于用户自定义的头文件或第三方库的头文件，搜索路径可以通过编译器的选项或环境变量来指定。

struct vs union的区别

结构体变量的大小是按照字节对齐的方式进行相加，是所有成员变量大小和字节长度的和。满足成员变量中最大数据类型的整数倍。
共用体变量是共用同一内存空间，大小由字节最长的成员变量和最大成员变量的数据类型决定，满足字节对齐方式，也满足成员变量中最大数据类型的整数倍。
因为共用体内所有成员公用一段内存，容易造成数据覆盖。用于函数传参时，传递不同类型的值，但只能存储一个值，多个值会产生覆盖。

struct的使用注意事项

使用结构体时要注意结构体是按照字节对齐的方式进行数据的存储，容易造成内存空洞，尽量将同类型的成员放在一起。
当成员变量中存在指针变量的时候，一定要注意浅拷贝问题，赋值符号会进行隐式浅拷贝，此时我们要自定义深拷贝函数解决浅拷贝的逻辑问题。

当结构体中包含指针变量时，需要特别小心浅拷贝问题。默认情况下，结构体的赋值符号进行的是浅拷贝，即只是简单地复制指针的值，而不会复制指针指向的数据。这样可能会导致多个结构体指针指向同一块内存，一旦其中一个指针修改了内存内容，会影响其他指针所指向的数据。为了解决浅拷贝问题，需要自定义深拷贝函数，确保在复制结构体时，也复制指针指向的数据，而不是仅仅复制指针本身。

示例：

#include 
#include 
#include 

struct Person {
    char *name;
    int age;
};

// 自定义深拷贝函数
void deepCopyPerson(struct Person *dest, const struct Person *src) {
    dest->name = strdup(src->name); // 使用 strdup 进行字符串的深拷贝
    dest->age = src->age;
}

int main() {
    struct Person p1;
    p1.name = "Alice";
    p1.age = 30;

    struct Person p2;
    deepCopyPerson(&p2, &p1);

    // 修改 p2 的姓名，不会影响 p1
    p2.name = "Bob";

    printf("p1: %s, %d\n", p1.name, p1.age);
    printf("p2: %s, %d\n", p2.name, p2.age);

    // 释放内存
    free(p2.name);

    return 0;
}

使用union如何判断机器的大小端

使用联合（union）可以判断机器的大小端（Endian）。大小端是指在多字节数据类型（如整数、浮点数）在内存中的存储方式。常见的大小端类型有大端序（Big-Endian）和小端序（Little-Endian）。

以下是使用联合来判断机器的大小端的方法：

#include 

// 定义一个联合类型
union EndianChecker {
    int value;
    char bytes[sizeof(int)];
};

int main() {
    union EndianChecker checker;
    checker.value = 1;

    // 如果小端序，bytes[0] 存放的是 1
    // 如果大端序，bytes[3] 存放的是 1
    if (checker.bytes[0] == 1) {
        printf("Little-Endian\n");
    } else {
        printf("Big-Endian\n");
    }

    return 0;
}

请注意，这种方法是一种常见的用于判断大小端的方法，但在实际应用中，最好使用系统提供的相关函数或宏来获取机器的大小端，以确保代码的可移植性和准确性。例如，在 C 语言中，可以使用 htonl 和 ntohl 函数来转换网络字节序和主机字节序，从而获取当前机器的大小端信息。在 C++ 中，可以使用 std::endian 命名空间下的相关宏来获取大小端信息。

枚举的作用及使用注意事项

枚举实际上就是一系列整数宏定义。与结构体和共用体不同，枚举不存在枚举变量。
枚举元素是常数，因此枚举元素又称为枚举常量。因为是常量，所以不能对枚举元素进行赋值。
在实际问题中，有些变量的取值被限定在一个有限的范围内，此时就可以使用枚举类型。

文件指针的作用

文件指针就是FILE类型指针，指向文件类型的结构，结构里包含该文件的各种属性，可以对它指向的文件进行各种操作。可以随机访问文件，可以把I/O操作抽象为文件操作。

feof实现原理？feof的作用？如何判断文件为空文件？

feof是站在当前文件读取位置向后看，看是否有字符，有字符返回0。feof一般用于判断一个文件是否为空。
对于一个空文件来说，当程序打开时，他的光标会停在文件的开头，此时使用feof遍历文件，如果返回值不为0，则文件为空。


fgets fputs fgetc fputc的函数原型及使用注意事项

  1. fgets 函数：
char* fgets(char* str, int num, FILE* stream);

函数原型说明：

  • str：指向一个字符数组，用于存储读取的字符串（包括换行符 \n）。
  • num：指定要读取的字符数（包括换行符 \n），通常应该将数组大小减去 1，以确保在字符串末尾添加 null 终止符。
  • stream：指向一个文件流，表示要从该文件流中读取数据。

使用注意事项：

  • fgets 函数读取数据时，会将换行符 \n 一并读取，并存储在字符串中，因此读取的字符串可能包含换行符。
  • 如果 fgets 成功读取数据，会将字符串的地址作为返回值，如果到达文件末尾或读取失败，返回值为 NULL。
  • 使用 fgets 读取数据后，字符串最后会被自动添加 null 终止符，因此需要确保数组大小足够容纳读取的字符串和终止符。
  1. fputs 函数：
int fputs(const char* str, FILE* stream);

函数原型说明：

  • str：指向一个以 null 终止的字符串，表示要写入到文件中的数据。
  • stream：指向一个文件流，表示要写入数据的文件流。

使用注意事项：

  • fputs 函数会将给定的字符串写入到文件中，但不会添加换行符 \n。
  • 如果写入成功，返回非负值，否则返回 EOF。
  1. fgetc 函数：
int fgetc(FILE* stream);

函数原型说明：

  • stream：指向一个文件流，表示要从该文件流中读取字符。

使用注意事项：

  • fgetc 函数从文件流中读取一个字符，并以整数形式返回其 ASCII 码值。
  • 如果到达文件末尾或读取失败，返回 EOF。
  1. fputc 函数：
int fputc(int character, FILE* stream);

函数原型说明：

  • character：表示要写入到文件的字符，以整数形式传递，通常使用字符的 ASCII 码值。
  • stream：指向一个文件流，表示要写入数据的文件流。

使用注意事项：

  • fputc 函数将一个字符写入到文件中。
  • 如果写入成功，返回写入的字符的 ASCII 码值，否则返回 EOF。

注意事项：

  • 使用这些文件输入输出函数时，需要确保文件的打开和关闭操作正确，以及进行错误处理。
  • 在读取文件内容时，要注意文件指针的位置，以免发生意外的读取错误。
  • 在写入文件内容时，要确保数据正确，并注意文件的写入权限，避免对只读文件进行写入操作。
  • 为了防止数据截断或数据溢出，应该合理设置读取和写入缓冲区的大小，并确保缓冲区足够容纳读取或写入的数据。

fopen fclose fread fwrite fseek 的函数原型及使用注意事项

以下是 fopen、fclose、fread、fwrite 和 fseek 函数的函数原型以及使用注意事项：

  1. fopen 函数：
FILE* fopen(const char* filename, const char* mode);

函数原型说明：

  • filename：要打开的文件的路径和名称。
  • mode：打开文件的模式，如 “r” 表示只读，“w” 表示写入，“a” 表示追加，“rb” 表示以二进制方式只读，等等。具体模式可以组合使用。

使用注意事项：

  • 在打开文件时，需要确保文件路径和名称正确，以及文件是否存在和权限是否正确。
  • 在打开文件后，要检查返回的文件指针是否为 NULL，以确认文件是否成功打开。
  1. fclose 函数：
int fclose(FILE* stream);

函数原型说明：

  • stream：指向要关闭的文件流的指针。

使用注意事项：

  • 在完成对文件的读写操作后，应该及时关闭文件，释放文件资源。
  • 在关闭文件时，要确保文件流指针是有效的，且没有重复关闭同一文件流。
  1. fread 函数：
size_t fread(void* ptr, size_t size, size_t nmemb, FILE* stream);

函数原型说明：

  • ptr：指向用于存储读取数据的缓冲区的指针。
  • size：每个数据项的字节大小。
  • nmemb：要读取的数据项的个数。
  • stream：指向要从中读取数据的文件流。

使用注意事项：

  • fread 函数用于从文件中读取二进制数据。
  • 要确保 ptr 缓冲区足够大，能够容纳读取的数据。
  • fread 返回实际成功读取的数据项个数，应该与 nmemb 相等，否则可能意味着到达文件末尾或读取错误。
  1. fwrite 函数：
size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream);

函数原型说明：

  • ptr：指向要写入文件的数据缓冲区的指针。
  • size：每个数据项的字节大小。
  • nmemb：要写入的数据项的个数。
  • stream：指向要写入数据的文件流。

使用注意事项：

  • fwrite 函数用于向文件中写入二进制数据。
  • 要确保 ptr 缓冲区中包含正确的数据，且缓冲区大小能够容纳要写入的数据。
  • fwrite 返回实际成功写入的数据项个数，应该与 nmemb 相等，否则可能意味着写入错误。
  1. fseek 函数：
int fseek(FILE* stream, long offset, int whence);

函数原型说明：

  • stream：指向要定位的文件流。
  • offset：相对于 whence 的偏移量，可以是正数或负数。
  • whence：指定起始位置，可以是 SEEK_SET（文件开头）、SEEK_CUR（当前位置）或 SEEK_END（文件末尾）。

使用注意事项：

  • fseek 函数用于定位文件指针的位置，以便实现文件的随机访问。
  • 要确保文件流指针有效，以及定位的位置在文件的有效范围内。
  • 在使用 fseek 函数时，应该检查返回值，确保定位操作是否成功。

注意：以上函数都是 C 和 C++ 标准库中的文件操作函数。在使用这些函数时，需要注意对文件的打开和关闭操作，以及进行错误处理，以保证文件操作的正确性和稳定性。同时，为了防止数据截断或数据溢出，应该合理设置读取和写入缓冲区的大小，并确保缓冲区足够容纳读取或写入的数据。

fprintf fscanf的函数原型及使用注意事项？

以下是 fprintf 和 fscanf 函数的函数原型以及使用注意事项：

  1. fprintf 函数：
int fprintf(FILE* stream, const char* format, ...);

函数原型说明：

  • stream：指向要写入数据的文件流。
  • format：格式化字符串，用于指定要写入文件的数据格式。
  • ...：可变参数，根据 format 字符串中的格式化指示符，用于指定要写入文件的数据。

使用注意事项：

  • fprintf 函数用于向文件中写入格式化的数据。
  • format 字符串中的格式化指示符应与可变参数列表中的数据类型相匹配，否则可能导致输出错误或内存访问错误。
  • 要确保 stream 文件流指针有效，且文件已经打开，并具有写入权限。
  • fprintf 返回成功写入的字符数，如果发生写入错误，返回负值。

示例用法：

#include 

int main() {
    FILE* file = fopen("example.txt", "w");
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    int num1 = 10;
    double num2 = 3.14;
    char str[] = "Hello, World!";

    // 向文件中写入格式化的数据
    fprintf(file, "Integer: %d\n", num1);
    fprintf(file, "Double: %lf\n", num2);
    fprintf(file, "String: %s\n", str);

    fclose(file);
    return 0;
}
  1. fscanf 函数：
int fscanf(FILE* stream, const char* format, ...);

函数原型说明：

  • stream：指向要读取数据的文件流。
  • format：格式化字符串，用于指定要读取的数据格式。
  • ...：可变参数，根据 format 字符串中的格式化指示符，用于指定读取的数据存储位置。

使用注意事项：

  • fscanf 函数用于从文件中读取格式化的数据。
  • format 字符串中的格式化指示符应与可变参数列表中的数据类型相匹配，否则可能导致读取错误或内存访问错误。
  • 要确保 stream 文件流指针有效，且文件已经打开，并具有读取权限。
  • fscanf 返回成功读取的项数，如果发生读取错误或到达文件末尾，返回 EOF。

示例用法：

#include 

int main() {
    FILE* file = fopen("example.txt", "r");
    if (file == NULL) {
        printf("Failed to open the file.\n");
        return 1;
    }

    int num1;
    double num2;
    char str[100];

    // 从文件中读取格式化的数据
    fscanf(file, "Integer: %d\n", &num1);
    fscanf(file, "Double: %lf\n", &num2);
    fscanf(file, "String: %s\n", str);

    printf("Integer: %d\n", num1);
    printf("Double: %lf\n", num2);
    printf("String: %s\n", str);

    fclose(file);
    return 0;
}

在使用 fprintf 和 fscanf 函数时，要特别注意格式化字符串中的格式化指示符与可变参数列表的数据类型匹配，以及文件流指针的有效性和文件的权限。同时，在读取数据时，应该确保文件中的数据格式与读取的格式化字符串匹配，以避免读取错误。

fflush作用

使用 fflush 主要有两个作用：

  1. 刷新输出缓冲区：在使用标准输出函数（如 printf）向屏幕输出信息时，这些信息会先被写入到输出缓冲区，然后根据一定的条件（比如缓冲区满、换行符 \n 出现等）进行实际的输出。如果想要立即将缓冲区的内容输出到屏幕上，可以在适当的位置使用 fflush(stdout)，这样可以实时查看输出结果，而不需要等到程序执行结束。
  2. 刷新输入缓冲区：在使用标准输入函数（如 scanf）从用户获取输入时，输入数据会先被写入输入缓冲区，然后根据一定的条件（比如用户按下 Enter 键）进行实际的读取。如果输入缓冲区中还有数据未读取，而程序又需要等待用户输入时，可以使用 fflush(stdin) 来清空输入缓冲区，防止遗留的数据干扰后续的输入操作。

注意事项：

  • fflush 函数的使用应该谨慎，一般来说，在标准输出和标准输入中使用 fflush 是合理的。但是在文件 I/O 操作中，fflush 可能会导致性能下降，因为频繁的刷新缓冲区会引起多次磁盘写入，降低文件操作效率。因此，在文件 I/O 操作中，通常不需要手动调用 fflush，因为当文件关闭时，缓冲区会被自动刷新。如果确实需要强制刷新文件缓冲区，可以使用 fflush 函数。

示例用法：

#include 

int main() {
    int num;
    printf("Enter a number: ");
    scanf("%d", &num);

    // 清空输入缓冲区，防止遗留的换行符影响后续输入
    fflush(stdin);

    printf("You entered: %d\n", num);
    printf("Flushing output buffer...\n");

    // 刷新输出缓冲区，立即显示输出结果
    fflush(stdout);

    return 0;
}

如何用c实现面向对象编程？

  1. 结构体和函数指针：使用结构体来表示类，结构体中包含成员变量和函数指针，函数指针指向该类的成员函数（方法）。
  2. 封装：将类的数据和行为封装在结构体中，使用函数指针来操作这些数据和行为，使得外部无法直接访问类的成员变量。
  3. 继承：使用结构体嵌套来实现类的继承关系。
  4. 多态：通过函数指针的动态绑定，实现不同类的同名成员函数实现多态。

特殊的文件指针

在 C 语言中，除了常规的文件指针 FILE*，还有一些特殊的文件指针用于特定的文件操作或位置控制。这些特殊文件指针包括：

  1. stdin：标准输入文件指针，通常用于从键盘读取输入。它是一个预定义的文件指针，指向标准输入流（stdin）。
  2. stdout：标准输出文件指针，通常用于向屏幕输出信息。它是一个预定义的文件指针，指向标准输出流（stdout）。
  3. stderr：标准错误文件指针，通常用于向屏幕输出错误信息。它是一个预定义的文件指针，指向标准错误流（stderr）。

系统调用 库函数的区别

系统调用和库函数是两种不同的方式来访问操作系统功能或执行特定任务的方法。它们的区别在于如何与操作系统进行交互和完成任务。

  1. 系统调用：
    系统调用是操作系统提供给用户程序的接口，用于访问底层操作系统功能。当一个程序需要执行特定的操作，例如创建新进程、读写文件、分配内存等，它必须通过系统调用请求操作系统来完成这些任务。系统调用是用户程序与操作系统之间的一种界面，通过这个接口，用户程序可以请求操作系统为其执行需要特权或底层硬件访问的任务。

系统调用的特点：

  • 需要较高的特权级别：系统调用涉及操作系统内核的功能，因此需要较高的权限级别来执行。
  • 开销较大：由于涉及从用户模式切换到内核模式，并且进行安全检查等操作，因此系统调用通常会比较耗时。
  • 提供更底层的功能：系统调用允许程序直接访问操作系统提供的底层功能，但同时也需要处理更多的细节和安全性。
  1. 库函数：
    库函数是由编程语言或操作系统提供的一组函数集合，用于在用户程序中重复使用常见的功能。这些函数通常是在用户空间中实现的，而不涉及操作系统内核的调用。库函数通过封装一系列操作，提供了更高级别的抽象，使得程序员可以更方便地使用这些功能，而不必关心底层的实现细节。

库函数的特点：

  • 位于用户空间：库函数在用户程序的地址空间中运行，因此不需要切换特权级别或进行安全检查。
  • 较小的开销：由于在用户空间执行，避免了从用户模式到内核模式的切换，因此库函数通常比系统调用执行起来更快。
  • 提供高级抽象：库函数将底层功能进行封装和抽象，使得程序员可以更简单地调用这些功能，而无需处理底层细节。

总结：
使用系统调用时，程序直接请求操作系统执行底层任务，需要切换特权级别和涉及较多的安全检查，开销较大，但能够访问更底层的功能。而使用库函数时，程序调用封装好的高级抽象接口，运行在用户空间，开销较小，但功能通常更有限，且不能直接访问底层硬件或特权级功能。

在实际编程中，通常建议优先使用库函数，除非需要特定的底层功能或操作系统接口，才考虑使用系统调用。库函数使得程序开发更简单，易于维护，并且通常具有良好的跨平台兼容性。

什么时候选择是使用系统调用API?什么时候使用库函数?

选择使用系统调用API或库函数取决于需求和应用场景。下面提供了一些指导原则来帮助做出正确的选择：

使用系统调用API的情况：

  1. 访问底层功能：如果需要直接访问操作系统提供的底层功能，例如创建新进程、分配内存、管理文件系统等，那么通常需要使用系统调用API。系统调用提供了更底层、更直接的接口来操作操作系统。
  2. 特权操作：某些操作，例如修改系统配置、管理硬件设备等，需要较高的权限级别。这时，只有通过系统调用来请求操作系统执行这些特权操作。
  3. 跨平台功能：有时候，不同操作系统可能提供不同的功能和特性。在需要跨平台兼容性的情况下，使用系统调用可以确保程序在不同操作系统上的行为一致。
  4. 高性能需求：在性能要求非常高的场景下，可能需要直接使用系统调用，以避免库函数带来的额外开销和抽象。

使用库函数的情况：

  1. 便捷性：库函数提供了更高级别的抽象和封装，使得编程更加简单和便捷。在不需要直接访问底层功能的情况下，库函数通常更易于使用。
  2. 提高可移植性：库函数通常是经过各种平台测试和优化的，使用库函数可以提高程序的可移植性，避免因为操作系统差异导致的问题。
  3. 安全性：库函数通常会处理一些底层细节，例如边界检查、错误处理等，从而提供更高的安全性，避免一些常见的编程错误。
  4. 提高开发效率：使用库函数可以大大减少开发时间和工作量，因为库函数已经为常见任务提供了现成的实现。

综合考虑以上因素，通常优先选择使用库函数，除非需要直接访问底层或特定的操作系统功能，或者对性能要求非常高，这时才考虑使用系统调用API。对于大部分应用程序，使用库函数可以提供更好的开发体验和更高的可移植性。

如何优化读写效率?方式?

优化读写效率是提高程序性能的重要方面。下面列举了一些常见的优化方式来提高读写效率：

  1. 使用缓冲区：减少频繁的读写操作，可以将数据存储在内存缓冲区中，然后进行批量读写。这样可以减少I/O次数，提高读写效率。
  2. 异步I/O：采用异步I/O方式可以在进行I/O操作的同时执行其他任务，充分利用系统资源，提高读写效率。
  3. 使用更高效的数据结构：根据实际需求选择适当的数据结构，例如使用哈希表或索引结构，可以提高读写操作的速度。
  4. 优化文件读写模式：在读写大文件时，可以使用mmap()函数来将文件映射到内存，这样可以减少系统调用次数，提高读写效率。
  5. 批量读写：尽量减少小块数据的单独读写，而是采用批量读写的方式，可以减少I/O开销。
  6. 顺序读写：对于磁盘文件，顺序读写比随机读写更高效，尽量按顺序访问数据。
  7. 使用缓存：在适当的场景下，可以使用缓存来缓存读取的数据，从而减少对磁盘或网络的频繁访问。
  8. 压缩数据：对于大量数据的读写，可以考虑使用压缩技术，减少数据量，从而提高读写效率。
  9. 并行读写：在多核处理器系统中，可以采用并行读写的方式，充分利用多个核心的计算能力，加速读写操作。
  10. 避免不必要的数据拷贝：在数据传递过程中，尽量避免不必要的数据拷贝操作，可以通过使用引用或指针等方式来传递数据。
  11. 磁盘分区与位置：合理划分磁盘分区，将频繁读写的数据集中在同一分区，还可以利用操作系统的磁盘缓存技术来提高读写效率。
  12. 使用更快速的设备：如果有选择的余地，可以选择更快速的磁盘或存储设备，例如使用SSD代替传统的机械硬盘，能够显著提高读写速度。

在优化读写效率时，需要根据具体的应用场景和系统环境进行针对性的优化。使用性能分析工具可以帮助发现瓶颈，并针对性地进行优化。同时，要注意在优化过程中不要牺牲代码的可维护性和可读性。

什么存储映射? mmap的函数接口?使用注意事项?

存储映射（Memory-mapped I/O）是一种将文件的内容直接映射到内存地址空间的技术。它允许将文件数据看作是内存中的一部分，从而实现对文件的读写操作，而无需使用传统的read和write函数。在许多操作系统中，这项技术由mmap函数提供支持。

mmap函数接口（在C语言中）通常如下：

#include 

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
int munmap(void *addr, size_t length);
  • addr: 指定映射的起始地址，通常设为0，让操作系统自动选择映射的地址。
  • length: 指定映射的长度，一般为文件的大小。
  • prot: 指定内存保护模式，可以是以下值的组合：
    • PROT_READ：可读
    • PROT_WRITE：可写
    • PROT_EXEC：可执行
    • PROT_NONE：无法访问
  • flags: 指定映射选项，可以是以下值的组合：
    • MAP_SHARED：允许多个进程共享映射区，对映射区的修改会影响到文件。
    • MAP_PRIVATE：创建一个私有的映射区，对映射区的修改不会影响到文件。
  • fd: 文件描述符，指定要映射的文件。
  • offset: 文件的偏移量，指定映射从文件的哪个位置开始。

使用注意事项：

  1. 确保对齐：在一些体系结构中，对内存的访问要求数据的地址与数据大小的对齐。因此，确保映射的地址和长度满足对齐要求是重要的。
  2. 内存管理：由于mmap映射的内存可能在进程退出或munmap后仍然留在内存中，所以应该注意管理内存，避免内存泄漏。
  3. 文件大小与映射长度：mmap映射的长度应该小于等于文件的大小。如果要扩展文件，应该先将文件扩展到所需大小，然后再重新映射。
  4. 文件描述符的生命周期：在映射期间，文件描述符应保持打开状态，否则映射可能出错。
  5. 多进程访问：当使用MAP_SHARED标志时，多个进程可以共享映射区，需要注意同步和竞态条件，以避免数据不一致的问题。
  6. 读写保护：应该根据需要设置合适的内存保护模式（prot），防止非法的内存访问。

使用存储映射可以提高文件读写性能和简化代码逻辑，但在使用时需要谨慎，并遵循上述注意事项，以确保正确且安全地使用该功能。

常见的文件标志位有哪些?功能?

常见的文件标志位是在打开文件时用来指定文件的打开模式和行为。在C语言中，文件标志位是通过在open()函数或相关函数中指定的参数来设置的。不同的操作系统可能有略微不同的标志位，下面列举了一些常见的文件标志位以及它们的功能：

  1. O_RDONLY: 只读模式。打开文件以供读取，文件必须存在，不能修改。
  2. O_WRONLY: 只写模式。打开文件以供写入，如果文件不存在，则创建一个新文件；如果文件已存在，则截断文件为零长度。
  3. O_RDWR: 读写模式。打开文件以供读取和写入，如果文件不存在，则创建一个新文件。
  4. O_CREAT: 如果文件不存在，则创建一个新文件。需要与O_WRONLY或O_RDWR标志位一起使用。
  5. O_TRUNC: 如果文件已存在，在打开文件时截断文件为零长度。需要与O_WRONLY或O_RDWR标志位一起使用。
  6. O_APPEND: 以追加模式打开文件，每次写入会将数据追加到文件末尾。
  7. O_EXCL: 与O_CREAT一起使用，用于确保创建新文件时，如果文件已存在，则返回错误。
  8. O_NONBLOCK（或O_NDELAY）: 非阻塞模式。在读取或写入时，如果没有数据或无法立即写入，则不会阻塞进程，而是立即返回。
  9. O_SYNC: 同步写入模式。每次写入都会直接传输到磁盘，保证数据持久化。
  10. O_DIRECTORY: 用于打开目录而非文件。
  11. O_CLOEXEC: 在进程执行exec函数时，会关闭这个文件描述符。

这些文件标志位可以根据需要进行组合，以满足不同的打开文件需求。在使用文件标志位时，需要根据具体场景和要求来选择适当的标志位组合，以实现正确的文件操作和行为。

阻塞IO和非阻塞IO的区别?

阻塞I/O（Blocking I/O）和非阻塞I/O（Non-blocking I/O）是两种不同的I/O操作方式，它们的主要区别在于进程或线程在执行I/O操作时的行为和状态。

  1. 阻塞I/O（Blocking I/O）：
    在阻塞I/O模式下，当一个进程或线程执行I/O操作时，如果请求的数据还没有准备好，进程或线程会被阻塞（挂起）等待，直到数据准备好或者I/O操作完成为止。在这个等待的过程中，进程或线程不能进行其他任务，它会一直停在I/O操作上。
  2. 非阻塞I/O（Non-blocking I/O）：
    在非阻塞I/O模式下，当一个进程或线程执行I/O操作时，如果请求的数据还没有准备好，进程或线程不会被阻塞，而是立即返回一个错误码或指示数据未准备好的消息。这样，进程或线程可以继续执行其他任务，而不必等待I/O操作的完成。

主要区别：

  • 阻塞I/O会导致进程或线程被阻塞，无法进行其他任务，直到I/O操作完成；非阻塞I/O允许进程或线程继续执行其他任务，不需要等待I/O操作完成。
  • 阻塞I/O适合在有足够时间等待的情况下使用，例如在读取文件或网络数据时，因为数据的读取可能需要一定时间；非阻塞I/O适合在不能或不愿等待的情况下使用，例如实时系统或需要同时处理多个任务的场景。

注意：

  • 使用阻塞I/O时，可能会导致程序在I/O操作上出现较长的延迟，从而影响整体性能。
  • 非阻塞I/O通常需要在代码中轮询检查数据是否准备好，可能会增加CPU的开销，但可以提高系统的响应性。可以配合使用异步I/O技术来避免轮询的开销。
  • 在某些情况下，可以将I/O操作放在专门的线程或进程中进行，以避免阻塞主程序的执行。

IO多路复用的作用及实现方式?

IO多路复用（IO Multiplexing）是一种高效的I/O操作模型，用于在单个线程或进程中同时监视多个I/O事件，并在有事件发生时进行响应。它的作用在于提高程序的并发性和响应性，使得一个线程或进程能够同时处理多个I/O操作而无需阻塞。

IO多路复用的实现方式主要有以下几种：

  1. select()：
    select是最早引入的IO多路复用函数，它能同时监视多个文件描述符（通常是套接字），并在其中有可读、可写或出错等事件发生时返回。但是select有一些限制，例如文件描述符数量有限，每次调用select时都需要传递所有要监视的文件描述符集合，导致效率低下。
  2. poll()：
    poll与select类似，也能同时监视多个文件描述符，但它没有select的一些限制，可以更好地处理大量的文件描述符。poll的实现方式避免了select的一些性能问题。
  3. epoll()：
    epoll是Linux特有的一种高效IO多路复用机制。它采用回调机制，当文件描述符就绪时，操作系统通知应用程序进行相应的处理。相比于select和poll，epoll在处理大量文件描述符时性能更好。epoll有两种工作方式：ET（边缘触发）和LT（水平触发）。ET模式只在文件描述符状态发生变化时通知应用程序，而LT模式会在文件描述符状态变化期间持续通知应用程序。
  4. kqueue()：
    kqueue是BSD和macOS上的IO多路复用机制。它类似于epoll，也是通过回调通知方式进行文件描述符的监视，但具体的接口和实现略有不同。

IO多路复用适用于需要同时监视多个文件描述符，并且希望在有事件发生时立即得到通知并进行相应处理的场景。常见的应用包括网络服务器，特别是在高并发环境下，使用IO多路复用能有效地提高服务器的性能和响应能力，避免多线程或多进程中可能出现的资源竞争和线程切换开销。


  1. select() 函数：
#include 

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
  • 参数：
    • nfds：要监视的最大文件描述符值加1。
    • readfds：可读文件描述符集合。
    • writefds：可写文件描述符集合。
    • exceptfds：异常文件描述符集合。
    • timeout：等待超时时间，如果为NULL，则select将阻塞直到有文件描述符就绪；如果为0，则立即返回，即非阻塞模式。
  • 返回值：
    • 成功：返回就绪文件描述符的数量（可能为0）。
    • 失败：返回-1，并设置errno来指示错误。
  • 功能：
    select函数用于同时监视多个文件描述符，当有文件描述符就绪时，它会返回，并告知应用程序哪些文件描述符已经准备好读、写或出错。
  1. poll() 函数：
#include 

int poll(struct pollfd *fds, nfds_t nfds, int timeout);
  • 参数：
    • fds：一个指向pollfd结构数组的指针，每个结构描述了一个要监视的文件描述符及其感兴趣的事件。
    • nfds：要监视的文件描述符数量。
    • timeout：等待超时时间，单位是毫秒。如果为-1，则poll将一直阻塞，直到有文件描述符就绪；如果为0，则立即返回，即非阻塞模式。
  • 返回值：
    • 成功：返回就绪文件描述符的数量（可能为0）。
    • 失败：返回-1，并设置errno来指示错误。
  • 功能：
    poll函数与select函数类似，用于同时监视多个文件描述符，当有文件描述符就绪时，它会返回，并告知应用程序哪些文件描述符已经准备好读、写或出错。
  1. epoll() 函数：
#include 

int epoll_create(int size);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
  • 参数：
    • epfd：epoll实例的文件描述符，由epoll_create函数返回。
    • op：要进行的操作，可以是EPOLL_CTL_ADD（添加文件描述符）、EPOLL_CTL_MOD（修改事件）、EPOLL_CTL_DEL（删除文件描述符）。
    • fd：要添加、修改或删除的文件描述符。
    • event：指向epoll_event结构的指针，描述文件描述符的事件。
    • maxevents：事件数组events的大小，即最多可以返回的就绪事件数量。
    • timeout：等待超时时间，单位是毫秒。如果为-1，则epoll_wait将一直阻塞，直到有文件描述符就绪；如果为0，则立即返回，即非阻塞模式。
  • 返回值：
    • epoll_create：成功时返回一个新的epoll实例的文件描述符，失败时返回-1，并设置errno来指示错误。
    • epoll_ctl：成功时返回0，失败时返回-1，并设置errno来指示错误。
    • epoll_wait：返回就绪文件描述符的数量（可能为0），失败时返回-1，并设置errno来指示错误。
  • 功能：
    epoll是一种高效的IO多路复用机制，通过epoll_create函数创建一个epoll实例，然后通过epoll_ctl函数向实例添加、修改或删除文件描述符的事件，最后通过epoll_wait函数等待文件描述符就绪事件。
  1. kqueue() 函数：
#include 
#include 
#include 

int kqueue(void);
int kevent(int kq, const struct kevent *changelist, int nchanges, struct kevent *eventlist, int nevents, const struct timespec *timeout);
  • 参数：
    • kq：kqueue实例的文件描述符，由kqueue函数返回。
    • changelist：指向kevent结构数组的指针，描述要添加、修改或删除的文件描述符的事件。
    • nchanges：changelist数组的大小，即要进行操作的事件数量。
    • eventlist：指向kevent结构的指针，用于接收返回的就绪事件。
    • nevents：eventlist数组的大小，即最多可以返回的就绪事件数量。
    • timeout：等待超时时间，与epoll_wait的timeout参数类似。
  • 返回值：
    • kqueue：成功时返回一个新的kqueue实例的文件描述符，失败时返回-1，并设置errno来指示错误。
    • kevent：返回就绪事件的数量（可能为0），失败时返回-1，并设置errno来指示错误。
  • 功能：
    kqueue是BSD和macOS上的IO多路复用机制，通过kqueue函数创建一个kqueue实例，然后通过kevent函数向实例添加、修改或删除文件描述符的事件，最后通过kevent函数等待文件描述符就绪事件。

IO多路复用每种方式的优缺点?

IO多路复用的每种方式（select、poll、epoll、kqueue等）都有各自的优点和缺点。下面分别列出它们的特点：

  1. select：
    优点：
  • 可移植性较好，几乎在所有平台上都能使用。
  • 支持的文件描述符数量没有上限。
    缺点：
  • 对文件描述符的扫描是线性的，随着文件描述符数量的增加，性能会下降。
  • 每次调用select时，需要传递所有监视的文件描述符集合，导致效率较低。
  • 不支持多线程并发处理。
  1. poll：
    优点：
  • 支持的文件描述符数量没有上限。
  • 不需要传递所有监视的文件描述符集合，解决了select的效率问题。
  • 支持多线程并发处理。
    缺点：
  • 对文件描述符的扫描是线性的，随着文件描述符数量的增加，性能会下降。
  • 每次调用poll时，需要将所有监视的文件描述符传递给内核，可能会导致开销较大。
  1. epoll：
    优点：
  • 支持高并发，对大量文件描述符的扫描效率高，不会随着文件描述符数量增加而下降。
  • 使用回调通知机制，无需遍历文件描述符集合，只通知就绪的文件描述符，提高效率。
  • 支持水平触发和边缘触发两种工作模式。
  • 支持多线程并发处理。
    缺点：
  • 只能在Linux系统上使用，不具备跨平台性。
  • API相对复杂，使用相对select和poll需要更多的代码。
  1. kqueue：
    优点：
  • 支持高并发，对大量文件描述符的扫描效率高，不会随着文件描述符数量增加而下降。
  • 支持多线程并发处理。
  • 提供更丰富的事件类型和事件过滤条件。
    缺点：
  • 只能在BSD和macOS系统上使用，不具备跨平台性。
  • API较为复杂，相对于select和poll需要更多的代码。

总体而言，epoll和kqueue在性能和功能上都优于select和poll。如果在Linux系统上开发，可以优先考虑使用epoll，而在BSD或macOS系统上开发，可以优先考虑使用kqueue。如果需要跨平台兼容，可以根据具体情况选择select或poll，但需要注意它们在大规模并发环境下可能带来的性能问题。

高级API (fcntl、mmap、dup dup2)

  1. fcntl() 函数：
#include 

int fcntl(int fd, int cmd, ... /* arg */);
  • 参数：
    • fd：文件描述符，表示要进行操作的文件。
    • cmd：要执行的操作命令，可以是以下值之一：
      • F_DUPFD：复制文件描述符。
      • F_GETFD：获取文件描述符标志。
      • F_SETFD：设置文件描述符标志。
      • F_GETFL：获取文件状态标志和访问模式。
      • F_SETFL：设置文件状态标志和访问模式。
      • F_GETOWN：获取文件异步I/O所有权。
      • F_SETOWN：设置文件异步I/O所有权。
      • 其他其他值和参数具体相关。
    • arg：根据cmd的不同，可能需要提供额外的参数。
  • 返回值：
    • 成功：根据cmd的不同返回不同值或者执行成功。
    • 失败：返回-1，并设置errno来指示错误。
  • 功能：
    fcntl函数用于对文件描述符进行各种控制操作，可以复制文件描述符、获取或设置文件描述符的标志、获取或设置文件状态标志和访问模式，以及控制异步I/O所有权等。
  1. mmap() 函数：
#include 

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
  • 参数：
    • addr：映射的起始地址，通常设为0，让操作系统自动选择映射的地址。
    • length：映射的长度，一般为文件的大小。
    • prot：内存保护模式，指定映射的内存区域的访问权限，可以是以下值的组合：
      • PROT_READ：可读
      • PROT_WRITE：可写
      • PROT_EXEC：可执行
      • PROT_NONE：无法访问
    • flags：映射选项，可以是以下值的组合：
      • MAP_SHARED：允许多个进程共享映射区，对映射区的修改会影响到文件。
      • MAP_PRIVATE：创建一个私有的映射区，对映射区的修改不会影响到文件。
      • MAP_FIXED：强制映射到指定地址。
      • MAP_ANONYMOUS：创建匿名映射，不与文件关联。
      • MAP_NORESERVE：不保留映射区对应的交换空间。
      • 其他其他值和参数具体相关。
    • fd：文件描述符，指定要映射的文件。
    • offset：文件的偏移量，指定映射从文件的哪个位置开始。
  • 返回值：
    • 成功：返回映射区的起始地址。
    • 失败：返回MAP_FAILED（-1），并设置errno来指示错误。
  • 功能：
    mmap函数用于将文件的内容直接映射到内存地址空间，允许对文件进行内存映射的读写操作，也可以创建匿名映射用于进程间共享数据。
  1. dup() 函数：
#include 

int dup(int oldfd);
  • 参数：
    • oldfd：要复制的文件描述符。
  • 返回值：
    • 成功：返回新的文件描述符，它与oldfd指向相同的文件表项（文件偏移量、状态等）。
    • 失败：返回-1，并设置errno来指示错误。
  • 功能：
    dup函数用于复制一个文件描述符，返回一个新的文件描述符，它与原始文件描述符指向同一个文件表项。这样可以在多个文件描述符之间共享相同的文件描述符表项，但独立维护各自的文件偏移量等状态。
  1. dup2() 函数：
#include 

int dup2(int oldfd, int newfd);
  • 参数：
    • oldfd：要复制的文件描述符。
    • newfd：新的文件描述符。
  • 返回值：
    • 成功：返回新的文件描述符newfd，它与oldfd指向相同的文件表项（文件偏移量、状态等）。
    • 失败：返回-1，并设置errno来指示错误。
  • 功能：
    dup2函数与dup函数类似

谈谈你对进程的理解?

1、进程是操作系统最小的资源分配单位，相对程序来讲，程是一个独立运行的程序在计算机中的一次执行过程。进程是动态的，程序是静态的;
2、每个进程都拥有自己的地址空间、代码、数据、文件描述符等资源，并且相互之间是独立的、隔离的。一个进程消亡不会影响其他进程;所以进程实现多任务是安全的;但是多进程的开销比较大;
3、多进程每个进程都有三种状态:进程可以处于运行、就绪、阻塞等状态。运行状态表示进程正在CPU上执行指令，就绪状态表示进程已准备好执行，但还没有得到CPU执行时间，阻塞状态表示进程在等待某些事件发生。
4、进程调度的策略:根据进程的三态，通过时间片轮转(实时性差)来实现进程的调度。抢占式:(可以在一个时间片内再次获取CPU):高优先级优先、短进程优先、先来先服务，非抢占式:不可以在一个时间片内再次获取CPU。
5、每个进程都有自己的ID号，叫做进程的pid;
6、操作系统在系统启动时会自动创建出三个进程：
0：负责引导系统启动，也会创建一个1号进程init进程
1：负责初始化硬件，回收资源
2：负责资源的分配，系统的调度

fork vfork

fork和vfork是两个创建新进程的系统调用，在Unix-like系统中常见。它们的主要区别在于创建子进程的方式和父子进程之间的行为。

  1. fork()：
  • 原型：pid_t fork(void);
  • 功能：fork函数用于创建一个新的子进程，子进程是父进程的副本，从fork调用之后的代码开始执行。子进程拥有与父进程几乎完全相同的地址空间和资源，包括代码、数据、堆栈等。fork函数会被调用一次，但返回两次，一次在父进程中返回子进程的PID（进程ID），一次在子进程中返回0。因此，通过返回值可以在父进程和子进程中区分执行的代码。
  • 父子进程的行为：fork创建子进程时，子进程继承了父进程的地址空间和资源。父子进程共享同一文件表项，但文件表项中的文件偏移量是各自独立的，因此它们在共享文件时需要注意文件指针的位置。
  1. vfork()：
  • 原型：pid_t vfork(void);
  • 功能：vfork函数用于创建一个新的子进程，子进程是父进程的副本，从vfork调用之后的代码开始执行。与fork不同的是，vfork保证在子进程中先执行，并且子进程共享父进程的地址空间，不会为子进程创建新的页表，这使得vfork的性能通常比fork更高。
  • 父子进程的行为：由于vfork保证在子进程中先执行，而子进程与父进程共享地址空间，因此子进程在调用exec系列函数或者退出后应该立即调用_exit函数来避免在共享地址空间中造成意外的修改。vfork通常用于创建临时子进程，它在父进程调用exec函数前临时运行一些代码。

总结：

  • fork创建的子进程拥有与父进程几乎相同的地址空间和资源，适用于一般的进程复制需求。
  • vfork创建的子进程与父进程共享地址空间，适用于创建临时子进程并在子进程中执行一些代码的场景，通常与exec函数结合使用。

进程间通信的方式有哪些?优缺点?

进程间通信（Inter-Process Communication，IPC）是多个进程之间进行数据交换和通信的机制。在多进程编程中，进程间通信是实现进程间协作的重要方式。常见的进程间通信方式包括：

  1. 管道（Pipe）：
    • 函数原型：int pipe(int pipefd[2]);
    • 参数：pipefd 是一个包含两个整数的数组，用于存放管道的两个文件描述符。pipefd[0] 用于读取数据，pipefd[1] 用于写入数据。
    • 功能：pipe函数用于创建一个无名管道，它是一个单向通信通道，用于在有亲缘关系的进程之间进行通信。管道是半双工的，数据只能在一个方向上流动。
    • 返回值：成功返回0，失败返回-1。
    • 优点：简单易用，不需要显式的创建和销毁通信通道；可以实现单向或双向通信。
    • 缺点：只适用于有亲缘关系的进程之间通信；管道是半双工的，数据只能在一个方向上流动。
  2. 命名管道（Named Pipe）：
    • 函数原型：int mkfifo(const char *pathname, mode_t mode);
    • 参数：pathname 是命名管道的路径名，mode 是权限掩码，用于指定管道的权限。
    • 功能：mkfifo函数用于创建一个命名管道，它可以在没有亲缘关系的进程之间进行通信。命名管道是一种特殊的文件类型，可以通过文件名进行访问。
    • 返回值：成功返回0，失败返回-1。
    • 优点：可以在没有亲缘关系的进程之间进行通信；可以实现双向通信。
    • 缺点：只能在同一主机上的进程之间通信；不能实时传递数据。
  3. 信号量（Semaphore）：
    • 函数原型：int sem_init(sem_t *sem, int pshared, unsigned int value);
    • 参数：sem 是指向信号量的指针，pshared 是一个标志，用于指定信号量是在进程间共享还是在线程间共享，value 是信号量的初始值。
    • 功能：sem_init函数用于初始化一个信号量，用于进程间同步和互斥。
    • 返回值：成功返回0，失败返回-1。
    • 优点：可以用于进程间同步和互斥；可以实现多进程之间的共享资源控制。
    • 缺点：编程复杂，易出现死锁问题；只能用于进程之间的同步，不能传递大量数据。
  4. 消息队列（Message Queue）：
    • 函数原型：int msgget(key_t key, int msgflg);
    • 参数：key 是消息队列的键值，msgflg 是标志位，用于指定消息队列的访问权限和创建选项。
    • 功能：msgget函数用于创建一个消息队列或获取一个已经存在的消息队列。
    • 返回值：成功返回消息队列的标识符（非负整数），失败返回-1。
    • 优点：可以实现多进程之间的通信和同步；支持不同类型的消息；可以实现消息的顺序传递。
    • 缺点：不适合传递大量数据；对消息的处理需要编程细节。
  5. 共享内存（Shared Memory）：
    • 函数原型：int shmget(key_t key, size_t size, int shmflg);
    • 参数：key 是共享内存的键值，size 是共享内存的大小，shmflg 是标志位，用于指定共享内存的访问权限和创建选项。
    • 功能：shmget函数用于创建一个共享内存区域或获取一个已经存在的共享内存区域。
    • 返回值：成功返回共享内存的标识符（非负整数），失败返回-1。
    • 优点：速度快，适合传递大量数据；可以实现多进程之间的高效通信。
    • 缺点：需要显式进行内存管理和同步操作；不适合用于保护敏感数据。
  6. 套接字（Socket）：
    • 函数原型：int socket(int domain, int type, int protocol);
    • 参数：domain 是通信协议族，如AF_UNIX（Unix域套接字）或AF_INET（IPv4套接字）；type 是套接字的类型，如SOCK_STREAM（流式套接字）或SOCK_DGRAM（数据报套接字）；protocol 是协议，一般设为0，让系统根据type自动选择合适的协议。
    • 功能：socket函数用于创建一个套接字，用于在不同主机上的进程之间进行通信，支持网络通信。
    • 返回值：成功返回套接字的文件描述符，失败返回-1。
    • 优点：可以在不同主机上的进程之间进行通信；支持网络通信，适用于分布式系统。
    • 缺点：编程复杂，需要网络编程知识。

进程VS线程?优缺点?使用场景?

首先进程是资源分配的最小单位，线程是任务调度的最小单位；进程比线程更健壮，每个进程拥有独立的地址空间，一个进程的崩溃不会影响其他进程、而线程之间共享地址空间，一个线程的崩溃可能影响其他线程或者整个程序；由于线程的调度必须通过频繁加锁来保持同步，线程的性能比进程低；但线程之间切换比进程之间切换开销少，成本低；

进程：

  • 优点：
    • 隔离性好：每个进程拥有独立的地址空间，一个进程的崩溃不会影响其他进程。
    • 可靠性高：一个进程的崩溃不会导致整个系统崩溃，其他进程仍然可以继续执行。
    • 安全性高：不同进程之间的数据不会相互干扰，进程间通信需要显式进行。
  • 缺点：
    • 创建销毁开销大：进程的创建和销毁需要较多的系统资源和时间。
    • 进程间通信复杂：不同进程之间通信需要使用IPC机制，编程复杂度较高。
  • 使用场景：
    • 需要高度隔离性、可靠性和安全性的任务。
    • 需要充分利用多核处理器的多核心能力。
    • 需要在多机分布的场景下进行任务处理。

线程：

  • 优点：
    • 创建销毁开销小：线程的创建和销毁比进程快，因为它们共享进程的资源。
    • 线程间通信方便：线程共享进程的地址空间，线程间通信更方便。
    • 效率高：线程切换比进程切换开销小，因为线程共享进程的资源，切换时不需要切换地址空间。
  • 缺点：
    • 隔离性差：一个线程的崩溃可能导致整个进程崩溃，影响其他线程。
    • 安全性低：多个线程共享进程的资源，需要考虑同步和互斥问题，容易出现数据竞争等问题。
  • 使用场景：
    • 需要高并发性的任务，如Web服务器处理并发请求。
    • 需要频繁进行计算密集型操作，可以利用多线程并行计算。
    • 需要高效地共享数据和通信的任务，如图形界面程序中的用户界面响应。
    • 需要响应用户输入等事件，保持界面的交互性。

综合应用场景：

  • 强相关处理：对于强相关性的任务，建议使用线程来实现，因为线程可以共享地址空间，通信方便，且创建销毁开销小，适合高并发、频繁计算等任务。
  • 弱相关处理：对于弱相关性的任务，建议使用进程来实现，因为进程具有良好的隔离性，一个进程崩溃不会影响其他进程，适合需要高度隔离性和可靠性的任务。
  • 分布式场景：对于需要在多机分布的任务处理，可以使用多进程来实现，以充分利用多台机器的处理能力。
  • 多核场景：对于需要充分利用多核处理器的多核心能力的任务，可以使用多线程来实现，并行处理计算密集型任务。

在实际应用中，可能会根据实际需求综合考虑进程和线程的特点，选择合适的方式来实现多任务并发。

线程的同步方式有哪些?及作用?

线程的同步是指在多个线程并发执行的情况下，通过一些机制来协调线程之间的执行顺序和共享资源的访问，以避免竞争条件和数据不一致等问题。常见的线程同步方式包括：

  1. 互斥锁（Mutex）：
    • 作用：互斥锁用于保护临界区（一段需要互斥访问的代码），确保同一时间只有一个线程可以进入临界区执行，其他线程需要等待。
    • 特点：只有持有锁的线程可以执行临界区代码，其他线程在获取锁之前会被阻塞。
    • 避免问题：避免了多个线程同时访问共享资源导致的数据竞争问题。
  2. 读写锁（Read-Write Lock）：
    • 作用：读写锁允许多个线程同时读取共享资源，但只允许一个线程写入共享资源。适用于读多写少的场景。
    • 特点：多个线程可以同时持有读锁，但写锁是互斥的。
    • 避免问题：避免了多个读线程之间的竞争，以及读线程和写线程之间的竞争。
  3. 条件变量（Condition Variable）：
    • 作用：条件变量用于在多个线程之间进行等待和通知，允许线程在某个条件满足时继续执行。
    • 特点：通常与互斥锁一起使用，等待时会释放锁，通知时会重新获取锁。
    • 避免问题：避免了忙等待，节省了CPU资源。
  4. 信号量（Semaphore）：
    • 作用：信号量用于控制对资源的访问数量，可以实现互斥和同步。
    • 特点：有计数功能，可以控制允许同时访问资源的线程数量。
    • 避免问题：避免了资源的过度共享和竞争，控制了线程的并发度。
  5. 屏障（Barrier）：
    • 作用：屏障用于同步多个线程的执行，在某个点等待所有线程都到达后才继续执行。
    • 特点：多个线程在达到屏障前会阻塞，直到所有线程都到达后才继续执行。
    • 避免问题：确保了线程在某个同步点都执行完毕后再继续进行。
  6. 原子操作（Atomic Operations）：
    • 作用：原子操作是不可中断的操作，可以保证某个操作在多线程环境下的原子性，从而避免竞争条件。
    • 特点：通过硬件的支持来保证操作的原子性，不需要加锁。
    • 避免问题：避免了竞争条件和数据不一致问题。

线程池的作用?如何实现线程池（线程池的定义)?

线程池的作用：
主要作用：避免创建过多的线程时引发的内存溢出问题，因为创建线程还是比较耗内存的。

  1. 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
  2. 提高响应速度：当任务到达时，任务可以不需要等待线程创建就能立即执行。
  3. 提高线程的可管理性：线程是稀缺资源，如果无限制地创建，不仅会消耗系统资源，还会降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控。

为什么使用线程池？

  • 创建/销毁线程伴随着系统开销，频繁创建/销毁线程影响效率，线程池减少了这种开销。
  • 控制线程的并发数，避免过多的线程抢占资源导致阻塞。

何时使用线程池？

  • 单个任务处理时间短，需要处理大量任务。
  • 需要充分利用系统资源，提高系统性能。

何时不适宜使用线程池？

  • 线程执行时间较长，任务耗时严重。
  • 需要详细的线程优先级控制。
  • 在执行过程中需要对线程进行操作，比如睡眠，挂起等，因为线程池本身就是为突然大量爆发的短任务而设计的，如果要使线程睡眠、挂起的话，与线程池设计思想相悖。

线程池的实现步骤：

  1. 创建线程池控制结构的结构体。
  2. 初始化线程池：分配空间、初始化信息、创建线程。
  3. 向线程池的任务队列中添加任务：加锁、判断线程池状态、解锁。
  4. 任务执行（回调函数）：加锁、判断线程池状态、解锁、执行回调函数。

TCP服务器和客户端的创建过程?(API)

TCP服务器创建过程：

  1. 创建套接字（Socket）：
    • 函数：socket()
    • 原型：int socket(int domain, int type, int protocol);
    • 参数：
      • domain：地址族，通常为AF_INET（IPv4）。
      • type：套接字类型，通常为SOCK_STREAM（TCP流式套接字）。
      • protocol：协议，通常为0（由给定的domain和type自动选择合适的协议）。
    • 功能：创建一个新的套接字。
    • 返回值：成功时返回套接字描述符，失败时返回-1。
  2. 绑定地址和端口：
    • 函数：bind()
    • 原型：int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    • 参数：
      • sockfd：套接字描述符。
      • addr：指向要绑定的地址结构的指针，通常是一个struct sockaddr_in类型的指针。
      • addrlen：地址结构的长度。
    • 功能：将套接字绑定到指定的IP地址和端口号。
    • 返回值：成功时返回0，失败时返回-1。
  3. 监听连接请求：
    • 函数：listen()
    • 原型：int listen(int sockfd, int backlog);
    • 参数：
      • sockfd：套接字描述符。
      • backlog：等待队列的最大长度，即允许等待连接的最大客户端数量。
    • 功能：开始监听连接请求。
    • 返回值：成功时返回0，失败时返回-1。
  4. 接受连接：
    • 函数：accept()
    • 原型：int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    • 参数：
      • sockfd：套接字描述符。
      • addr：用于存储客户端地址的结构体指针。
      • addrlen：指向存储addr结构体长度的变量的指针。
    • 功能：等待并接受客户端连接请求。
    • 返回值：成功时返回新的套接字描述符，用于与客户端通信，失败时返回-1。
  5. 与客户端通信：
    • 使用新的套接字描述符与客户端进行通信，可以使用send() 和 recv() 等函数发送和接收数据。
  6. 关闭套接字：
    • 函数：close()
    • 原型：int close(int sockfd);
    • 参数：套接字描述符。
    • 功能：关闭套接字。
    • 返回值：成功时返回0，失败时返回-1。

TCP客户端创建过程：

  1. 创建套接字（Socket）：同上。
  2. 连接服务器：
    • 函数：connect()
    • 原型：int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    • 参数：
      • sockfd：套接字描述符。
      • addr：指向服务器地址结构的指针，通常是一个struct sockaddr_in类型的指针。
      • addrlen：地址结构的长度。
    • 功能：连接到服务器的指定IP地址和端口号。
    • 返回值：成功时返回0，失败时返回-1。
  3. 与服务器通信：
    • 使用套接字描述符与服务器进行通信，可以使用send() 和 recv() 等函数发送和接收数据。
  4. 关闭套接字：同上。

listen函数的作用?

listen() 函数用于将一个套接字（socket）标记为被动（监听）套接字，以便它可以接受传入的连接请求。在TCP服务器程序中，listen() 函数的作用是开始监听指定的套接字，使其可以接受客户端的连接请求。

函数原型：

int listen(int sockfd, int backlog);

参数：

  • sockfd：要监听的套接字描述符。
  • backlog：等待队列的最大长度，即允许等待连接的最大客户端数量。

功能：

  • listen() 函数用于将指定的套接字转换为被动套接字，使其可以开始监听连接请求。
  • 当套接字被标记为被动套接字后，可以使用 accept() 函数来接受传入的连接请求。

返回值：

  • 如果函数调用成功，返回值为0，表示监听操作已经开始。
  • 如果函数调用失败，返回值为-1，可能是因为套接字无效或者其他错误。

需要注意的是，一旦调用 listen() 函数后，套接字将变为被动状态，只能用于接受连接请求，而不能直接用于数据的发送和接收。接下来，通常会使用 accept() 函数来接受客户端的连接请求，获取新的套接字用于与客户端通信。

为什么要将“套接字文件描述符”转为被动描述符后，才能监听连接？

将套接字（Socket）文件描述符转为被动描述符后才能监听连接，涉及到网络通信的基本原理和TCP协议的工作机制。

TCP协议是一种面向连接的协议，它在通信双方之间建立起一条可靠的、全双工的数据传输通道。在建立TCP连接时，通常有一个主动方（客户端）和一个被动方（服务器端）。这种主动方和被动方的区分在套接字的角色上有所体现：

  1. 主动方（客户端）：客户端通过创建一个套接字，然后主动发起连接请求，即向服务器端发出连接请求。
  2. 被动方（服务器端）：服务器端通过创建一个套接字，然后将该套接字标记为被动（监听）状态，以等待客户端的连接请求。

将套接字文件描述符转为被动描述符后，主要是为了准备服务器端接受连接请求的环境。这涉及到以下原因：

  1. 连接请求的排队等待：当服务器正在与一个客户端进行通信时，可能会有其他客户端也想连接到服务器。这时，服务器需要有一个队列来保存这些连接请求，使得可以逐个接受这些连接。将套接字标记为被动描述符后，服务器就可以开始监听连接请求并将其排队。
  2. 连接三次握手：在TCP连接的建立中，存在三次握手的过程，通过这个过程确保了客户端和服务器的互通性和可靠性。服务器需要准备好接受这个握手过程，才能建立可靠的连接。将套接字标记为被动描述符后，服务器可以接受传入的连接请求，进行连接的三次握手。

总之，将套接字文件描述符转为被动描述符后，服务器端可以进入监听状态，等待客户端的连接请求，并在连接请求到来时准备好进行握手和建立连接，从而实现可靠的网络通信。

为什么会出现无法绑定的错误?

在网络编程中，无法绑定的错误通常指的是在使用 bind() 函数时出现了错误。bind() 函数用于将套接字（Socket）与一个特定的IP地址和端口号绑定，以便于在该地址和端口上监听连接请求。如果出现无法绑定的错误，可能是以下几种原因导致的：

  1. 端口被占用：如果指定的端口号已经被其他程序占用，那么在尝试绑定相同端口时就会失败。每个端口只能被一个程序同时占用。
  2. 地址不可用：如果指定的IP地址不可用，或者在多网卡环境下出现了IP地址冲突，也会导致绑定失败。
  3. 权限不足：在某些操作系统中，需要足够的权限才能绑定低于1024的端口号，比如80（HTTP端口）或443（HTTPS端口）。
  4. 套接字状态问题：在套接字已经被使用并且未释放的情况下，尝试再次绑定可能会失败。需要确保在绑定之前关闭之前的套接字。
  5. 网络设置问题：可能存在网络配置问题，如路由设置、防火墙等，导致绑定失败。

关于 setsockopt() 函数，你提到了两个使用场景：

  1. 重用连接处于 TIME_WAIT 状态的端口： 在TCP连接关闭后，会进入 TIME_WAIT 状态一段时间，以确保在网络中传递的所有数据都被接收完毕。这个状态持续的时间可能会影响服务器程序的性能，通过设置 SO_REUSEADDR 选项，可以在端口释放后立即重用端口，避免等待 TIME_WAIT 的时间。
  2. 强制关闭连接： 如果需要在连接状态下立即关闭套接字，而不等待 TIME_WAIT 状态，也可以使用 SO_REUSEADDR 选项。

accept函数的作用?

accept()函数接受连接请求等待队列中待处理的客户端连接请求。函数调用成功时，accept ()内部将产生用于数据I/O的套接字，并返回器文件描述符。需要强调的是，套接字是自动创建的，并自动与发起连接请求的客户端建立连接。
从处于 ESTABLISHED状态下的连接队列头部取出一个已经完成的连接，如果这个队列没有已经完成的连接，accept()函数就会阻塞，直到取出队列中已完成的用户连接为止。

recv/send vs read/write?

在网络编程中，以及在处理文件和数据流的情况下，有两组常用的函数用于数据的读写和传输：recv 和 send，以及 read 和 write。这些函数在不同的上下文中用于不同的目的，但本质上都是用于在套接字（sockets）或文件中进行数据传输。

  1. recv 和 send：
    • 这对函数主要用于网络编程中的套接字通信，如在 TCP 和 UDP 协议中。
    • recv 用于从套接字接收数据。它等待并接受数据，然后将数据存储到指定的缓冲区中。
    • send 用于将数据从缓冲区发送到套接字。它负责将数据发送给连接的远程主机。
    • 这些函数通常提供更多的控制选项，如处理数据的边界、标志等。
  2. read 和 write：
    • 这对函数通常用于文件 I/O 操作，例如处理文件、管道、流等。
    • read 用于从文件或数据流中读取数据。它会将数据读取到指定的缓冲区中。
    • write 用于将数据从缓冲区写入文件或数据流。它将缓冲区中的数据写入到目标文件或流中。
    • 这些函数通常用于标准文件描述符（例如标准输入和标准输出）以及文件操作。

udp的创建过程?(API)

在网络编程中，创建和使用 UDP（User Datagram Protocol）套接字涉及一系列 API 调用。以下是使用典型的套接字 API（例如，C 语言的套接字库）来创建 UDP 套接字的一般步骤：

  1. 包含头文件： 首先，您需要包含适当的头文件，通常是 和 。
  2. 创建套接字： 使用 socket() 函数来创建套接字。指定套接字的地址族（AF_INET 或 AF_INET6）和套接字类型（SOCK_DGRAM 用于 UDP 套接字）。
    int socket_fd = socket(AF_INET, SOCK_DGRAM, 0);
if (socket_fd == -1) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
}
  3. 配置地址和端口： 定义和配置套接字地址信息，包括 IP 地址和端口号。
    struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // Use any available network interface
server_addr.sin_port = htons(PORT);  // Define the port number
  4. 绑定套接字： 使用 bind() 函数将套接字与指定的地址和端口绑定。
    if (bind(socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("Binding failed");
    exit(EXIT_FAILURE);
}
  5. 接收和发送数据： 使用 recvfrom() 函数接收数据，使用 sendto() 函数发送数据。这两个函数用于 UDP 数据的接收和发送。
    char buffer[MAX_BUFFER_SIZE];
struct sockaddr_in client_addr;
socklen_t addr_len = sizeof(client_addr);

ssize_t bytes_received = recvfrom(socket_fd, buffer, sizeof(buffer), 0, (struct sockaddr *)&client_addr, &addr_len);
if (bytes_received == -1) {
    perror("Receive failed");
    exit(EXIT_FAILURE);
}

// Process and handle received data...

ssize_t bytes_sent = sendto(socket_fd, buffer, bytes_received, 0, (struct sockaddr *)&client_addr, addr_len);
if (bytes_sent == -1) {
    perror("Send failed");
    exit(EXIT_FAILURE);
}
  6. 关闭套接字： 在不再需要套接字时，使用 close() 函数关闭套接字。
    close(socket_fd);

这些步骤展示了使用 C 语言的套接字库创建 UDP 套接字的基本过程。具体的细节可能因编程语言、操作系统和网络库而有所不同。不同编程语言和库可能会有相应的 API 调用，但总体的创建过程基本类似。

TCP的创建过程?(API)

在网络编程中，创建和使用 TCP（Transmission Control Protocol）套接字涉及一系列 API 调用。以下是使用典型的套接字 API（例如，C 语言的套接字库）来创建 TCP 套接字的一般步骤：

  1. 包含头文件： 首先，您需要包含适当的头文件，通常是 和 。
  2. 创建套接字： 使用 socket() 函数来创建套接字。指定套接字的地址族（AF_INET 或 AF_INET6）和套接字类型（SOCK_STREAM 用于 TCP 套接字）。
    int socket_fd = socket(AF_INET, SOCK_STREAM, 0);
if (socket_fd == -1) {
    perror("Socket creation failed");
    exit(EXIT_FAILURE);
}
  3. 配置服务器地址和端口： 定义和配置服务器的套接字地址信息，包括 IP 地址和端口号。
    struct sockaddr_in server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // Use any available network interface
server_addr.sin_port = htons(PORT);  // Define the port number
  4. 绑定套接字： 使用 bind() 函数将套接字与指定的地址和端口绑定。
    if (bind(socket_fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1) {
    perror("Binding failed");
    exit(EXIT_FAILURE);
}
  5. 监听连接请求： 使用 listen() 函数开始监听传入的连接请求。参数指定了允许排队的连接请求的最大数量。
    if (listen(socket_fd, BACKLOG) == -1) {
    perror("Listening failed");
    exit(EXIT_FAILURE);
}
  6. 接受连接： 使用 accept() 函数接受传入的连接请求，创建一个新的套接字用于与客户端进行通信。
    struct sockaddr_in client_addr;
socklen_t addr_len = sizeof(client_addr);
int client_socket_fd = accept(socket_fd, (struct sockaddr *)&client_addr, &addr_len);
if (client_socket_fd == -1) {
    perror("Accepting failed");
    exit(EXIT_FAILURE);
}
  7. 接收和发送数据： 使用新创建的客户端套接字进行数据的接收和发送，使用 recv() 函数接收数据，使用 send() 函数发送数据。
    char buffer[MAX_BUFFER_SIZE];
ssize_t bytes_received = recv(client_socket_fd, buffer, sizeof(buffer), 0);
if (bytes_received == -1) {
    perror("Receive failed");
    exit(EXIT_FAILURE);
}

// Process and handle received data...

ssize_t bytes_sent = send(client_socket_fd, buffer, bytes_received, 0);
if (bytes_sent == -1) {
    perror("Send failed");
    exit(EXIT_FAILURE);
}
  8. 关闭套接字： 在不再需要套接字时，使用 close() 函数关闭套接字。
    close(client_socket_fd);
close(socket_fd);

如何实现并发服务器模型？优缺点?

服务器模型分为两种：循环服务器，并发服务器
循环服务器：循环服务器在同一个时刻只能相应一个客户端请求
并发服务器：并发服务器在同一个时刻可以相应多个客户端的请求
TCP服务器默认是循环服务器，因为TCP服务器有两个读阻塞函数accept和recv，这两个函数默认无法独立执行，所以无法实现并发
UDP默认是并发服务器，因为udp只有一个读阻塞函数recvfrom
如何实现TCP并发服务器？
方法1：使用多线程实现并发服务器
缺点:
线程的个数受限（硬件资源(内存)，操作系统资源(pid号)） --解决方法:线程池
当客户端不与服务器交互时，此时资源消耗;(所有创建的读线程不断切换)–解决方法:IO多路复用
优点:
高性能(最优)
方法2：使用多进程实现并发服务器
缺点:
1、开销大(创建开销、通信开销、切换开销)，
2、进程的个数受限（硬件资源(内存)，操作系统资源(pid号) ）–解决方法:进程池
3、当客户端不与服务器交互时，此时资源消耗;(所有创建的读进程不断切换)–解决方法:IO多路复用
优点:
高并发（最优)

close vs shutdown区别?

close() 和 shutdown() 都是用于关闭套接字（socket）连接的函数，但它们在行为和用法上有一些区别。

1. close():

  • close() 用于关闭套接字连接。它会关闭套接字的读写功能，并释放与该套接字相关的资源。
  • 调用 close() 后，不能再对该套接字进行任何读写操作。
  • 如果套接字有其他正在使用的引用（例如，其他线程或进程仍在使用套接字），close() 并不会立即销毁套接字，而是将套接字的引用计数减一。只有当没有引用时，套接字才会被真正关闭和销毁。

2. shutdown():

  • shutdown() 用于关闭套接字的一部分功能，即可以关闭读功能、写功能或同时关闭读写功能。
  • 它的参数可以是 SHUT_RD（关闭读功能）、SHUT_WR（关闭写功能）或 SHUT_RDWR（同时关闭读写功能）。
  • 调用 shutdown() 后，套接字的某些功能将被关闭，但套接字本身并不会被销毁。可以继续使用未关闭的功能，但已关闭的功能将无法使用。

总结：

  • 如果您希望完全关闭套接字并释放相关资源，应该使用 close() 函数。
  • 如果您希望关闭套接字的部分功能，例如只关闭写功能或读功能，可以使用 shutdown() 函数，并根据需要指定相应的参数。
  • 在一些情况下，例如多线程或多进程环境中，可能需要注意关闭套接字的正确顺序和时机，以避免资源泄漏或竞争条件。

嵌入式数据库的特点?有哪些数据库可以作为嵌入式数据库?

数据存储的方式:文件VS 数据库
文件缺点:1、无格式（操作复杂、查找性能低）2、安全性
数据库(DataBase，简记为DB)就是一个有结构的、集成的、可共亨的统管理的数据集合。它不仅包括数据本身，而且包括相关数据之间的联系。数据库技术主要研究如何存储、使用和管理数据;
数据库的特点：
可视化，数据保存有格式，便于查找，操作方便
不需要配置，不需要安装和管理
提供了简单和易于使用的API
可跨平台使用
有哪些数据库课作为嵌入式数据库？
目前有许多数据库产品，如Oracle、SQL Server、DB2、MySQL 、Access，SQLite3等产品各以自己特有的功能，在数据库市场上占有一席之地。

SQL语句的使用（常用的SQL语句)

这些函数是 SQLite C/C++ 接口中常用的函数，用于在应用程序中操作 SQLite 数据库。以下是对这些函数的简要介绍：

  1. *sqlite3_open(const char filename, sqlite3 ppDb):
    • 用于打开或创建一个 SQLite 数据库文件。
    • filename 参数是数据库文件的名称。
    • ppDb 参数是一个指向 SQLite 数据库指针的指针，用于接收数据库连接句柄。
    • 返回值表示操作是否成功。
  2. sqlite3_close(sqlite3 pDb):
    • 用于关闭先前打开的 SQLite 数据库连接。
    • pDb 参数是要关闭的数据库连接句柄。
    • 返回值表示操作是否成功。
  3. sqlite3_exec(sqlite3 db, const char sql, int (callback)(void, int, char, char), void *data, char errmsg):
    • 用于执行一个 SQL 查询语句（例如，SELECT、INSERT、UPDATE 等）。
    • db 参数是数据库连接句柄。
    • sql 参数是要执行的 SQL 查询语句。
    • callback 参数是一个回调函数，用于处理查询结果（可以为 NULL，不需要处理结果时可省略）。
    • data 参数是传递给回调函数的用户数据。
    • errmsg 参数是一个指向错误消息的指针，用于接收执行中的错误信息。
    • 返回值表示操作是否成功。
  4. **sqlite3_get_table(sqlite3 *db, const char *sql, char ***result, int nrow, int ncolumn, char **errmsg):
    • 用于执行一个 SQL 查询语句，并将结果存储在一个表格中。
    • db 参数是数据库连接句柄。
    • sql 参数是要执行的 SQL 查询语句。
    • result 参数是一个指向结果表格的指针，将存储查询结果。
    • nrow 参数用于接收表格的行数。
    • ncolumn 参数用于接收表格的列数。
    • errmsg 参数是一个指向错误消息的指针，用于接收执行中的错误信息。
    • 返回值表示操作是否成功。
  5. sqlite3_free_table(char result):
    • 用于释放 sqlite3_get_table() 函数分配的结果表格内存。
    • result 参数是要释放的表格指针。

这些函数是 SQLite C/C++ 接口中的一部分，用于方便地在应用程序中进行数据库操作。它们提供了打开数据库、执行查询、获取查询结果等功能。使用这些函数可以进行数据库的增、删、改、查等操作，使得应用程序能够与 SQLite 数据库进行交互。

自旋锁和互斥锁的区别

互斥锁，顾名思义，当一个线程加互斥锁成功后，其他准备加锁的线程会加锁失败，实现同一时间内只有一个线程在占用CPU，避免多线程占用共享资源而出现错误，其他线程加锁失败后会有用户态转到内核态，内核会将线程转为睡眠状态，加锁成功的线程将锁释放掉之后内核会将其他处于睡眠状态的线程唤醒；
自旋锁，区别于互斥锁，只在用户态进行加锁和解锁的操作，不会进行进程间上下文切换，减少了进程间的开销，没有加锁的进程会处于忙等待状态，不会进入睡眠状态。

你可能感兴趣的:(linux,c语言,面试,考研)

  • 2020最新大厂内部 PHP 高级工程师面试题汇总（一） it阿布
    1、给你四个坐标点，判断它们能不能组成一个矩形，如判断([0,0],[0,1],[1,1],[1,0])能组成一个矩形。勾股定理，矩形是对角线相等的四边形。只要任意三点不在一条直线上，任选一点，求这一点到另外三点的长度的平方，两个短的之和如果等于最长的，那么这就是矩形。2、写一段代码判断单向链表中有没有形成环，如果形成环，请找出环的入口处，即P点/**单链表的结点类*/classLNode{//为
  • 高级java每日一道面试题-2024年8月30日-基础篇-你对泛型了解多少? java我跟你拼了 java每日一道面试题java泛型基础篇面试高级面试题java高级
    如果有遗漏,评论区告诉我进行补充面试官:你对泛型了解多少?我回答:泛型的基本概念泛型是一种编程语言特性，它允许在类、接口或方法定义时使用类型参数（TypeParameters）。类型参数允许在编译时指定具体的类型，从而避免了运行时类型检查和转换带来的性能开销，并且增强了代码的类型安全性。语法类型参数通常用大写字母表示，如T、E等。在类或接口定义时，类型参数放在类名或接口名后面，用尖括号包围。在方法
  • 【MYSQL】在MySQL中设置 max_allowed_packet、wait_timeout 和 interactive_timeout 丶2136 web数据库mysql数据库后端
    目录重要配置参数临时设置参数1.使用SQL语句设置1.检查当前设置持久化设置修改配置文件在Linux上重启MySQL服务：在Windows上重启MySQL服务：注意事项示例：使用BLOB存储大数据总结解决连接断开问题的总结在处理大于1MB的数据时，MySQL数据库可能会遇到连接断开的问题。此类问题通常与几个重要的配置参数有关，包括max_allowed_packet、wait_timeout和in
  • linux: 管理GPG密钥的实用指南 运维开发王义杰 软件开发系统运维安全linuxchrome运维
    在软件开发和系统管理中，GPG（GNUPrivacyGuard）是一种常用的加密工具，用于加密数据、创建和验证数字签名等。为了简化GPG密钥的管理，我们可以编写Bash脚本自动化地生成、导出、删除GPG密钥。本文将介绍一个实用的Bash脚本，帮助你轻松管理GPG公钥和私钥。1.脚本功能概述这个脚本的主要功能包括：自动生成GPG密钥对。列出当前系统中的GPG密钥。导出生成的GPG公钥和私钥。自动删除
  • 高鸿业宏观经济学第七版课后答案 zgxxw 课后习题答案深度学习
    完整版：http://zgw.100xuexi.com/SubItem/IndexInfoDetail.aspx?id=97adebda-f4df-4cf8-bdc2-e5e4a690128a第12章 宏观经济的基本指标及其衡量12.1 复习笔记12.2 课后习题详解12.3 名校考研真题详解第13章 国民收入的决定：收入-支出模型13.1 复习笔记13.2 课后习题详解13.3 名校考研真题详解
  • Redis基础知识学习笔记（一） 晚睡早起₍˄·͈༝·͈˄*₎◞ ̑̑ redisredis学习笔记
    文章目录Redis简介Redis简介REmoteDIctionaryServer(Redis)是一个由SalvatoreSanfilippo写的key-value存储系统，是跨平台的非关系型数据库,其是一个开源的使用ANSIC语言编写、遵守BSD协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的API。Redis通常被称为数据结构服务器，因为值
  • 2024最新最全的React面试题 二丫骑士qq react.js前端前端框架
    1.react和vue的区别？(1)设计理念:React:更倾向于函数式编程思想，推崇组件的不可变性和单向数据流。Vue:结合了响应式编程和模板系统，致力于简化开发过程。(2)核心库与生态系统:React:React本身只关注UI层，但它有一个庞大的生态系统，例如Redux、MobX等用于状态管理，以及ReactRouter用于路由处理。Vue:Vue是一个更完整的解决方案，它的核心库除了视图层，
  • react面试题＋答案 abc8002117034 javascript前端react.js
    1.什么是虚拟DOM？虚拟DOM是真实DOM在内存中的表示，ul的表示形式保存在内存中，并且与实际的DOM同步，这是一个发生在渲染函数被调用和元素在屏幕上显示的步骤，整个过程被称为调和2.类组件和函数组件之间的区别是什么？类组件可以使用其他特性，如状态和生命周期钩子，并且他有this函数组件只能接收props渲染到页面，无状态组件，没有this，不能使用生命周期钩子函数组件性能要高于类组件，因为类
  • 2024版最新最全React面试题 2401_84618790 react.js前端javascript
    );};上面代码中，输入框和checkbox的变化，均是经过了React来操作的，在数据变更时，React是能够知道的。####高阶组件（HOC）？####高阶组件？高阶组件通过包裹（wrapped）被传入的React组件，经过一系列处理，最终返回一个相对增强（enhanced）的React组件，供其他组件调用。作用：1.复用逻辑：高阶组件更像是一个加工react组件的工厂，批量对原有组件进行加工
  • react面试题六 笃励 react.js前端前端框架
    一、React中如何捕获和处理错误？在React中，捕获和处理错误是一个重要的部分，以确保应用的健壮性和用户体验。React提供了几种机制来捕获和处理错误，包括错误边界（ErrorBoundaries）、事件处理器中的try/catch语句、以及React17中引入的并发模式（ConcurrentMode）下的新特性（尽管后者主要面向未来，目前许多项目可能还未采用）。下面是一些常用的方法：1.错误
  • 【Linux】Linux系统性能调优技巧 大雨淅淅 linuxlinux
    目录一、Linux系统性能指标二、Linux系统性能调优技巧2.1保持系统更新2.2磁盘I/O性能优化2.3内存管理调整2.4关闭不必要的服务2.5进程资源限制2.6网络性能调整2.7监控和分析工具2.8编译器优化2.9预读取和写入缓存2.10内核参数调整2.11性能分析工具2.12NUMA优化2.13数据库性能调优2.14使用交换空间2.15更新和维护2.16负载均衡和分布式计算2.17使用固态
  • C语言程序设计：将字符串写入文件 老侯（Old monkey） c语言课程设计
    从键盘输入一个字符串，将其中的小写字母全部转换为大写字母，然后输出到一个磁盘文件“text”中保存，输入的字符以'!'结束。1.定义相关变量charstr[N];//定义字符数组，用于存储字符串charc;//定义字符变量，用于接收从键盘输入的字符FILE*fp;//定义文件类型指针，用于指向文件信息区inti;//定义整型变量，用于循环2.从键盘输入字符利用for循环从键盘输入字符，当输入字符'
  • react面试题七 笃励 react.jsjavascript前端
    一、请解释React的shouldComponentUpdate的作用。shouldComponentUpdate是React组件生命周期中的一个方法，用于决定一个组件在接收到新的props或state时是否应该重新渲染。这是React性能优化的一个关键工具，特别是在组件树变得复杂和深层时。基本原理默认情况下，当组件的props或state发生变化时，React会准备更新组件的DOM。但是，在许多
  • Linux进程间通信：信号(signal) D.• Linux进程通信Linux进程c语言c++开发语言linux服务器
    目录信号说明一信号发送①raise函数②kill函数③alarm函数二信号接收while函数：sleep函数：pause函数：三信号处理signal函数信号说明在Linux中，①信号可以简单理解为软中断，许多重要的程序都需要处理信号。信号，为Linux提供了一种处理异步事件的方法。比如，终端用户输入了ctrl+c来中断程序，会通过信号机制停止一个程序。②信号也是进程间通信的一种方式，也是如此，进程
  • Spring Cloud Gateway面试题 golove666 面试题大全微服务springcloud面试网关gateway
    SpringCloudGateway面试题1.SpringCloudGateway基本概念1.1什么是SpringCloudGateway？1.2SpringCloudGateway和Zuul有什么区别？1.3SpringCloudGateway的核心组件有哪些？1.4为何需要使用API网关？2.路由和过滤器2.1如何在SpringCloudGateway中配置路由？声明性配置编程式配置注意2.2
  • linux：网络编程之TCP htx nb 网络linuxtcp/ip数据库c语言
    一、三个模型1.B/S（Browser/Server）模型定义：B/S模型是一种网络架构模式，其中用户通过网页浏览器（如Chrome、Firefox等）来访问和使用服务器上的应用程序或数据。特点：简化用户访问：用户无需下载和安装专门的客户端软件，只需通过浏览器即可访问系统。跨平台性：由于基于浏览器，因此可以跨多个操作系统和平台使用。维护和升级方便：所有的维护和升级工作都在服务器端进行，减少了客户端
  • 冲刺蓝桥杯第一章输入与输出 CodeWizard～ 编程征途·蓝桥风云录蓝桥杯职场和发展算法c++
    取消同步流加速cin/cout运行时间cin与cout是C++提供的函数输入输出方便但速度较慢，所以需要用指令进行输入输出加速，切记使用加速命令后不要同时使用cin/cout与scanf/printf。ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);scanf与printf其实是C语言提供的函数。大多数情况下，它们的速度比cin和cout更快，并且能够
  • 云计算：LNMP网站架构，前期准备，安装php，安装MySQL 248 云计算phpmysql
    准备工作（初始化）1.关闭防火墙systemctldisablefirewalld--now//直接永久关闭防火墙2.关闭SELINUX查看SELINUX:getenforce永久关闭：[root@localhost~]#vim/etc/selinux/configSELINUX=enforcing|disabled或者[root@localhost~]#sed-i's/^SELINUX=.*/S
  • Redis 系列（二）Redis 安装 后端小哥 Redis系列redis
    Redis全称：RemoteDictionaryServer(远程字典服务器)，是完全开源免费的，用C语言编写的，遵守BSD协议，是一个高性能的(key/value)分布式内存数据库，基于内存运行并支持持久化的NoSQL数据库，是当前最热门的NoSql数据库之一，也被人们称为数据结构服务器。1.Redis介绍官方网站https://redis.iohttp://www.redis.cnRedis与
  • 大厂面试官：讲讲Redis的过期策略吧，不要泛泛而谈，详细点 暮起 Redisredis数据库缓存数据结构面试java后端
    大厂常问面试题，Redis的过期策略，你了解多少？希望大家能关注点赞，创作不易且没收益，您的小小举动却能给予我大大的鼓励，会激励我继续创作出高质量文章，更多内容可看我主页～Redis的过期策略如何设置过期时间？先说一下对key设置过期时间的命令。设置key过期时间的命令一共有4个：expire：设置key在n秒后过期，比如expirekey100表示设置key在100秒后过期；pexpire：设置
  • 基于RK3568平台opencv的图像采集、ffmpeg推流和Windows端拉流(多线程) 嵌入式专业户 图像处理相关移植及应用opencvffmpegwindows
    目录一、概述二、环境要求2.1硬件环境2.2软件环境三、移植流程3.1编写测试3.2验证功能一、概述本章节是针对ffmpeg移植到Linux系统，运行在RK3568开发板上，首先创建一个线程opencv通过摄像头采集视频图像，接着再创建两个线程，其中一个线程获取采集的视频图像送给ffmpeg服务，另一个线程用于获取采集的视频图像并处理，详细的流程请参看如下。Windows端使用VLCmediapl
  • 【Linux函数】命令行参数解析函数 April.19th 嵌入式Linuxc语言linux
    文章目录前言版本迭代参考文档命令行参数getopt()getopt_long()getopt_long_only()总结前言每个开源代码的main函数中都有一个命令行参数解析函数，今天特意参考各种博客资料总结一下。版本迭代时间版本版本更新2024.8.26V1.0初始版本参考文档1.https://blog.csdn.net/qq_41816308/article/details/13289963
  • 3.1.2 linux用户管理 : 常用查询 (debian和RedHat通用) ： 用户组查询 阳光的王小潮
    3.1.2linux用户管理:常用查询(debian和RedHat通用)：用户组查询1.常用命令$groups##查看当前用户所属用户组$cat/etc/group##查看所有的用户组$cat/etc/group|grepsgx##查看指定用户组2.查看当前用户所属用户组$groupssgxadmcdromsudodipplugdevlpadminsambashare3.查看用户组(所有)$cat
  • 字符串操作相关函数(C语言) Beginner_bml c语言开发语言
    目录头文件strlenstrcpystrcatstrcmpstrchrstrstratoXstrtoksprintfsscanf头文件string.hstrlen作用:测量字符串长度语法:size_tstrlen(constchar*s);参数:要测量的字符串(必须是一个以空字符结尾的字符数组或字符指针。)返回值长度注意:测量的长度不包括\0和空字符strcpy作用:拷贝字符串(深拷贝)语法:ch
  • tcp 网络通信及抓包工具的使用 喵了d喵 学习linuxc语言
    tcp网络通信本地回环（Loopback）的概念本地回环地址是一个特殊的IP地址，用于指向计算机本身的网络接口。在IPv4中，最常见的本地回环地址是127.0.0.1，而在IPv6中则是::1。这个地址用于测试网络软件，确保网络协议栈在本地计算机上正确运行，而不涉及实际的网络硬件。本地回环地址通常与一个虚拟的网络接口关联，在Linux系统中这个接口被称为lo。本地回环的作用和重要性本地回环接口允许
  • 微服务中间件之Nacos-安装篇 java_heartLake 中间件微服务中间件架构
    Nacos（DynamicNamingandConfigurationService）是由阿里巴巴开发的一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。以下是Nacos的安装说明，主要适用于Linux/macOS系统以及Windows系统（以最新版本的Nacos为例，具体版本可能会随时间更新）：一、准备工作1、下载Nacos安装包访问Nacos的GitHub仓库或官方网站，下载最新
  • 地域年龄影响着闲聊 殇情小生
    农村里长大，经过高中三年，不负众望考上了大学。四年毕业后，由于自己大学期间的不上进，只能现在回到家，从新准备考研。但是这次回到家里，人还是那些人，但是我的心境确实不那么一样了，也可能是随着时间的逝去，在一年一年的长大，也可能是大学期间所接触的东西不一样了，有些事就在潜移默化之间改变了，曾经习惯的那些长辈的闲聊，在此刻的我看来是那么苍白无聊，甚至会有排挤。长大了，就会想着比较多，想着要好好赚钱，好好
  • 《Linux就该这么学》学习笔记——Day13 ggsddu_mmm Linux学习笔记
    简介本章节主要讲解nmtui命令配置网络参数管理网络会话服务以及手工绑定mode6模式双网卡，实现网络的负载均衡。同时深入介绍了SSH协议与sshd服务程序的理论知识以及实验演示Linux系统的远程管理方和配置服务程序的方法，并使用screen服务程序远程管理Linux系统的不间断会话等技术。参考：https://www.linuxprobe.com/chapter-09.html命令行详解可参考
  • Linux基础入门 LIPAH linux运维服务器
    课程链接：黑马程序员新版Linux零基础快速入门到精通，全涵盖linux系统知识、常用软件环境部署、Shell脚本、云平台实践、大数据集群项目实战等_哔哩哔哩_bilibili声明：该文章为本人的学习笔记，非专业教程目录声明：本文章为本人的学习笔记，非正版教程第一章概述操作系统概述硬件和软件操作系统初始LinuxLinux诞生Linux内核Linux发行版虚拟机概念VMwareWorkStatio
  • Linux 使用 docker 安装 MinIO 分布式对象存储系统 liupeng_blog dockerdockerlinux分布式
    文章目录个人知识库MinIO简介环境要求一.新建文件目录1.1.新建docker-compose.yml1.2.编写docker-compose.yml二.文件赋权限三.启动容器3.1.启动并下载镜像3.2.停止并删除容器四.访问五.DockerHub官网更多知识平台个人知识库云网站：http://www.liupeng.cloud语雀：https://www.yuque.com/liupeng_
  • mongodb3.03开启认证 21jhf mongodb
    下载了最新mongodb3.03版本，当使用--auth 参数命令行开启mongodb用户认证时遇到很多问题，现总结如下： （百度上搜到的基本都是老版本的，看到db.addUser的就是，请忽略） Windows下我做了一个bat文件，用来启动mongodb，命令行如下： mongod --dbpath db\data --port 27017 --directoryperdb --logp
  • 【Spark103】Task not serializable bit1129 Serializable
    Task not serializable是Spark开发过程最令人头疼的问题之一，这里记录下出现这个问题的两个实例，一个是自己遇到的，另一个是stackoverflow上看到。等有时间了再仔细探究出现Task not serialiazable的各种原因以及出现问题后如何快速定位问题的所在，至少目前阶段碰到此类问题，没有什么章法 1.   package spark.exampl
  • 你所熟知的 LRU(最近最少使用) dalan_123 java
    关于LRU这个名词在很多地方或听说，或使用，接下来看下lru缓存回收的实现 1、大体的想法     a、查询出最近最晚使用的项     b、给最近的使用的项做标记 通过使用链表就可以完成这两个操作，关于最近最少使用的项只需要返回链表的尾部；标记最近使用的项，只需要将该项移除并放置到头部，那么难点就出现 你如何能够快速在链表定位对应的该项？ 这时候多
  • Javascript 跨域 周凡杨 JavaScriptjsonp跨域cross-domain
                                       
  • linux下安装apache服务器 g21121 apache
    安装apache 下载windows版本apache，下载地址：http://httpd.apache.org/download.cgi   1.windows下安装apache Windows下安装apache比较简单，注意选择路径和端口即可，这里就不再赘述了。 2.linux下安装apache： 下载之后上传到linux的相关目录，这里指定为/home/apach
  • FineReport的JS编辑框和URL地址栏语法简介 老A不折腾 finereportweb报表报表软件语法总结
      JS编辑框： 1.FineReport的js。 作为一款BS产品，browser端的JavaScript是必不可少的。 FineReport中的js是已经调用了finereport.js的。 大家知道，预览报表时，报表servlet会将cpt模板转为html，在这个html的head头部中会引入FineReport的js，这个finereport.js中包含了许多内置的fun
  • 根据STATUS信息对MySQL进行优化 墙头上一根草 status
    mysql  查看当前正在执行的操作，即正在执行的sql语句的方法为:      show processlist 命令   mysql> show global status;可以列出MySQL服务器运行各种状态值，我个人较喜欢的用法是show status like '查询值%';一、慢查询mysql> show variab
  • 我的spring学习笔记7-Spring的Bean配置文件给Bean定义别名 aijuans Spring 3
    本文介绍如何给Spring的Bean配置文件的Bean定义别名？ 原始的 <bean id="business" class="onlyfun.caterpillar.device.Business"> <property name="writer"> <ref b
  • 高性能mysql 之 性能剖析 annan211 性能mysqlmysql 性能剖析剖析
    1 定义性能优化 mysql服务器性能，此处定义为 响应时间。 在解释性能优化之前，先来消除一个误解，很多人认为，性能优化就是降低cpu的利用率或者减少对资源的使用。 这是一个陷阱。 资源时用来消耗并用来工作的，所以有时候消耗更多的资源能够加快查询速度，保持cpu忙绿，这是必要的。很多时候发现 编译进了新版本的InnoDB之后，cpu利用率上升的很厉害，这并不
  • 主外键和索引唯一性约束 百合不是茶 索引唯一性约束主外键约束联机删除
    目标;第一步;创建两张表 用户表和文章表         第二步;发表文章       1,建表; ---用户表 BlogUsers --userID唯一的 --userName --pwd --sex create
  • 线程的调度 bijian1013 java多线程thread线程的调度java多线程
    1.       Java提供一个线程调度程序来监控程序中启动后进入可运行状态的所有线程。线程调度程序按照线程的优先级决定应调度哪些线程来执行。   2.       多数线程的调度是抢占式的（即我想中断程序运行就中断，不需要和将被中断的程序协商） a) 
  • 查看日志常用命令 bijian1013 linux命令unix
    一.日志查找方法，可以用通配符查某台主机上的所有服务器grep "关键字" /wls/applogs/custom-*/error.log   二.查看日志常用命令1.grep '关键字' error.log：在error.log中搜索'关键字'2.grep -C10 '关键字' error.log：显示关键字前后10行记录3.grep '关键字' error.l
  • 【持久化框架MyBatis3一】MyBatis版HelloWorld bit1129 helloworld
    MyBatis这个系列的文章，主要参考《Java Persistence with MyBatis 3》。   样例数据 本文以MySQL数据库为例，建立一个STUDENTS表，插入两条数据，然后进行单表的增删改查     CREATE TABLE STUDENTS ( stud_id int(11) NOT NULL AUTO_INCREMENT,
  • 【Hadoop十五】Hadoop Counter bit1129 hadoop
       1. 只有Map任务的Map Reduce Job File System Counters FILE: Number of bytes read=3629530 FILE: Number of bytes written=98312 FILE: Number of read operations=0 FILE: Number of lar
  • 解决Tomcat数据连接池无法释放 ronin47 tomcat 连接池　优化
    近段时间，公司的检测中心报表系统(SMC)的开发人员时不时找到我，说用户老是出现无法登录的情况。前些日子因为手头上 有Jboss集群的测试工作，发现用户不能登录时，都是在Tomcat中将这个项目Reload一下就好了，不过只是治标而已，因为大概几个小时之后又会 再次出现无法登录的情况。 今天上午，开发人员小毛又找到我，要我协助将这个问题根治一下，拖太久用户难保不投诉。 简单分析了一
  • java-75-二叉树两结点的最低共同父结点 bylijinnan java
    import java.util.LinkedList; import java.util.List; import ljn.help.*; public class BTreeLowestParentOfTwoNodes { public static void main(String[] args) { /* * node data is stored in
  • 行业垂直搜索引擎网页抓取项目 carlwu LuceneNutchHeritrixSolr
    公司有一个搜索引擎项目，希望各路高人有空来帮忙指导，谢谢！ 这是详细需求： （1） 通过提供的网站地址(大概100-200个网站)，网页抓取程序能不断抓取网页和其它类型的文件（如Excel、PDF、Word、ppt及zip类型），并且程序能够根据事先提供的规则，过滤掉不相干的下载内容。 （2） 程序能够搜索这些抓取的内容，并能对这些抓取文件按照油田名进行分类，然后放到服务器不同的目录中。
  • [通讯与服务]在总带宽资源没有大幅增加之前,不适宜大幅度降低资费 comsci 资源
          降低通讯服务资费，就意味着有更多的用户进入，就意味着通讯服务提供商要接待和服务更多的用户，在总体运维成本没有由于技术升级而大幅下降的情况下，这种降低资费的行为将导致每个用户的平均带宽不断下降，而享受到的服务质量也在下降，这对用户和服务商都是不利的。。。。。。。。     &nbs
  • Java时区转换及时间格式 Cwind java
    本文介绍Java API 中 Date, Calendar, TimeZone和DateFormat的使用，以及不同时区时间相互转化的方法和原理。   问题描述： 向处于不同时区的服务器发请求时需要考虑时区转换的问题。譬如，服务器位于东八区（北京时间，GMT+8:00），而身处东四区的用户想要查询当天的销售记录。则需把东四区的“今天”这个时间范围转换为服务器所在时区的时间范围。
  • readonly,只读，不可用 dashuaifu jsjspdisablereadOnlyreadOnly
    readOnly 和 readonly 不同，在做js开发时一定要注意函数大小写和jsp黄线的警告！！！我就经历过这么一件事： 使用readOnly在某些浏览器或同一浏览器不同版本有的可以实现“只读”功能，有的就不行，而且函数readOnly有黄线警告！！！就这样被折磨了不短时间！！！（期间使用过disable函数，但是发现disable函数之后后台接收不到前台的的数据！！！）  
  • LABjs、RequireJS、SeaJS 介绍 dcj3sjt126com jsWeb
    LABjs 的核心是 LAB（Loading and Blocking）：Loading 指异步并行加载，Blocking 是指同步等待执行。LABjs 通过优雅的语法（script 和 wait）实现了这两大特性，核心价值是性能优化。LABjs 是一个文件加载器。RequireJS 和 SeaJS 则是模块加载器，倡导的是一种模块化开发理念，核心价值是让 JavaScript 的模块化开发变得更
  • [应用结构]入口脚本 dcj3sjt126com PHPyii2
    入口脚本 入口脚本是应用启动流程中的第一环，一个应用（不管是网页应用还是控制台应用）只有一个入口脚本。终端用户的请求通过入口脚本实例化应用并将将请求转发到应用。 Web 应用的入口脚本必须放在终端用户能够访问的目录下，通常命名为 index.php，也可以使用 Web 服务器能定位到的其他名称。 控制台应用的入口脚本一般在应用根目录下命名为 yii（后缀为.php），该文
  • haoop shell命令 eksliang hadoophadoop shell
    cat chgrp chmod chown copyFromLocal copyToLocal cp du dus expunge get getmerge ls lsr mkdir movefromLocal mv put rm rmr setrep stat tail test text
  • MultiStateView不同的状态下显示不同的界面 gundumw100 android
    只要将指定的view放在该控件里面，可以该view在不同的状态下显示不同的界面，这对ListView很有用，比如加载界面，空白界面，错误界面。而且这些见面由你指定布局，非常灵活。 PS：ListView虽然可以设置一个EmptyView，但使用起来不方便，不灵活，有点累赘。 <com.kennyc.view.MultiStateView xmlns:android=&qu
  • jQuery实现页面内锚点平滑跳转 ini JavaScripthtmljqueryhtml5css
    平时我们做导航滚动到内容都是通过锚点来做，刷的一下就直接跳到内容了，没有一丝的滚动效果，而且 url 链接最后会有“小尾巴”，就像#keleyi，今天我就介绍一款 jquery 做的滚动的特效，既可以设置滚动速度，又可以在 url 链接上没有“小尾巴”。   效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/37.htmHTML文件代码： &
  • kafka offset迁移 kane_xie kafka
    在早前的kafka版本中（0.8.0），offset是被存储在zookeeper中的。   到当前版本（0.8.2）为止，kafka同时支持offset存储在zookeeper和offset manager（broker）中。   从官方的说明来看，未来offset的zookeeper存储将会被弃用。因此现有的基于kafka的项目如果今后计划保持更新的话，可以考虑在合适
  • android > 搭建 cordova 环境 mft8899 android
      1 , 安装 node.js        http://nodejs.org      node -v   查看版本   2, 安装 npm   可以先从  https://github.com/isaacs/npm/tags  下载 源码 解压到
  • java封装的比较器，比较是否全相同，获取不同字段名字 qifeifei
     非常实用的java比较器，贴上代码： import java.util.HashSet; import java.util.List; import java.util.Set; import net.sf.json.JSONArray; import net.sf.json.JSONObject; import net.sf.json.JsonConfig; i
  • 记录一些函数用法 .Aky. 位运算PHP数据库函数IP
    高手们照旧忽略。 想弄个全天朝IP段数据库，找了个今天最新更新的国内所有运营商IP段，copy到文件，用文件函数，字符串函数把玩下。分割出startIp和endIp这样格式写入.txt文件，直接用phpmyadmin导入.csv文件的形式导入。（生命在于折腾，也许你们觉得我傻X，直接下载人家弄好的导入不就可以，做自己的菜鸟，让别人去说吧） 当然用到了ip2long()函数把字符串转为整型数
  • sublime text 3 rust wudixiaotie Sublime Text
    1.sublime text 3 => install package => Rust 2.cd ~/.config/sublime-text-3/Packages 3.mkdir rust 4.git clone https://github.com/sp0/rust-style 5.cd rust-style 6.cargo build --release 7.ctrl
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他