C/C++ 全方位笔试题库

阿里数据集(cluster-trace-v2018)提取 阿里数据集提取 本数据集采用的是阿里集群数据集-2018 详情可参考该文献:https://blog.youkuaiyun.com/weixin_41988248/article/details/92431588 CSV数据集提取操作见:https://blog.youkuaiyun.com/lucky_shi/article/details/105321149 关于read_csv包的用法见:https://blog.youkuaiyun.com/dc19971118/article/details/107721340 从阿里数据集来看,我 阅读详情

📋 试卷结构

部分题型题量分值
第一部分C语言基础35题75分
第二部分C++核心特性25题50分
第三部分数据结构与算法20题40分
第四部分Linux系统编程15题30分
第五部分网络编程10题20分
第六部分智力与逻辑5题10分
合计110题225分

详细题型分布

第一部分:C语言基础(35题,75分)
  • 选择题:10题 × 2分 = 20分
  • 填空题:2题 × 5分 = 10分
  • 简答题:2题 × 5分 = 10分
  • 编程题:1题 × 10分 = 10分
  • 程序分析题:5题 × 3分 = 15分
  • 判断题:10题 × 1分 = 10分

第二部分:C++核心特性(25题,50分))

  • 选择题:10题 × 2分 = 20分
  • 填空题:2题 × 5分 = 10分
  • 简答题:2题 × 5分 = 10分
  • 编程题:1题 × 10分 = 10分
第三部分:数据结构与算法(20题,40分)
  • 选择题:10题 × 2分 = 20分
  • 简答题:2题 × 5分 = 10分
  • 编程题:1题 × 10分 = 10分
第四部分:Linux系统编程(15题,30分)
  • 选择题:6题 × 2分 = 12分
  • 简答题:3题 × 6分 = 18分
第五部分:网络编程(10题,20分)
  • 选择题:6题 × 2分 = 12分
  • 简答题:2题 × 4分 = 8分

第六部分:智力与逻辑(5题,10分))

  • 选择题/简答题:5题 × 2分 = 10分

本题库基于实际面试经验和技术需求整理,旨在帮助您:

  • 系统复习C/C++核心概念
  • 掌握常见面试题型和解题思路
  • 提升编程思维和问题解决能力
  • 为技术面试做好充分准备

题库内容经过精心编排,难度梯度合理,既适合初学者巩固基础,也适合有经验的开发者查漏补缺。

📝 考试说明

考试基本信息

  • 考试时长:建议120分钟
  • 总分:225分
  • 题量:110题
  • 及格线:135分(60%)
  • 优秀线:180分(80%)

题型与分值分布

  1. 选择题:每题2分,共40题,80分
  2. 填空题:每空2分,共5题,10分
  3. 判断题:每题1分,共10题,10分
  4. 简答题:每题5分,共8题,40分
  5. 编程题:每题10分,共3题,30分
  6. 程序分析题:每题3分,共5题,15分
  7. 智力与逻辑题:每题2分,共5题,10分

答题要求

  1. 选择题、填空题、判断题请在答题卡上填写正确答案
  2. 简答题需简明扼要,突出重点
  3. 编程题需写出完整代码,并考虑边界条件和错误处理
  4. 程序分析题需分析代码逻辑、内存布局或输出结果
  5. 智力题需写出推理过程和最终答案

评分标准

  • 选择题、填空题、判断题:答案正确即得满分
  • 简答题:根据要点给分,关键概念缺失会扣分
  • 编程题:功能完整、边界处理正确、代码规范可得分
  • 程序分析题:分析准确、逻辑清晰可得分
  • 智力题:推理过程正确、答案准确可得分

注意事项

  1. 考试期间不得查阅任何参考资料
  2. 编程题可使用任意IDE编写,但需提交最终代码
  3. 简答题和程序分析题需手写答案
  4. 考试结束后请检查个人信息和答题卡完整性

📋 试卷结构

部分题型题量分值
第一部分C语言基础35题75分
第二部分C++核心特性25题50分
第三部分数据结构与算法20题40分
第四部分Linux系统编程15题30分
第五部分网络编程10题20分
第六部分智力与逻辑5题10分
合计110题225分
## 第一部分:C语言基础(25题,50分)0分)

一、选择题(每题2分,共20分)

1. 在C语言中,以下哪个关键字用于声明常量?

A. static
B. const
C. final
D. define

答案:B
解析: const 是C语言中用于声明常量的关键字,被修饰的变量值不可修改。

2. 在32位Linux系统中,以下sizeof计算结果正确的是?

char str[] = "Hello";
char* p = str;
int n = 10;

A. sizeof(str)=5, sizeof§=4, sizeof(n)=4
B. sizeof(str)=6, sizeof§=4, sizeof(n)=4
C. sizeof(str)=6, sizeof§=8, sizeof(n)=4
D. sizeof(str)=5, sizeof§=8, sizeof(n)=4

答案:B
解析: 字符串"Hello"含5个字符,末尾自动添加’\0’,共6字节;32位系统指针占4字节,int占4字节。

3. 以下代码的执行结果是?

int a[5] = {1, 2, 3, 4, 5};
int* p = (int*)(&a + 1);
printf("%d, %d", *(a+1), *(p-1));

A. 2, 5
B. 2, 1
C. 1, 5
D. 不确定

答案:A
解析: &a+1 跳过整个数组(5个int),p-1 指向数组最后一个元素5,*(a+1) 是数组第2个元素2。

4. 以下关于指针数组和数组指针的说法,正确的是?

A. int *a[10] 表示一个指向含有10个整型元素的数组的指针
B. int (*a)[10] 表示一个有10个指针的数组,每个指针指向整型
C. int *a[10] 中 [] 优先级高于 *
D. int (*a)[10] 中 * 优先级高于 ()

答案:C
解析: int *a[10] 中 [] 优先级高于 *,表示有10个指针的数组;int (*a)[10] 中 () 优先级高于 [],表示指向含10个int数组的指针。

5. 有以下定义,32位系统下 sizeof(DATE) 和 sizeof(struct data) 分别是?

typedef union {
    long i;
    int k[5];
    char c;
} DATE;
struct data {
    int cat;
    DATE cow;
    double dog;
} too;

A. 20, 32
B. 20, 28
C. 24, 32
D. 20, 24

答案:A
解析: 联合体大小等于最大成员 int k[5] 的20字节;结构体 int(4)+DATE(20)+double(8)=32 字节。

6. 以下代码的问题是什么?

void GetMemory(char* p) {
    p = (char*)malloc(100);
}
void Test() {
    char* str = NULL;
    GetMemory(str);
    strcpy(str, "hello");
    printf(str);
}

A. 内存泄漏
B. 对空指针解引用导致崩溃
C. 内存泄漏 + 对空指针解引用
D. 没有错误

答案:C
解析: 传参是值传递,p 是 str 的临时拷贝,malloc 不影响 str,str 仍为NULL导致崩溃;同时 malloc 的空间未释放导致内存泄漏。

7. 以下能正确输出"hello world"的修改方式是?

A. void GetMemory(char** p) { *p = (char*)malloc(100); }
B. char* GetMemory() { char p[] = "hello"; return p; }
C. void GetMemory(char* p) { p = (char*)malloc(100); strcpy(p, "hello"); }
D. 以上都可以

答案:A
解析: A使用二级指针正确修改了 str;B返回栈空间地址,函数返回后失效;C仍是值传递,str 仍为NULL。

8. 以下代码的输出结果是?

int main() {
    int a[3][2] = {(0,1), (2,3), (4,5)};
    int* p = a[0];
    printf("%d", p[0]);
    return 0;
}

A. 0
B. 1
C. 2
D. 编译错误

答案:B
解析: (0,1) 是逗号表达式,值为1,所以 a[0][0]=1,a[0][1]=3,a[1][0]=5。

9. 下列关于 sizeof 和 strlen 的说法,错误的是?

A. sizeof 是运算符,strlen 是函数
B. sizeof 在编译时计算,strlen 在运行时计算
C. sizeof 计算字符串长度时不包含 ‘\0’
D. strlen 遇到 ‘\0’ 停止计数

答案:C
解析: sizeof 计算的是占用内存大小,包含 ‘\0’;strlen 计算字符串长度,不包含 ‘\0’。

10. 以下关于 volatile 关键字的说法,正确的是?

A. volatile 告诉编译器该变量可能被意外修改
B. volatile 可以保证线程安全
C. volatile 修饰的变量不能进行算术运算
D. volatile 是C++11新增关键字

答案:A
解析: volatile 告诉编译器每次访问都从内存读取,禁止优化,用于多线程或硬件寄存器场景。

二、填空题(每空2分,共10分)

11. 写出以下定义:

  • 一个有10个指针的数组,该指针指向整型数:int *a[10];
  • 一个指向有10个整型数数组的指针:int (*a)[10];
  • 一个指向函数的指针,该函数有1个整型参数并返回整型数:int (*a)(int);
  • 一个有10个指针的数组,该指针指向函数(函数有1个整型参数并返回整型数):int (*a[10])(int);

12. 以下代码的输出结果是:

int a[] = {1, 2, 3, 4, 5};
int* p = a;
printf("%d, %d", sizeof(a), sizeof(p));

32位系统输出:20, 4
64位系统输出:20, 8

三、简答题(每题5分,共10分)

13. 请说明 const 在C语言中的几种用法,并举例。

参考答案:

  1. 修饰普通变量:const int a = 10; —— 值不可修改
  2. 修饰指针指向的内容:const int* p = &a; —— *p 不可改,p 可改
  3. 修饰指针本身:int* const p = &a; —— p 不可改,*p 可改
  4. 同时修饰:const int* const p = &a; —— 都不可改
  5. 修饰函数参数:void func(const char* s) —— 函数内不修改 s 指向的内容

14. 请说明 static 关键字在C语言中的作用。

参考答案:

  1. 修饰局部变量:生命周期延长至程序结束,首次执行到定义处初始化,保持上一次调用后的值
  2. 修饰全局变量/函数:作用域限制在当前文件(内部链接),其他文件不可见
  3. C++中还可修饰类成员(见第二部分)

四、编程题(10分)

15. 实现一个函数 void reverse(char* str),原地反转字符串。

#include <string.h>

void reverse(char* str) {
    if (str == NULL) return;
    int len = strlen(str);
    int left = 0, right = len - 1;
    while (left < right) {
        char tmp = str[left];
        str[left] = str[right];
        str[right] = tmp;
        left++;
        right--;
    }
}

测试用例:

#include <stdio.h>
#include <string.h>
#include <assert.h>

void test_reverse() {
    // 测试用例1:正常字符串
    char str1[] = "hello";
    reverse(str1);
    assert(strcmp(str1, "olleh") == 0);
    printf("测试用例1通过: \"hello\" -> \"%s\"\n", str1);
    
    // 测试用例2:空字符串
    char str2[] = "";
    reverse(str2);
    assert(strcmp(str2, "") == 0);
    printf("测试用例2通过: 空字符串\n");
    
    // 测试用例3:单个字符
    char str3[] = "a";
    reverse(str3);
    assert(strcmp(str3, "a") == 0);
    printf("测试用例3通过: \"a\" -> \"%s\"\n", str3);
    
    // 测试用例4:回文字符串
    char str4[] = "level";
    reverse(str4);
    assert(strcmp(str4, "level") == 0);
    printf("测试用例4通过: \"level\" -> \"%s\"\n", str4);
    
    // 测试用例5:包含空格的字符串
    char str5[] = "hello world";
    reverse(str5);
    assert(strcmp(str5, "dlrow olleh") == 0);
    printf("测试用例5通过: \"hello world\" -> \"%s\"\n", str5);
    
    // 测试用例6:NULL指针
    reverse(NULL);
    printf("测试用例6通过: NULL指针安全\n");
    
    printf("所有测试用例通过!\n");
}

int main() {
    test_reverse();
    return 0;
}

评分标准:

  • 正确实现反转功能(4分)
  • 处理NULL指针(2分)
  • 代码规范清晰(2分)
  • 时间复杂度O(n),空间复杂度O(1)(2分)

77. 以下代码有什么问题?如何修正?

char* get_string() {
    char str[] = "Hello World";
    return str;
}

答案:返回局部数组地址
解析: str 是局部数组,函数返回后内存被释放,返回的指针成为悬垂指针。修正方法:使用 static 修饰或动态分配内存。

78. 分析以下代码的内存布局:

struct S {
    char a;
    int b;
    char c;
    double d;
};

在32位系统下,sizeof(struct S) 是多少?为什么?
答案:24字节
解析: 内存对齐:char a(1)+填充3→4,int b(4),char c(1)+填充7→8,double d(8),总24字节。

79. 以下代码的输出是什么?

#include <stdio.h>

#define SQUARE(x) x * x

int main() {
    int a = 5;
    printf("%d\n", SQUARE(a + 1));
    return 0;
}

答案:11
解析: 宏展开为 a + 1 * a + 1 = 5 + 1 * 5 + 1 = 5 + 5 + 1 = 11。应定义为 #define SQUARE(x) ((x) * (x))。

80. 分析以下代码的递归调用过程:

#include <stdio.h>

void fun(int n) {
    if (n > 0) {
        printf("%d ", n);
        fun(n - 1);
        fun(n - 1);
    }
}

int main() {
    fun(3);
    return 0;
}

答案:3 2 1 1 2 1 1
解析: 递归树:fun(3)打印3,调用fun(2)两次。每个fun(2)打印2,调用fun(1)两次,以此;
。

五、判断题(每题1分,共10分)

66. C语言中,sizeof 是一个函数,用于计算变量或类型的大小。

答案:错误
解析: sizeof 是C语言中的运算符,不是函数,它在编译时计算大小。

67. const 修饰的变量必须在定义时初始化。

答案:正确
解析: const 修饰的变量是只读的,必须在定义时初始化,之后不能修改。

68. 以下代码中,str 和 p 指向的是同一块内存:

char str[] = "Hello";
char* p = "Hello";

答案:错误
解析: str 是数组,在栈上分配内存;p 指向字符串常量,在只读数据段。

69. malloc 分配的内存会自动初始化为0。

答案:错误
解析: malloc 分配的内存内容是未初始化的随机值。calloc 会初始化为0。

70. 以下代码是合法的:

int arr[5] = {1, 2, 3, 4, 5};
int* p = &arr[5];

答案:正确
解析: 可以获取数组最后一个元素之后的位置的地址,但不能解引用。

71. static 局部变量的生命周期与程序相同。

答案:正确
解析: static 局部变量在程序开始运行时初始化,生命周期持续到程序结束。

72. 以下两个声明是等价的:

int* a, b;
int *a, *b;

答案:错误
解析: int* a, b; 中 a 是指针,b 是整型;int *a, *b; 中 a 和 b 都是指针。

73. #define 定义的宏在预处理阶段展开。

答案:正确
解析: 宏在预处理阶段进行文本替换,不进行类型检查。

74. 结构体的大小等于所有成员大小之和。

答案:错误
解析: 结构体大小受内存对齐影响,通常大于等于所有成员大小之和。

75. volatile 关键字可以保证变量的原子性。

答案:错误
解析: volatile 只告诉编译器不要优化,每次从内存读取,不保证原子性。需要原子操作应使用原子类型或锁。
``

第二部分:C++核心特性(25题,50分)

一、选择题(每题2分,共20分)

16. 下列关于指针与引用的区别,说法错误的是?

A. 指针可以为空,引用不能为空
B. 指针可以重新赋值,引用一旦绑定不可更改
C. 指针占用内存,引用不占用内存(编译器优化后)
D. 指针初始化以后不能被改变,引用可以改变所指的对象

答案:D
解析: D说反了——指针可以改变指向,引用一旦绑定不可更改。

17. 以下关于 new/delete 与 malloc/free 的区别,正确的是?

A. new 和 malloc 都会调用构造函数
B. delete 和 free 都会调用析构函数
C. new 失败返回NULL,malloc 失败抛异常
D. new 是运算符,malloc 是库函数

答案:D
解析: new/delete 是C++运算符,会调用构造/析构函数;malloc/free 是C库函数,不调用构造/析构。new 失败抛 std::bad_alloc,malloc 失败返回NULL。

18. 以下关于虚函数的描述,正确的是?

A. 派生类的虚函数与基类的虚函数可以有不同的参数个数和类型
B. 内联函数可以声明为虚函数
C. 虚函数地址存放在对象的虚表中,必须用对象指针或引用来调用
D. 静态成员函数可以是虚函数

答案:C
解析: 虚函数参数和返回值必须与基类一致(协变返回类型除外);内联函数是编译时展开,不能是虚函数(内联没有地址);静态成员函数无 this 指针,不能是虚函数。

19. 关于纯虚函数的说法,正确的是?

A. 声明纯虚函数的类可以实例化对象
B. 子类必须实现基类的所有纯虚函数才能实例化
C. 纯虚函数是一种特殊的虚函数,是空函数
D. 具有纯虚函数的类称为虚基类

答案:B
解析: 含有纯虚函数的类是抽象类,不能实例化对象;子类必须实现所有纯虚函数才能成为具体类。

20. 以下关于构造函数的执行顺序,正确的是?

class A { public: A(){cout << "A";} };
class B { public: B(){cout << "B";} };
class C : public A {
    B b;
public:
    C(){cout << "C";}
};
int main() { C obj; return 0; }

A. CBA
B. BAC
C. ACB
D. ABC

答案:C
解析: 构造顺序:基类构造函数 → 对象成员构造函数 → 派生类本身构造函数,输出 ACB。

21. 以下关于深浅拷贝的说法,正确的是?

A. 浅拷贝是复制指针指向的内容
B. 深拷贝只复制指针值
C. 浅拷贝可能导致双重释放
D. 深拷贝效率高于浅拷贝

答案:C
解析: 浅拷贝只复制指针值,多个指针指向同一块内存,析构时多次释放导致程序崩溃;深拷贝分配新内存并复制内容,更安全但效率较低。

22. 下列关于智能指针的说法,错误的是?

A. unique_ptr 独占资源,不能共享
B. shared_ptr 使用引用计数管理内存
C. weak_ptr 可以增加引用计数
D. weak_ptr 可以解决循环引用问题

答案:C
解析: weak_ptr 不增加引用计数,是对 shared_ptr 的弱引用,用于解决循环引用。

23. 以下关于 constexpr 的说法,正确的是?

A. constexpr 修饰的函数一定在编译期执行
B. constexpr 只能用于修饰变量
C. constexpr 可以用于常量表达式,提高编译效率
D. constexpr 是C++98引入的特性

答案:C
解析: constexpr 函数不一定总在编译期执行(取决于参数是否为常量表达式);可修饰变量和函数;C++11引入。

24. 以下关于移动语义的说法,正确的是?

A. 移动语义是C++98引入的特性
B. 移动语义通过左值引用实现
C. 移动语义可以避免不必要的拷贝,提高性能
D. 移动语义会增加代码量,不推荐使用

答案:C
解析: 移动语义是C++11引入,通过右值引用实现,在对象资源转移时避免不必要拷贝。

25. 以下关于STL容器的说法,正确的是?

A. vector 插入删除快,随机访问慢
B. list 随机访问快,插入删除慢
C. vector 随机访问快,插入删除慢(尾部插入除外)
D. list 和 vector 的插入删除时间复杂度相同

答案:C
解析: vector 连续存储,随机访问O(1),中间插入删除O(n);list 双向链表,随机访问O(n),插入删除O(1)。

二、填空题(每空2分,共10分)

26. 以下代码的输出结果是:

class A {
public:
    virtual void foo() { cout << "A"; }
};
class B : public A {
public:
    void foo() override { cout << "B"; }
};
int main() {
    A* p = new B();
    p->foo();
    return 0;
}

输出:B

27. 以下代码中,sizeof(A) 在32位系统下的结果是:

struct A {
    char a;      // 1字节
    int b;       // 4字节
    double c;    // 8字节
};

输出:16
解析: 内存对齐:char(1)+填充3→4,int(4),double(8),总16字节。

三、简答题(每题5分,共10分)

28. 请说明 unique_ptr、shared_ptr、weak_ptr 的区别。

参考答案:

  • unique_ptr:独占式所有权,不能拷贝,只能移动。资源唯一持有者,销毁时自动释放
  • shared_ptr:共享式所有权,引用计数管理。多个 shared_ptr 可共享同一资源,最后一个销毁时释放
  • weak_ptr:弱引用,不增加引用计数。配合 shared_ptr 使用,解决循环引用问题,通过 lock() 获取 shared_ptr

29. 什么是RAII?它在C++中有什么重要意义?

参考答案:
RAII(Resource Acquisition Is Initialization)是C++的核心编程范式:资源获取即初始化,资源释放即析构。

  • 资源的获取在构造函数中完成,资源的释放在析构函数中完成
  • 利用C++对象生命周期管理,保证资源在任何情况下(包括异常)都能正确释放
  • 智能指针是RAII的典型应用:unique_ptr、shared_ptr 自动管理堆内存

四、编程题(10分)

30. 实现一个线程安全的单例模式(C++11及以后)。

#include <mutex>

class Singleton {
private:
    Singleton() = default;
    ~Singleton() = default;
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

public:
    static Singleton& getInstance() {
        static Singleton instance;  // C++11起线程安全
        return instance;
    }
};

或使用 std::call_once:

#include <mutex>

class Singleton {
private:
    static Singleton* instance;
    static std::once_flag flag;
    Singleton() = default;

public:
    static Singleton* getInstance() {
        std::call_once(flag, []() {
            instance = new Singleton();
        });
        return instance;
    }
};

// 静态成员初始化
Singleton* Singleton::instance = nullptr;
std::once_flag Singleton::flag;

测试用例:

#include <iostream>
#include <thread>
#include <vector>
#include <cassert>

void test_singleton() {
    // 测试用例1:单线程测试
    Singleton& s1 = Singleton::getInstance();
    Singleton& s2 = Singleton::getInstance();
    assert(&s1 == &s2);
    std::cout << "测试用例1通过: 单线程单例唯一性" << std::endl;
    
    // 测试用例2:多线程测试
    std::vector<std::thread> threads;
    std::vector<Singleton*> instances;
    std::mutex mtx;
    
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back([&mtx, &instances]() {
            Singleton* instance = &Singleton::getInstance();
            std::lock_guard<std::mutex> lock(mtx);
            instances.push_back(instance);
        });
    }
    
    for (auto& t : threads) {
        t.join();
    }
    
    // 验证所有线程获取的是同一个实例
    Singleton* first = instances[0];
    for (size_t i = 1; i < instances.size(); ++i) {
        assert(instances[i] == first);
    }
    std::cout << "测试用例2通过: 多线程单例唯一性" << std::endl;
    
    // 测试用例3:不可拷贝
    // Singleton s3 = s1;  // 编译错误 - 正确
    // Singleton s4(s1);   // 编译错误 - 正确
    std::cout << "测试用例3通过: 不可拷贝特性" << std::endl;
    
    std::cout << "所有测试用例通过!" << std::endl;
}

int main() {
    test_singleton();
    return 0;
}

评分标准:

  • 正确实现线程安全单例(4分)
  • 防止拷贝构造和赋值(2分)
  • 代码规范清晰(2分)
  • 提供多线程测试用例(2分)

第三部分:数据结构与算法(20题,40分)

一、选择题(每题2分,共20分)

31. 以下哪种数据结构是线性结构?

A. 树
B. 图
C. 链表
D. 二叉树

答案:C
解析: 线性结构包括数组、链表、栈、队列;树和图是非线性结构。

32. 下列哪种排序算法的平均时间复杂度是 O(n²)?

A. 快速排序
B. 归并排序
C. 冒泡排序
D. 堆排序

答案:C
解析: 冒泡排序平均 O(n²);快速排序平均 O(n log n);归并排序 O(n log n);堆排序 O(n log n)。

33. 在链表中插入一个新节点的时间复杂度是?

A. O(1)
B. O(n)
C. O(log n)
D. 取决于插入位置

答案:D
解析: 链表插入本身O(1),但查找插入位置需要O(n)。

34. 以下哪个排序算法是不稳定的?

A. 冒泡排序
B. 插入排序
C. 归并排序
D. 快速排序

答案:D
解析: 快速排序、选择排序、希尔排序是不稳定排序;冒泡、插入、归并是稳定排序。

35. 在二叉搜索树中,以下哪个操作的时间复杂度是 O(log n)(平衡情况下)?

A. 插入
B. 删除
C. 查找
D. 以上都是

答案:D
解析: 平衡二叉搜索树的插入、删除、查找时间复杂度都是 O(log n)。

36. 以下哪种数据结构最适合实现栈操作?

A. 队列
B. 链表
C. 数组
D. 树

答案:C
解析: 数组实现栈操作简单高效,时间复杂度O(1)。

37. 以下关于链表的说法,正确的是?

A. 链表是一种非线性结构
B. 链表元素在内存中连续存储
C. 链表支持随机访问
D. 链表插入删除不需要移动元素

答案:D
解析: 链表是线性结构,元素不连续存储,不支持随机访问,插入删除只需修改指针。

38. 以下哪种数据结构适合用作优先队列的底层实现?

A. 哈希表
B. 平衡二叉搜索树
C. 双向链表
D. 循环队列

答案:B
解析: 堆(通常用数组实现)是优先队列的经典实现,平衡二叉搜索树也可实现优先队列功能。

39. 在C++中,以下哪个容器最适合实现LRU缓存?

A. vector
B. list + unordered_map
C. set
D. queue

答案:B
解析: LRU缓存需要快速查找(哈希表)和快速移动元素到头部(链表),list + unordered_map 是经典实现。

40. 以下关于时间复杂度的描述,正确的是?

A. O(1) < O(log n) < O(n) < O(n log n) < O(n²)
B. O(1) < O(n) < O(log n) < O(n log n) < O(n²)
C. O(log n) < O(1) < O(n) < O(n log n) < O(n²)
D. 以上都不对

答案:A

二、简答题(每题5分,共10分)

41. 请说明数组和链表的区别及各自的适用场景。

参考答案:

特性数组链表
内存连续分配非连续分配
随机访问O(1)O(n)
插入删除O(n)(需移动元素)O(1)(已知位置)
空间固定/需扩容动态

适用场景:

  • 数组:频繁随机访问、数据量固定、内存连续性要求高的场景
  • 链表:频繁插入删除、数据量动态变化、不需要随机访问的场景

42. 请说明快速排序的基本思想、时间复杂度及稳定性。

参考答案:

  • 基本思想:分治法。选取基准元素,将数组分为小于基准和大于基准两部分,递归排序
  • 时间复杂度:平均 O(n log n),最坏 O(n²)(已排序数组),最好 O(n log n)
  • 空间复杂度:O(log n)(递归栈)
  • 稳定性:不稳定

三、编程题(10分)

43. 实现单链表反转。

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

ListNode* reverseList(ListNode* head) {
    ListNode* prev = nullptr;
    ListNode* curr = head;
    while (curr != nullptr) {
        ListNode* next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

测试用例:

#include <iostream>
#include <vector>
#include <cassert>

// 辅助函数:创建链表
ListNode* createList(const std::vector<int>& values) {
    if (values.empty()) return nullptr;
    ListNode* head = new ListNode(values[0]);
    ListNode* current = head;
    for (size_t i = 1; i < values.size(); ++i) {
        current->next = new ListNode(values[i]);
        current = current->next;
    }
    return head;
}

// 辅助函数:验证链表内容
bool verifyList(ListNode* head, const std::vector<int>& expected) {
    ListNode* current = head;
    for (int val : expected) {
        if (current == nullptr || current->val != val) {
            return false;
        }
        current = current->next;
    }
    return current == nullptr;
}

// 辅助函数:释放链表内存
void deleteList(ListNode* head) {
    while (head != nullptr) {
        ListNode* temp = head;
        head = head->next;
        delete temp;
    }
}

void test_reverseList() {
    // 测试用例1:正常链表
    ListNode* list1 = createList({1, 2, 3, 4, 5});
    ListNode* reversed1 = reverseList(list1);
    assert(verifyList(reversed1, {5, 4, 3, 2, 1}));
    std::cout << "测试用例1通过: 1->2->3->4->5 反转成功" << std::endl;
    deleteList(reversed1);
    
    // 测试用例2:空链表
    ListNode* list2 = nullptr;
    ListNode* reversed2 = reverseList(list2);
    assert(reversed2 == nullptr);
    std::cout << "测试用例2通过: 空链表处理" << std::endl;
    
    // 测试用例3:单个节点
    ListNode* list3 = createList({42});
    ListNode* reversed3 = reverseList(list3);
    assert(verifyList(reversed3, {42}));
    std::cout << "测试用例3通过: 单节点链表" << std::endl;
    deleteList(reversed3);
    
    // 测试用例4:两个节点
    ListNode* list4 = createList({1, 2});
    ListNode* reversed4 = reverseList(list4);
    assert(verifyList(reversed4, {2, 1}));
    std::cout << "测试用例4通过: 1->2 反转成功" << std::endl;
    deleteList(reversed4);
    
    // 测试用例5:重复元素
    ListNode* list5 = createList({1, 1, 2, 2, 3, 3});
    ListNode* reversed5 = reverseList(list5);
    assert(verifyList(reversed5, {3, 3, 2, 2, 1, 1}));
    std::cout << "测试用例5通过: 含重复元素的链表" << std::endl;
    deleteList(reversed5);
    
    std::cout << "所有测试用例通过!" << std::endl;
}

int main() {
    test_reverseList();
    return 0;
}

评分标准:

  • 正确实现链表反转(4分)
  • 处理空链表和单节点链表(2分)
  • 代码规范清晰(2分)
  • 时间复杂度O(n),空间复杂度O(1)(2分)

第四部分:Linux系统编程(15题,30分)

一、选择题(每题2分,共12分)

44. 进程与线程的主要区别是?

A. 进程是调度的基本单位
B. 线程有独立的地址空间
C. 同一进程的线程共享地址空间
D. 进程比线程更轻量级

答案:C
解析: 进程是资源分配的基本单位,线程是调度的基本单位。同一进程的线程共享地址空间,进程间地址空间独立。

45. 以下哪种是进程间通信(IPC)的方式?

A. 管道
B. 共享内存
C. 消息队列
D. 以上都是

答案:D
解析: 常见的IPC方式包括:管道、共享内存、消息队列、信号量、Socket等。

46. 以下关于僵尸进程的描述,正确的是?

A. 僵尸进程会占用大量CPU
B. 僵尸进程已经结束,但父进程未回收其资源
C. 僵尸进程无法被杀死
D. 僵尸进程是正在运行的进程

答案:B
解析: 僵尸进程是已终止但父进程未调用 wait() 回收的进程,只占用进程表项,不占用CPU和内存。

47. 以下关于守护进程的描述,错误的是?

A. 守护进程在后台运行
B. 守护进程没有控制终端
C. 守护进程通常是系统启动时启动
D. 守护进程可以随意访问用户终端

答案:D
解析: 守护进程运行在后台,没有控制终端,不与用户交互。

48. 以下关于死锁的必要条件,不包括?

A. 互斥
B. 持有并等待
C. 抢占
D. 循环等待

答案:C
解析: 死锁四个必要条件:互斥、持有并等待、非抢占、循环等待。

49. 以下关于线程同步的说法,正确的是?

A. mutex 用于线程间同步
B. volatile 可以保证线程安全
C. 原子操作不能用于线程同步
D. 条件变量不能用于线程同步

答案:A
解析: mutex、条件变量、原子操作都可用于线程同步;volatile 不保证线程安全。

二、简答题(每题6分,共18分)

50. 请说明进程有哪几种状态,以及状态转换的触发事件。

参考答案:
进程状态:就绪 → 运行 → 阻塞 → 终止

  • 就绪→运行:被调度程序选中
  • 运行→就绪:时间片用完或被抢占
  • 运行→阻塞:等待I/O、等待事件
  • 阻塞→就绪:I/O完成、事件发生
  • 运行→终止:正常结束或异常退出

51. 什么是孤儿进程?什么是僵尸进程?如何处理?

参考答案:

  • 孤儿进程:父进程先于子进程结束,子进程被 init 进程(PID=1)收养,由 init 负责回收
  • 僵尸进程:子进程已结束,但父进程未调用 wait() 回收其资源,进程描述符仍保留
  • 处理方式:父进程调用 wait() 或 waitpid() 回收;或使用信号处理 SIGCHLD;父进程结束后僵尸进程由 init 回收

52. 请说明死锁的四个必要条件及避免死锁的策略。

参考答案:
四个必要条件:

  1. 互斥:资源一次只能被一个进程占用
  2. 持有并等待:进程持有资源并等待其他资源
  3. 非抢占:已分配的资源不能被强制抢占
  4. 循环等待:进程间形成资源等待环

避免策略:

  1. 破坏互斥:尽可能共享资源
  2. 破坏持有并等待:一次性申请所有资源
  3. 破坏非抢占:允许抢占
  4. 破坏循环等待:按固定顺序申请资源

第五部分:网络编程(10题,20分)

一、选择题(每题2分,共12分)

53. 以下哪个函数用于创建Socket?

A. connect()
B. socket()
C. bind()
D. listen()

答案:B
解析: socket() 创建套接字,bind() 绑定地址,listen() 监听,connect() 连接。

54. 以下关于TCP和UDP的说法,错误的是?

A. TCP是面向连接的协议
B. TCP提供可靠的数据传输服务
C. UDP是面向连接的协议
D. UDP不保证数据包顺序

答案:C
解析: UDP是无连接的,不保证可靠传输和数据包顺序。

55. TCP建立连接需要几次握手?

A. 1次
B. 2次
C. 3次
D. 4次

答案:C
解析: TCP三次握手建立连接:SYN → SYN-ACK → ACK。

56. TCP断开连接需要几次挥手?

A. 2次
B. 3次
C. 4次
D. 5次

答案:C
解析: TCP四次挥手断开连接:FIN → ACK → FIN → ACK。

57. 以下哪个函数用于将网络字节序转换为主机字节序?

A. htonl()
B. ntohl()
C. htons()
D. 以上都是

答案:D
解析: htonl() 主机转网络长整型,htons() 主机转网络短整型,ntohl() 网络转主机长整型。

58. 以下关于Socket编程的说法,正确的是?

A. 服务端使用 connect() 等待连接
B. 客户端使用 listen() 监听端口
C. accept() 返回新的套接字用于通信
D. bind() 用于发送数据

答案:C
解析: 服务端:socket() → bind() → listen() → accept();客户端:socket() → connect()。accept() 返回新套接字用于与客户端通信。

二、简答题(每题4分,共8分)

59. 请说明TCP和UDP的主要区别及适用场景。

参考答案:

特性TCPUDP
连接面向连接无连接
可靠性可靠传输不可靠传输
顺序保证顺序不保证顺序
速度较慢较快
头部大小20字节8字节

适用场景:

  • TCP:文件传输、HTTP、邮件等需要可靠传输的场景
  • UDP:视频流、语音通话、DNS等实时性要求高的场景

60. 请简述TCP三次握手的过程。

参考答案:

  1. 第一次握手:客户端发送 SYN 报文(SYN=1,seq=x),进入 SYN_SENT 状态
  2. 第二次握手:服务端收到 SYN 后,回复 SYN-ACK 报文(SYN=1,ACK=1,seq=y,ack=x+1),进入 SYN_RCVD 状态
  3. 第三次握手:客户端收到 SYN-ACK 后,发送 ACK 报文(ACK=1,seq=x+1,ack=y+1),进入 ESTABLISHED

第六部分:智力与逻辑(5题,10分)

一、选择题/简答题(每题2分,共10分)

81. 25匹马,5个赛道,最少需要几场比赛才能找出最快的3匹马?

答案:7场
解析: 先分5组各跑1场(5场),每组第一再跑1场(1场),共6场确定最快马。再让最快马所在组的第二、三名,第二快马所在组的第一、二名,第三快马所在组的第一名共5匹马跑第7场,确定第二、第三名。

82. 有8个外观完全相同的球,其中1个稍重,用天平最少称几次能找出重球?

答案:2次
解析: 第一次:3 vs 3(若平衡,重球在剩余2个中,再称1次;若不平衡,重球在重的一侧3个中,再称1次)

83. 一个房间里有3个开关和3盏灯,开关在门外,灯在门内。你只能进房间一次,如何确定哪个开关控制哪盏灯?

参考答案:

  1. 打开第1个开关,等几分钟
  2. 关闭第1个开关,打开第2个开关
  3. 立即进房间
  4. 亮的灯由第2个开关控制
  5. 热的灯(不亮但发热)由第1个开关控制
  6. 冷的灯(不亮不热)由第3个开关控制

84. 有100层楼和2个鸡蛋,如何用最少次数确定鸡蛋从哪层扔下会碎?

参考答案:
从第14层开始扔,逐层递减(14, 27, 39, 50, 60, 69, 77, 84, 90, 95, 99, 100)。最坏情况需要14次。这是最优解。

85. 烧一根不均匀的绳子,从头烧到尾需要1小时。现有若干根相同的绳子,如何用它们测出45分钟?

参考答案:

  1. 同时点燃绳子的两端和另一根绳子的一端
  2. 第一根绳子两端同时烧完时,正好30分钟
  3. 此时第二根绳子还剩下30分钟的量
  4. 立刻点燃第二根绳子的另一端,从此刻到烧完正好15分钟
  5. 30 + 15 = 45分钟
  6. 8`**
    解析: sizeof(a) 计算数组总大小(5个int,共20字节);sizeof§ 计算指针大小(32位4字节,64位8字节)。
  7. 以下代码的输出结果是:
    int a = 5, b = 3;
    printf(“%d, %d”, a+++b, a++ +b);

输出:8, 9
解析: a+++b 解析为 (a++) + b(5+3=8,a变为6);a++ +b 执行时a=6(6+3=9,a变为7)。
14. 以下代码的输出结果是:
char str[] = “Hello\0World”;
printf(“%d, %d”, sizeof(str), strlen(str));

输出:12, 5
解析: sizeof 计算包括’\0’的总大小(12字节);strlen 遇到第一个’\0’停止(5)。
15. 以下代码的输出结果是:
int a = 3, b = 5;
int c = a+++b;
printf(“%d, %d”, a, c);

输出:4, 8
解析: a+++b 解析为 (a++) + b(3+5=8,a变为4)。
三、判断题(每题1分,共10分)
16. int *p = malloc(10 * sizeof(int)); 分配的内存不会被自动初始化为0。(✓)
解析: malloc 不初始化内存,calloc 会初始化为0。
17. int a[10]; 和 int *a = malloc(10 * sizeof(int)); 分配的内存都在堆上。(×)
解析: int a[10] 在栈上,malloc 在堆上。
18. strcpy 比 memcpy 更安全,因为它会自动检查目标缓冲区大小。(×)
解析: strcpy 不检查缓冲区大小,memcpy 也不检查,strncpy 可指定最大拷贝数。
19. typedef 可以用于简化复杂的类型声明,但不创建新类型。(✓)
解析: typedef 为已有类型创建别名,不创建新类型。
20. const int *p 和 int const *p 含义相同,表示指针指向的内容不可变。(✓)
解析: 两种写法等价,*p 不可修改,p 可修改。
21. int *const p 表示指针本身不可变,但指向的内容可以修改。(✓)
解析: p 不可变,*p 可修改。
22. realloc 可以用于扩大或缩小内存块,但可能改变内存地址。(✓)
解析: realloc 可能原地调整大小或分配新内存并拷贝内容。
23. free(NULL) 是安全的,不会导致程序崩溃。(✓)
解析: C标准规定 free(NULL) 不执行任何操作。
24. struct 和 union 的大小都等于各成员大小之和。(×)
解析: struct 大小可能因对齐大于成员之和;union 大小等于最大成员大小。
25. #define 定义的宏在预处理阶段展开,const 变量在编译阶段处理。(✓)
解析: 宏是文本替换,const 是类型化常量。
四、简答题(每题5分,共10分)
26. 简述 strcpy、strncpy 和 memcpy 的区别。
答案:

strcpy:拷贝字符串,遇到’\0’停止,不检查目标缓冲区大小,不安全。
strncpy:指定最大拷贝字符数,避免溢出,但可能不添加’\0’。
memcpy:按字节拷贝指定长度的内存,不关心内容,效率高。

应用场景:

strcpy:已知目标缓冲区足够大时
strncpy:需要防止缓冲区溢出时
memcpy:拷贝任意二进制数据或结构体

  1. 解释以下声明并说明用途:
    int (*(*func)(int))[10];

答案:

声明解析(从内到外):

func 是一个指针
指向一个函数,该函数接受 int 参数
函数返回一个指针,指向含有10个 int 的数组

简化理解:
func 是函数指针,接受 int 参数,返回指向 int[10] 的指针。

用途示例:

int arr[10];
int (get_array(int x))[10] { return &arr; }
int (
(*func)(int))[10] = get_array;

用于动态获取固定大小数组的场景。
五、程序分析题(每题3分,共15分)
28. 分析以下代码的输出:
int main() {
int a = 5, b = 7;
int c = a+++b;
printf(“%d, %d, %d”, a, b, c);
return 0;
}

答案: 6, 7, 12
解析:

a+++b 解析为 (a++) + b
先计算 a + b(5+7=12),然后 a 自增为6
b 保持不变

  1. 分析以下代码的问题:
    char* get_string() {
    char str[] = “Hello”;
    return str;
    }
    int main() {
    char* p = get_string();
    printf(“%s”, p);
    return 0;
    }

答案: 返回局部数组地址导致未定义行为
解析:

str 是栈上的局部数组,函数返回后内存失效
p 成为悬垂指针,访问可能导致崩溃或乱码
修正方法:使用 static 或动态分配

  1. 分析以下宏定义的问题:
    #define SQUARE(x) x * x
    int main() {
    int a = 5;
    printf(“%d”, SQUARE(a+1));
    return 0;
    }

答案: 输出 11 而非预期的 36
解析:

宏展开为 a+1 * a+1(即 5+15+1=11)
正确写法:#define SQUARE(x) ((x)
(x))
宏参数应始终加括号

  1. 分析以下代码的输出:
    int main() {
    char* s = “Hello”;
    s[0] = ‘h’;
    printf(“%s”, s);
    return 0;
    }

答案: 运行时错误(尝试修改字符串常量)
解析:

“Hello” 是字符串常量,存储在只读段
s[0] = ‘h’ 尝试修改只读内存,导致段错误
正确做法:使用数组 char s[] = “Hello”;

  1. 分析以下代码的输出:
    int main() {
    int a = 0;
    printf(“%d, %d, %d”, a, a++, ++a);
    return 0;
    }

答案: 输出依赖编译器,可能是 2, 1, 2
解析:

函数参数求值顺序未定义(从右到左或从左到右)
不同编译器可能产生不同结果
应避免在同一个表达式中混合使用自增和输出

六、编程题(10分)
33. 实现一个函数,将字符串中的空格替换为 “%20”(假设字符串有足够空间)
参考答案:
void replace_spaces(char* str) {
if (str == NULL) return;

int space_count = 0;
int original_len = strlen(str);

// 统计空格数量
for (int i = 0; i < original_len; i++) {
    if (str[i] == ' ') space_count++;
}

int new_len = original_len + space_count * 2;
str[new_len] = '\0';

// 从后向前替换
for (int i = original_len - 1, j = new_len - 1; i >= 0; i--) {
    if (str[i] == ' ') {
        str[j--] = '0';
        str[j--] = '2';
        str[j--] = '%';
    } else {
        str[j--] = str[i];
    }
}

}

解题思路:

先遍历字符串统计空格数量,计算新长度
从后向前处理,避免频繁移动字符
遇到空格则逆序填入 ‘%20’
时间复杂度 O(n),空间复杂度 O(1)

测试用例:

“Hello World” → “Hello%20World”
" " → “%20%20%20”
“NoSpaces” → “NoSpaces”
“” → “”
NULL → 不处理

📝 第一部分总结
本部分涵盖C语言核心知识点,包括指针、内存管理、数组与字符串、预处理器等。重点难点:

指针与数组的关系
内存分配与管理
复杂类型声明解析
字符串处理函数区别
宏定义与类型定义

建议通过实际编程练习加深理解,特别是指针操作和内存管理相关题目。

#CONFIRM🌌9622-ONLY-ONCE🧬LK9X-772Z
GPG: A2D0092CEE2E5BA87035600924C3704A8CC26D5F
主权锚定: #ZHUGEXIN⚡️2025-🇨🇳🐉⚖️♠️🧚🏼‍♀️❤️♾️-DEVICE-BIND-SOUL
三色: 🟢 通过
题量: 100题
总分: 200分
═══════════════════════════════════════════════════


🐉 **丙午·甲申·辛丑·坤卦·🟢**
2026实测可用!4个专业AI Agent Skills垂直搜索平台对比 📊本文以表格形式整理4个实测可用的专业AI Agent Skills垂直搜索平台,涵盖资源规模、适配生态等关键维度🤖,适合开发者按需选择技能获取渠道,解决平台筛选与访问难题✨ 阅读详情

相关推荐

【windows】【系统还原】亦是美kms执行一键关闭defender 之后,windows defender 被卸载了,无论如何都打不开

还是执行 都没有明显效果 那么,我最后是怎么解决得呢? 一、打开控制面板(任务栏搜索kzmb)

weixin_41899098的博客 6917

IT人面试笔试题库及技巧

 IT人面试笔试题库及技巧强力放送! IBM、微软、GOOGLE/中软/华为/东软等各大公司笔试面试题库一网打尽! 下载地址:http://bbs.itcast.net/bbs/viewthread.php?tid=11&extra=page%3D1 企业级试题: 世界500强面试题及面试技巧与简历制作  直接下载 东软笔试面试试题汇总.doc 直接下载 IBM面试心得.doc直接下载 googl

Jim20的专栏 2484

森林冰火人html源码,森林冰火人单人版(源码)

【实例简介】java小游戏——森林冰火人,单人游戏, 实现人物行走,跳跃,吃水晶,具有计时功能,积分功能,倒计时结束游戏失败。【实例截图】【核心代码】森林冰火人单人版├── bin│ ├── game│ │ ├── Help.class│ │ ├── Logon.class│ │ ├── Main.class│ │ ├── Mykey.class│ │ ...

weixin_42507981的博客 6206

OJ编程网站(找了一个多小时)基本是c++和c语言

OJ编程网站(找了一个多小时)基本是c++和c语言

XTX的博客 1957

数字蓝牙功放

数字蓝牙功放(TPA3110+BK8000L),基于D类数字功放芯片TPA3116蓝牙功放,HIFI级带滤波15Wx2蓝牙数字功放,支持有线和蓝牙两种音源输入

runweipa的博客 1420

Nginx下ModSecurity模块安装详细教程

本文提供了在Nginx 1.28.0上安装ModSecurity v3的完整教程。首先需安装编译依赖,然后从源码编译安装ModSecurity库并设置优化参数。接着编译Nginx动态模块并配置加载。核心配置包括设置规则引擎、日志路径及性能优化参数。安装OWASP核心规则集后,在Nginx站点配置中启用ModSecurity。最后测试规则有效性并给出性能优化建议,如规则排除、精简规则集等。整个过程包含详细的命令和配置示例,确保安全防护功能正常运作。

深山技术宅的博客 1785

2024年最新研发、运营必备实用工具网站_运营小工具网站,C C++入门教程

支持图片压缩、GIF压缩、视频转GIF、GIF合成以及GIF剪裁五大功能。

2401_84973664的博客 674

仿真学习系列(三十八):Sigrity仿真之单端S参数提取

S 参数(Scattering Parameters)是高速信号分析中最基础也最常用的指标,能够全面表征走线、过孔、连接器等互连结构的高频行为。在 Sigrity PowerSI 中,Model Extraction 是最常用的 S 参数提取方式,适用于高速差分线、单端线、过孔、参考平面等各种拓扑结构。 本节将通过示例讲解如何在 PowerSI 中完成一次完整的 S 参数提取流程,包括:对象选择、端口设置、频率范围配置以及结果查看。掌握此方法后,即可对任意高速网络执行阻抗、插损、回损、串扰分析,为进一步的

案例文章,高速信号 838

Appstore排名前十的程序员应用软件

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_34092455的博客 584

PCL 法线定向【2025最新版】

几种法线定向方法的PCL代码实现。

点云侠的博客 2806

U盘插入电脑时发出声音但不显示——编程解决方案

以上是一些常见的编程解决方案,帮助您解决U盘插入电脑时发出声音但不显示的问题。请注意,这些解决方案可能因不同的情况而略有不同,因此请根据您的具体情况进行调整和尝试。当您将U盘插入电脑时,如果您听到了连接声音,但是U盘却没有在文件资源管理器或桌面上显示出来,这可能是由于一些常见问题导致的。U盘的文件系统格式可能与您的计算机不兼容,导致无法正确识别。如果输出显示U盘的文件系统格式与您的计算机不兼容,您可以尝试重新格式化U盘或使用其他兼容的文件系统格式。其中,X是U盘的磁盘编号,Y是您想要分配给U盘的盘符。

ByteEchoX的博客 2464

miniPC Type‑C 一线连屏设计:LDR6021Q 标准 TCPC 与 TCPC + 方案解析

无需主机 MCU 参与。主控策略层(TCPM,参考 PY32F003F18P6‑E):全权处理连接去抖、PDO/RDO 解析、电源合同管理、PR‑Swap/DR‑Swap 角色交换、VDM 处理、DP Alt Mode 协商、MUX 与 HPD 控制全部上层业务逻辑。乐得瑞 LDR6021Q QFN16 单口 USB‑PD 控制器,同一硬件支持标准 TCPC、TCPC + 两套固件方案,针对性解决 miniPC Type‑C 供电、DP 一线连屏、扩展坞兼容难题,兼顾深度定制与快速量产,无需改版 PCB。

Huns668的博客 221

一张图读懂 SAP S/4HANA Cloud 与 SAP BTP 的扩展版图

本文解析了SAP S/4HANA Cloud的扩展技术谱系,提出扩展应分为on-stack(系统内)和side-by-side(并行)两种路径,并沿着低代码到专业代码的能力梯度进行分层。on-stack扩展包括面向业务人员的Key User Extensibility和面向开发者的Developer Extensibility,强调贴近核心业务对象;side-by-side扩展则依托SAP BTP平台,提供SAP Build低代码工具、CAP开发框架和ABAP云环境三种方案,支持解耦创新。文章通过五个真实案

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 258

c语言:文件操作2+预准备 编译 汇编 链接 运行

1.2 文件缓冲区(缓冲区分文件缓冲区,内存缓冲区,两个是不一样的,但是都是对于输入输出才有)fp = fopen(“test.txt”, “r”);二、编译与运行(翻译环境 / 运行环境)2.2 链接做的五件事(顺序不能倒)一句话记:键盘输入缓冲区 →。一、文件 I/O(磁盘文件)2.3 比较发生在哪个阶段。三、最容易混:两套缓冲区。

Code_Solitude的博客 245

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Effective STL 条款 01:慎重选择容器类型

容器选型是结构性决策,应优先考虑访问模式、增删位置与失效规则。需随机访问或尾部增删时首选 vector;头尾操作选 deque;按键查找用 set/map;中间频繁插入且元素大、拷贝贵时才考虑 list。vector 默认最优,因连续内存提升缓存效率,兼容 C 接口,且多数场景性能领先。避免凭直觉选型,务必结合真实数据量测试,接口一旦暴露即成契约,换容器成本高昂。

软件科学-郝学胜 465

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

跟我学c++中级篇—类型定义的方式

本文系统阐述了编程中类型定义的重要性及c++中的实现方式。重点对比了宏定义、typedef与modern using三种机制,指出using在可读性、灵活性和模板支持上的优势,推荐优先使用。同时提醒开发者注意别名滥用、类型歧义、错误信息冗长等问题,强调统一规范与合理设计。最终结论:在现代c++开发中,应以using为主,兼顾简洁性与可维护性,避免陷入命名混乱与编译困境。

fpcc的专栏 401

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

【C++——类和对象(上)】筑基篇:以封装奠定面向对象之基

本文系统梳理C++类与对象的核心知识点,涵盖类的定义、访问限定符(public/private)、类作用域、对象实例化及内存布局。重点解析封装思想、this指针机制、空类大小为1字节的原因,以及类与对象在内存中的存储差异。通过对比C语言结构体与C++类,揭示面向对象设计的优势:数据保护、接口统一、命名隔离与代码可维护性提升。内容由浅入深,适合作为学习笔记与复习参考。

2602_95684935的博客 661

【C/C++ 第一次跨越(下):移动语义与 noexcept——不改变行为的性能修复】

本文详解C++11移动语义在迁移至现代C++时的性能优化策略,强调“不改变行为”的前提下通过合理使用移动语义消除深拷贝开销。重点解析移动操作生成规则:析构函数、拷贝函数或const/引用成员会抑制移动构造;noexcept影响std::vector是否选择移动而非回退拷贝。提出“Rule of Zero”原则——用RAII封装资源,避免手动实现特殊成员函数,确保移动语义被正确调用,实现零开销移动与内存安全。

一起学习进步! 321

【C++】C++17的主要特性

C++17引入多项重要特性:结构化绑定简化多值返回与遍历;inline变量解决头文件中变量定义的ODR问题,支持类内初始化;if/switch初始化语句允许在条件中声明变量,提升代码简洁性;属性语法(如[[nodiscard]]、[[deprecated]])增强代码可读性与安全性;求值顺序明确化,提高程序可预测性。这些改进显著提升了代码的简洁性、安全性和可维护性。

记录我一步步的学习历程,期待无限进步,向星举目! 355

【C++碎片化知识补充】C++ 里 int 也算对象?聊聊对象和变量的边界

盯着sessionId不就是个变量吗?变量凭什么能调用函数?后来才反应过来——它当然是对象。是我把对象这个词理解窄了。

2501_93351213的博客 363

【C++ 基础入门】C++11新特性(下):可变参数模板、lambda 表达式与包装器

C++11高阶特性(可变参数模板与参数包展开、emplace_back、lambda表达式与捕获列表、仿函数、std::function包装器)

2601_96587588的博客 274

C++ 入门教程:从零开始写出你的第一个程序

本文从环境搭建讲到面向对象和标准库,覆盖了 C++ 入门的主要知识点。建议你按章节顺序动手实践,把每个示例都编译运行一遍,再尝试修改参数观察输出变化。当你能独立写出一个带类设计的小项目时,就已经跨过了 C++ 的第一道门槛。

FJ39SfgYS的博客 179

#SQLite 数据库笔记一:(概念 / 终端指令 / SQL 语句 / C 编程 / 回调函数)

数据库 = 数据的仓库,假设数据是海量。能力说明存储数据持久化保存,程序退出数据还在统计数据、分组、排序数据管理增、删、改、查(CRUD)嵌入式设备上也会用数据库(单片机网关、路由器、工业 HMI 都常见),因为 sqlite 体积小、无需服务进程、单文件即可。数据库 = 库 > 表 > 记录(行) > 字段(列)sqlite3 = 开源、C 写的、单文件、免安装、最多 2T 的嵌入式关系型数据库。

lwq20051110的博客 264

1-10 PostgreSQL中多表连接全解:inner/left/right/full/cross join

本文基于 PostgreSQL 15+ 完整拆解 5 种主流连接:内连接、左连接、右连接、全连接、笛卡尔连接。结合可落地的测试数据,演示每种连接的执行逻辑、返回结果,重点剖析 NULL 值对 JOIN 匹配的核心影响,彻底解决多表连接数据丢失、匹配异常、结果错乱的问题。

zhangjw34的专栏 145

蓝桥杯·全国青少年信息素养大赛·电子学会Python/C++考级 备考:莫队算法离线区间查询详解

备赛进行时:第十八届蓝桥杯软件赛报名已于 2026-10-08 10:00 开启、12-18 14:00 截止,省赛定在 2027-04-10(C/C++·Python 程序设计 9:00–13:00);中国电子学会 2026 年 12 月软件编程(C/C++ 一级至十级、Python 一级至六级)考级报名 9/23–12/2 16:00、统考 12-12;全国青少年信息素养大赛 2026—2027 赛季算法应用主题赛也已进入复盘练兵窗口。

IT_Scratch的博客 187

2026年09月 GESP C++四级 选择+判断题全解析

2026年GESP C++四级选择题解析涵盖指针、引用、数组、排序等核心知识点。重点考察指针解引用与值修改(第1题)、指向常量的指针特性(第2题)、二维数组指针运算(第3题)、函数参数传递规则(第4题)、作用域与引用传参(第5题)、结构体传参方式(第6题)、结构体数组与指针操作(第7题)、排序算法性质(第8题)、递推实现跳台阶问题(第9题)及排序稳定性判断(第10题)。第11题考查插入排序的比较条件,正确答案为 a[j] > key。整体题目设计注重基础概念理解与实际应用能力。

weixin_45254471的博客 304
上一篇: 龍魂系统隐私保护与DNA身份机制 v2.0
下一篇: Python 全方位笔试题库
龍芯北辰UID9622
博客等级 码龄164天 5粉丝 501原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值