静态库和动态库如何制作及使用，区别是什么

静态库在程序的链接阶段链接到可执行文件中，其实静态库就是一堆目标文件的集合

构建静态库

alt

使用这个命令也可以编译成功，但是这样很繁琐，不如将其功能打包成一个静态库 gcc main.c ./src/add.c ./src/div.c ./src/mult.c ./src/sub.c ./include/head.h -o app

静态库制作

cd src

将源文件编译成目标文件

gcc -c add.c div.c mult.c sub.c

之后会编译而不链接生成 add.o dic.o mult.o sub.o

使用ar命令构建静态库

注意libcalc.a在使用-l时,链接器会忽略lib和.a前缀和后缀，所以只需要-lcalc即可

ar rv ../lib/libcalc.a add.o div.o mult.o sub.o

显示打包文件的内容

ar t ../lib/libcalc.a

编译main.c

gcc -c main.c

链接静态库并编译目标文件main.o,这里需要指定连接静态库的目录和包含头文件的目录

gcc main.o -o app -lcalc -L ./lib/ -I ./include/

运行可执行文件(编译链接后的) ./app

构建动态库

alt

到了程序中；动态库在链接阶段没有被复制到程序中，而是程序在运行时由系统动态加 载到内存中供程序调用。

cd src

PIC表示位置无关代码的意思 -f表示设置PIC为true

gcc -c -fPIC add.c sub.c mult.c div.c

gcc -shared add.o sub.o mult.o div.o -o ../lib/libcalc.so

gcc main.c -o app -I ./include/ -l calc -L ./lib/

直接运行./app会报错，找不到动态库的路径

  • 静态库：GCC 进行链接时，会把静态库中代码打包到可执行程序中
  • 动态库：GCC 进行链接时，动态库的代码不会被打包到可执行程序中
  • 程序启动之后，动态库会被动态加载到内存中，通过 ldd （list dynamic dependencies）命令检查动态库依赖关系
  • 如何定位共享库文件呢？ 当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径。 此时就需要系统的动态载入器来获取该绝对路径。 对于elf格式的可执行程序，是 由ld-linux.so来完成的， 它先后搜索elf文件的 DT_RPATH段 ——> 环境变量 LD_LIBRARY_PATH ——> /etc/ld.so.cache文件列表 ——>/lib/，/usr/lib 目录找到库文件后将其载入内存。

通过ldd指令检查app的动态依赖关系如下，发现找不到所以来的动态链接库libcalc.so的绝对路径。 以下方法只在当前终端有效

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/yeahqing/git/CppLearn/CxxProjects/静态库和动态库的构建/动态库的构建/lib

以下方法永久有效

方法一： 修改当前用户的环境变量 vim ~/.bashrc 最后一行插入： export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/usr_name/linux/lession06/library/lib source ~/.bashrc

修改系统环境变量 方法二： sudo vim /etc/profile 最后一行插入：export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/usr_name/linux/lession06/library/lib source /etc/profile

方法三 配置/etc/ld.so.cache文件列表 sudo vim /etc/ld.so.conf 最后一行插入：/home/usr_name/linux/lession06/library/lib sudo ldconfig

方法四 将所依赖度动态库复制到/lib或/usr/lib目录下也可，但不推荐，因为这两个目录下有大量的系统库文件

修改Ubuntu20.04下的终端只显示当前目录名

修改当前用户的~/.bashrc 使用:62找到第62行。 将里面的小写w改为大写W即可。之后保存退出，使用source ~/.bashrc使其生效。


if [ "$color_prompt" = yes ]; then
    PS1='${debian_chroot:+($debian_chroot)}\[\033[01;32m\]\u@\h\[\033[00m\]:\[\033[01;34m\]\w\[\033[00m\]\$ '
else
    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
fi

说一说STL 中常见容器的实现原理

【得分点】

vector、deque、stack、queue、list、set、map

【参考答案】

标准回答

  1. vector

vector 是一种动态数组，在内存中具有连续的存储空间，支持快速随机访问，由于具有连续的存储空间，所以在插入和删除操作方面，效率比较慢。

  1. deque

deque 是一种双向开口的连续线性空间，元素在内存连续存放，随机存取任何元素都在常数时间完成，在两端增删元素具有较佳的性能。

  1. stack

stack 是一种先进后出（First In Last Out，FILO）的数据结构，它只有一个出口。stack 容器允许新增元素，移除元素，取得栈顶元素，但是除了最顶端外，没有任何其他方法可以存取 stack 的其他元素，stack 不允许有遍历行为。

  1. queue

queue 是一种先进先出（First In First Out，FIFO）的数据结构，它有两个出口，queue 容器允许从一端新增元素，从另一端移除元素。

  1. list

list 内部实现的是一个双向链表，元素在内存不连续存放，在任何位置增删元素都能在常数时间完成，不支持随机存取。

  1. map map内部自建一棵红黑树（一种自平衡二叉树），这棵树具有数据自动排序的功能，所以在map内部所有的数据都是有序的，以二叉树的形式进行组织。

  2. set

set 底层使用红黑树实现，插入删除操作时仅仅移动指针即可，不涉及内存的移动和拷贝，所以效率比较高。set 中的元素都是唯一的，而且默认情况下会对元素进行升序排列。不能直接改变元素值，因为那样会打乱原本正确的顺序，要改变元素值必须先删除旧元素，再插入新元素。不提供直接存取元素的任何操作函数，只能通过迭代器进行间接存取。

简述一下堆和栈的区别

【得分点】

管理方式、空间大小、是否产生内存碎片、生长方向、分配方式、分配效率

【参考答案】

标准回答

堆和栈主要有如下几点区别：管理方式、空间大小、是否产生内存碎片、生长方向、分配方式、分配效率。

  1. 管理方式

对于栈来讲，是由编译器自动管理，无需手动控制；对于堆来说，分配和释放都是由程序员控制的。

  1. 空间大小

总体来说，栈的空间是要小于堆的。堆内存几乎是没有什么限制的；但是对于栈来讲，一般是有一定的空间大小的。

  1. 碎片问题

对于堆来讲，由于分配和释放是由程序员控制的（利用new/delete 或 malloc/free），频繁的操作势必会造成内存空间的不连续，从而造成大量的内存碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的数据结构，在某一数据弹出之前，它之前的所有数据都已经弹出。

  1. 生长方向

对于堆来讲，生长方向是向上的，也就是沿着内存地址增加的方向，对于栈来讲，它的生长方式是向下的，也就是沿着内存地址减小的方向增长。

  1. 分配方式

堆都是动态分配的，没有静态分配的堆。栈有两种分配方式：静态分配和动态分配，静态分配是编译器完成的，比如局部变量的分配；动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，它的动态分配是由编译器实现的，无需我们手工实现。

  1. 分配效率

栈是机器系统提供的数据结构，计算机会在底层对栈提供支持，分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率很高。堆则是C/C++ 函数提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率要比栈底的多。

编程题: 01背包问题，动态规划

版本1


int knapsack(int V, int n, vector<vector<int> >& vw) {
 	vector<vector<int>> dp(n+1, vector<int>(V+1));
  
  	for (int i = 1; i <= n; i++)
    {
    	for (int j = 1; j <= V; j++)
        {
        	dp[i][j] = dp[i-1][j];
          	if (j >= vw[i-1][0])
            {
            	dp[i][j] = max(dp[i][j], dp[i-1][j-vw[i-1][0]] + vw[i-1][1]);
            }
        }
    }
  	return dp[n][V];
}



int knapsack(int V, int n, vector<vector<int> >& vw) {
	
  vector<int> dp(V+1, 0);
  
  for(int i = 0; i < n; i++){
  	for (int j = V; j >= vw[i][0]; j--)
    {
    	dp[j] = max(dp[j], dp[j - vw[i][0]] + vw[i][1]);
    }
  }
  
  return dp[V];
}