资料来源：南科大 余仕琪 C/C++ Program Design
LINK：CPP/week06 at main · ShiqiYu/CPP · GitHub
一、本节内容
本节主要介绍静态库和动态库。
1.1 静态库和动态库的概念
静态链接和静态库(也称为存档)是链接器将所有使用的库函数复制到可执行文件的结果。静态链接会创建更大的二进制文件，并且需要更多的磁盘和主存空间。静态库的示例包括Linux中的.a文件和Windows中的.lib文件。
动态链接和动态库动态链接不需要复制代码，只需将库的名称放在二进制文件中即可。实际的链接发生在程序运行时，当二进制文件和库都在内存中时。如果系统中的多个程序链接到同一动态链接库，则它们都引用该库。因此，该库由多个程序共享，称为“共享库”。动态库的示例包括Linux中的.so和Windows中的.dll。
1.2 静态库和动态库的区别
| 优点 | 缺点 | |
| 静态库 | 1.使可执行文件具有较少的依赖关系，已打包成可执行文件。 2.链接在编译阶段完成，代码在执行过程中快速加载。 | 1.使可执行文件比那的更大。 2.作为依赖于另一个库的库将导致冗余副本，因为它必须与目标文件打包在一起。 3.升级不方便、不容易。需要替换并重新编译整个可执行文件。 |
| 动态库 | 1.动态库可以实现进程间的资源共享，只能有一个库文件。 2.升级过程简单，不需要重新编译。 | 1.运行时加载会降低代码的执行速度。 2.添加必须伴随可执行文件的程序依赖项。 |
1.3 静态库的建立方法
假设我们编写了以下代码：
二、习题笔记
习题1
存在的问题：使用new却后续没有释放内存（gpt说的）
问题出在使用 new int[SIZE] 分配内存的那一行。当使用 new 动态分配内存时，需要在使用完后使用 delete 来释放这块内存。然而，在代码中，没有相应的 delete 语句来释放为 pa 分配的内存。
为了解决这个问题，使用智能指针可以自动管理内存，避免手动释放的问题。例如，std::unique_ptr<int> p(new int); 将在作用域结束时自动释放内存。
#include <iostream>
#include <memory> // Include the <memory> header for std::unique_ptr
using namespace std;
#define SIZE 5
int sum(const int *pArray, int n)
{
int s = 0;
for (int i = 0; i < n; i++)
s += pArray[i];
return s;
}
int main()
{
// Use std::unique_ptr to manage memory
unique_ptr<int[]> pa(new int[SIZE]{3, 5, 8, 2, 6});
int total = sum(pa.get(), SIZE); // Use pa.get() to access the raw pointer
cout << "sum = " << total << endl;
// No need to manually delete pa; it will be automatically cleaned up when it goes out of scope
return 0;
}
- 什么情况下应该使用裸指针而不是智能指针？
-
裸指针（原生指针）：
- 裸指针是指直接使用
T*类型的指针，没有被智能指针封装。 - 适用情况：
- 无所有权语义：当你不需要管理资源的所有权时，可以使用裸指针。例如，函数参数传递时，如果不涉及资源所有权的转移，可以使用裸指针或引用。
- 性能要求高：裸指针操作更轻量，不涉及引用计数等开销，适用于性能敏感的场景。
- 裸指针是指直接使用
-
智能指针：
- 智能指针是 C++ 提供的 RAII（资源获取即初始化）机制的一部分，用于管理动态分配的内存。
- 适用情况：
- 资源管理：在资源获取时，应优先使用智能指针。它们可以自动清理内存，避免内存泄漏。
- 明确所有权：当需要明确资源的所有权转移时，使用
std::unique_ptr或std::shared_ptr。 - 线程安全：
std::shared_ptr可以在多线程环境中共享资源。
-
总结：
- 使用裸指针时，要确保不会出现悬空指针、多次释放等问题。
- 使用智能指针时，可以更安全地管理资源，但要根据具体情况选择合适的类型。
习题2
仿真结果：
问题分析：
在 create_array 函数中，声明了一个名为 arr 的整数数组，并在函数内部对其进行赋值。然后，返回了指向这个局部数组的指针 arr。问题在于，局部数组 arr 是在栈上分配的，而指针 ptr 在 main 函数中持有这个指向局部数组的地址。当 create_array 函数结束时，局部数组 arr 将被销毁，但指针 ptr 仍然指向已经不存在的内存区域
为了避免内存泄漏，我们需要使用动态分配的内存（在堆上分配）来存储数组。我们可以使用 new 运算符来分配堆内存，并返回指向堆内存的指针。
#include <iostream>
using namespace std;
int *create_array(int size)
{
int *arr = new int[size]; // 使用 new 分配堆内存
for (int i = 0; i < size; i++)
arr[i] = i * 10;
return arr;
}
int main()
{
int len = 16;
int *ptr = create_array(len);
for (int i = 0; i < len; i++)
cout << ptr[i] << " ";
delete[] ptr; // 释放堆内存
return 0;
}
仿真结果：
习题3
问题分析：sum函数中常数指针不能被修改赋值
修改方案：将pa改为普通指针
#include <iostream>
#define SIZE 5
void sum( int *, const int *, int);
int main()
{
int a[SIZE] = {10,20,30,40,50};
int b[SIZE] = {1,2,3,4,5};
std::cout << "Before calling the function, the contents of a are:" << std::endl;
for(int i = 0; i < SIZE; i++)
std::cout << a[i] << " ";
// passing arrays to function
sum(a,b,SIZE);
std::cout << "\nAfter calling the function, the contents of a are:" << std::endl;
for(int i = 0; i < SIZE; i++)
std::cout << a[i] << " ";
std::cout << std::endl;
return 0;
}
void sum( int *pa, const int *pb, int n)
{
for(int i = 0; i < n; i++)
{
*pa += *pb;
pa++;
pb++;
}
}
习题4
swap.hpp
#ifndef __SWAP_HPP__
#define __SWAP_HPP__
void swap(int& a, int& b);
#endifswap.cpp
#include <iostream>
#include "swap.hpp"
void swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}main.cpp
#include <iostream>
#include "swap.hpp"
int main()
{
int x = 10;
int y = 20;
std::cout << "Before swapping: x = " << x << ", y = " << y << std::endl;
// 调用交换函数
swap(x, y);
std::cout << "After swapping: x = " << x << ", y = " << y << std::endl;
return 0;
}
按照1.3节内容进行操作，结果如下所示、将生成的libswap.a库文件移除之后仍然可以正常运行可执行文件，表面成功建立静态库。
在编写swap.cpp中使用了引用（参考C++学习日记 | Lecture 6 函数-CSDN博客）而不是传统的参数作为函数输入。
使用引用作为函数的输入
引用可以直接修改原始变量的值： 当我们传递参数时，如果使用引用，我们实际上传递的是原始变量的引用，而不是它的副本。这意味着在函数内部对引用的修改会直接影响原始变量。如果我们使用值传递（
int），则函数内部的修改只会影响参数的副本，而不会影响原始变量。效率更高： 使用引用避免了复制大型对象的开销。当我们传递大型结构体或类对象时，使用引用可以提高性能，因为不需要复制整个对象。
语义更清晰： 使用引用可以更清楚地表达我们的意图。当我们在函数中看到引用参数时，我们知道这个函数可能会修改原始变量的值。
