gcc生成静态库和动态库以及静态的.a和.so库文件的生成与使用。以及重温全局常量、全局变量、局部变量、静态变量、堆、栈等概念，在Ubuntu（x86）系统和STM32(Keil)中分别进行编程、验证

1.gcc生成静态库和动态库

1.1什么是静态库和动态库

静态库和动态库都是存储在磁盘上的库文件，包含了一些可以被程序调用的函数、变量和其他可执行对象。它们都是编译链接的结果。但是，它们之间有以下几个不同点：

1. 静态库是在编译链接时将库文件的代码复制到可执行文件中的方式进行链接，而动态库是在程序运行时加载并链接的方式进行链接。

2. 静态库在编译链接时就已经确定了，即使库文件本身更新了，也需要重新编译链接程序。而动态库可以在不重新编译链接程序的情况下更新。

3. 静态库会增加可执行文件的大小，因为库文件的代码被复制到了可执行文件中。而动态库不会直接增加可执行文件的大小，因为它们只会在运行时被加载。

4. 静态库的调用速度比动态库快，因为它们已经被编译链接到可执行文件中，不需要运行时加载。但是，静态库会增加可执行文件的大小。而动态库的调用速度相对较慢，因为需要在运行时加载，但是动态库的使用可以减小可执行文件的大小，节省存储空间。

通常来说，静态库适合用于程序较小的情况下，因为可以减少运行时的加载速度。而动态库适合于程序较大的情况下，因为可以减小可执行文件的大小，节省存储空间。

1.2hello实例应用

1.文件创建

使用gedit创建文件：hello.h hello.c main,c

ps:为了方便管理文件储存位置，在创建文件前先创建文件目录

mkdir test1
cd test1 ##此处是移动到创建目录

创建文件

hello.h

#ifndef HELLO_H
#define HELLO_H
void hello(const char *name);
#endif//HELLO_H

hello.c

#include<stdio.h>
void hello(const char *name)
{
	printf("Hello %s\n",name);
}

main.c

#include"hello.h"
int main()
{
	hello("everyone");
	return 0;
}

 (3). gcc编译得到.o文件

gcc -c hello.c

生成后使用ls查看生成的文件 

2.生成静态库

1)创建静态库
创建静态库的工具：ar
静态库文件命名规范：以lib作为前缀,是.a文件

ar -crv libmyhello.a hello.o

(2)程序中使用静态库

①gcc -o hello main.c -L. -lmyhello

注意：对于自定义的静态库，main.c还可以放在-L.和-lmyhello之间，否则myhello没有定义。
-L.：表示连接的库在当前目录

gcc main.c libmyhello.a -o hello

③

先生成main.o gcc -c main.c
生成可执行文件 gcc -o hello main.c libmyhello.a

(3)验证静态库的特点
在删掉静态库的情况下，运行可执行文件，发现程序仍旧正常运行，表明静态库跟程序执行没有联系。同时，也表明静态库是在程序编译的时候被连接到代码中的。

./hello

3.动态库的使用

(1). 创建动态库
创建动态库的工具：gcc
动态库文件命名规范：以lib作为前缀,是.so文件

gcc -shared -fPIC -o libmyhello.so hello.o

shared:表示指定生成动态链接库，不可省略
-fPIC：表示编译为位置独立的代码，不可省略

命令中的-o一定不能够被省略

(2). 在程序中执行动态库

gcc -o hello main.c -L. -lmyhello
gcc main.c libmyhello.so -o hello

再运行可执行文件hello，会出现错误

问题的解决方法：将libmyhello.so复制到目录/usr/lib中。由于运行时，是在/usr/lib中找库文件的。

mv libmyhello.so /usr/lib

4.静态库与动态库比较

gcc编译得到.o文件 gcc -c hello.c
创建静态库 ar -crv libmyhello.a hello.o
创建动态库 gcc -shared -fPIC -o libmyhello.so hello.o
使用库生成可执行文件 gcc -o hello main.c -L. -lmyhello
执行可执行文件 ./hello

在执行可执行文件，会报一个错误，可见当静态库和动态库同时存在的时候，程序会优先使用动态库。

1.3:实例2使用库

创建文件A1.c  A2. c A.h test.c

A1.c

#include<stdio.h>
void print1(int arg)
{
	printf("A1 print arg:%d\n",arg);
}

A2.c

#include<stdio.h>
void print2(char *arg)
{
	printf("A2 printf arg:%s\n",arg);
}

A.h

#ifndef A_H
#define A_H
void print1(int);
void print2(char *);
#endif

 test.c

#include<stdio.h>
#include"A.h"
int main()
{
	print1(1);
	print2("test");
	exit(0);
}

 

 二、总结

通过程序用gcc生成静态库和动态库的练习过程，基本上能够熟练的生成静态库和动态库。在两种库的比较中，能够明显看出两者的差别。虽然，过程中，遇到一些小问题，但是很快就解决了。只要慢慢多练几遍，便很快能够掌握。可执行文件是通过编译链接获取得到的，利用工具将源码编译得到.o文件，接下来就是将.o文件链接得到可执行文件。

三. 编写一个C程序

重温全局常量、全局变量、局部变量、静态变量、堆、栈等概念，在Ubuntu（x86）系统和STM32(Keil)中分别进行编程、验证（STM32 通过串口printf 信息到上位机串口助手) 。1）归纳出Ubuntu、stm32下的C程序中堆、栈、全局、局部等变量的分配地址，进行对比分析；2）加深对ARM Cortex-M/stm32F10x的存储器地址映射的理解。

编写一个ubantu c程序。
 

#include <stdio.h>

// 全局常量
const int global_constant = 10;

// 全局变量
int global_variable = 20;

void function()
{
    // 局部变量
    int local_variable = 30;

    // 静态变量
    static int static_variable = 40;
}

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

编译和运行该程序以获得地址信息。在Ubuntu上使用gcc编译器进行编译并执行生成的可执行文件

gcc memory_allocation.c -o memory_allocation
./memory_allocation

在程序中添加代码来打印变量的地址，并将结果输出到终端或串口助手。例如，在function()函数中添加以下代码：

void function()
{
    // 局部变量
    int local_variable = 30;

    // 打印局部变量的地址
    printf("Local variable address: %p\n", &local_variable);

    // 静态变量
    static int static_variable = 40;

    // 打印静态变量的地址
    printf("Static variable address: %p\n", &static_variable);
}

在STM32上，你可以使用HAL库函数和串口打印来输出地址信息。例如：

#include "stm32f10x.h"
#include "stdio.h"

// 全局变量
int global_variable = 20;

void function()
{
    // 局部变量
    int local_variable = 30;

    // 打印局部变量的地址
    printf("Local variable address: %p\n", &local_variable);

    // 静态变量
    static int static_variable = 40;
    
    // 打印静态变量的地址
    printf("Static variable address: %p\n", &static_variable);
}

int main(void)
{
    // 初始化串口
    USART_Init(/* 串口参数 */);
    
    // 打开串口
    USART_Cmd(USART1, ENABLE);

    // 输出全局变量的地址
    printf("Global variable address: %p\n", &global_variable);

    function();

    while (1)
    {
        // 主循环
    }
}

使用Keil进行编译并在STM32上烧录该程序。通过串口助手监视输出，即可查看变量的地址。

四：总结

通过比较Ubuntu和STM32下的C程序中堆、栈、全局和局部变量的分配地址，以及ARM Cortex-M / stm32F10x的存储器地址映射，可以加深对这些概念和存储器地址映射的理解

一般而言，程序内变量在堆栈上的分配，栈是由高地址到低地址，堆是由低地址到高地址。

在Ubuntu下，栈区的地址存储是向上增长，堆区的地址存储也是向上增长；
在STM32下，栈区的地址存储是向下增长，堆区的地址存储却是向上增长。

可是为什么Ubuntu下，栈区的地址值也是增长的？
：

在Ubuntu环境下，栈区的地址值也会增长，这是因为操作系统使用了分段（segmentation）或分页（paging）技术来实现内存管理。

分段是一种将内存划分为不同段（每个段具有不同的特性和用途）的技术。每个进程都有自己的代码段、数据段和栈段。当进程被创建时，操作系统会为每个段分配一个独立的内存空间，并且每个段的地址空间都是独立的。

当函数被调用时，会在栈段中创建一个新的栈帧（stack frame），用于存储函数的局部变量、参数和返回地址。当函数返回时，其对应的栈帧会被销毁，而栈指针会指向下一个可用的栈帧。

由于每个进程都有自己的内存空间，因此不同进程的栈空间是独立的。当一个进程被切换到后台运行时，它的内存空间仍然被保留，以便在它再次获得CPU时可以继续使用。

因此，即使在Ubuntu环境下，栈区的地址值也会随着函数调用和返回而增长，但这仅限于单个进程的栈空间，不同进程的栈空间是相互独立的。