C++学习日记 | LAB 6 static library 静态库

资料来源：南科大 余仕琪 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_ptrusing namespace std;#define SIZE 5int 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 memoryunique_ptr<int[]> pa(new int[SIZE]{3, 5, 8, 2, 6});int total = sum(pa.get(), SIZE); // Use pa.get() to access the raw pointercout << "sum = " << total << endl;// No need to manually delete pa; it will be automatically cleaned up when it goes out of scopereturn 0;
}

---

•  什么情况下应该使用裸指针而不是智能指针？

1. 裸指针（原生指针）：

   • 裸指针是指直接使用 T* 类型的指针，没有被智能指针封装。
   • 适用情况：
     • 无所有权语义：当你不需要管理资源的所有权时，可以使用裸指针。例如，函数参数传递时，如果不涉及资源所有权的转移，可以使用裸指针或引用。
     • 性能要求高：裸指针操作更轻量，不涉及引用计数等开销，适用于性能敏感的场景。

2. 智能指针：

   • 智能指针是 C++ 提供的 RAII（资源获取即初始化）机制的一部分，用于管理动态分配的内存。
   • 适用情况：
     • 资源管理：在资源获取时，应优先使用智能指针。它们可以自动清理内存，避免内存泄漏。
     • 明确所有权：当需要明确资源的所有权转移时，使用 std::unique_ptr 或 std::shared_ptr。
     • 线程安全：std::shared_ptr 可以在多线程环境中共享资源。

3. 总结：

   • 使用裸指针时，要确保不会出现悬空指针、多次释放等问题。
   • 使用智能指针时，可以更安全地管理资源，但要根据具体情况选择合适的类型。

---

习题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 functionsum(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);
#endif

swap.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博客）而不是传统的参数作为函数输入。

使用引用作为函数的输入

1. 引用可以直接修改原始变量的值： 当我们传递参数时，如果使用引用，我们实际上传递的是原始变量的引用，而不是它的副本。这意味着在函数内部对引用的修改会直接影响原始变量。如果我们使用值传递（int），则函数内部的修改只会影响参数的副本，而不会影响原始变量。

2. 效率更高： 使用引用避免了复制大型对象的开销。当我们传递大型结构体或类对象时，使用引用可以提高性能，因为不需要复制整个对象。

3. 语义更清晰： 使用引用可以更清楚地表达我们的意图。当我们在函数中看到引用参数时，我们知道这个函数可能会修改原始变量的值。