2. 程式人生 > >c語言模組化開發(GCC編譯例項)

c語言模組化開發(GCC編譯例項)

阿新 • • 發佈：2018-12-02

c語言編譯步驟，即一個*.c檔案是如何一步步成為*.exe的?

參見：C語言真正的編譯過程

window下GCC(minGW)的安裝

參見：MinGW下載安裝

GCC常見命令：

參見：Linux GCC常用命令

本人理解的c語言編譯過程、中間檔案、常用命令

 

本次實驗環境：

window7、minGW

實驗程式碼：https://download.csdn.net/download/u010476739/10800828

實驗一、編譯單個檔案

程式碼 test.c

#include <stdio.h>
#include <stdlib.h>
int main()
{
	printf("hello\n");
	system("pause");
}

gcc命令：(gcc test.c -o test.exe -save-temps)

編譯結果：

雙擊執行test.exe

實驗二、編譯多個檔案

目錄：
    sub.h
    sub.c
    main.c

程式碼sub.h

#ifndef MY_MATH
#define MY_MATH
	int add(int,int);
	int sub(int,int);
#endif

程式碼sub.c

int add(int x,int y)
{
	return x+y;
}
int sub(int x,int y)
{
	return x-y;
}

程式碼main.c

#include <stdio.h>
#include <stdlib.h>
#include "sub.h"
int main()
{
	int a=5;
	int b=2;
	printf("add(a,b)=%d\n",add(a,b));
	printf("sub(a,b)=%d\n",sub(a,b));
	system("pause");
	return 0;
}

執行命令：

gcc sub.c main.c -o test.exe

實驗三、模組化程式設計

檔案目錄結構:
    header
        m1.h
        m2.h
    mod1
        m1.c
    mod2
        m2.c
    main.c

程式碼:
m1.h
    

#ifndef M1
    #define M1
    int add(int,int);
#endif


m2.h
    

#ifndef M2
    #define M2
    int sub(int,int);
#endif


m1.c
    

int add(int x,int y)
{    
       return x+y;
}


m2.c
    

int sub(int x,int y)
{
        return x-y;
}


main.c

#include <stdio.h>
 #include <stdlib.h>

#include "header/m1.h"
#include "header/m2.h"

int main()
{
      int a=5,b=3;
      printf("add(a,b)=%d\n",add(a,b));
      printf("sub(a,b)=%d\n",sub(a,b));
      system("pause");
}

編譯方案一、各自單獨編譯,最後連結成exe程式
    1.編譯模組mod1(僅需要m1.c)
        cd mod1
        gcc -c m1.c -o m1.obj
    2.編譯模組mod2(僅需要m2.c)
        cd mod2
        gcc -c m2.c -o m2.obj
    3.編譯主模組main
        cd ..
        gcc -c main.c -o main.obj
    4.將main.obj,m1.obj,m2.obj連結到一起
        gcc main.obj mod1/m1.obj mod2/m2.obj -o test.exe

編譯方案二、直接編譯
    直接將這些檔案編譯成exe可執行程式
    gcc main.c mod1/m1.c mod2/m2.c -o test.exe

實驗四、gcc命令選項

檔案目錄結構:
    header
        m1.h
        m2.h
    mod1
        m1.c
    mod2
        m2.c
    main.c

程式碼:
m1.h
    

#ifndef M1
    #define M1
    int add(int,int);
#endif


m2.h
    

#ifndef M2
    #define M2
    int sub(int,int);
#endif


m1.c
    

int add(int x,int y)
{
      return x+y;
}


m2.c
  

 int sub(int x,int y)
{
     return x-y;
}


main.c
  

#include <stdio.h>
#include <stdlib.h>

#include "m1.h"
#include "m2.h"

int main()
{
      int a=5,b=3;
      printf("add(a,b)=%d\n",add(a,b));
      printf("sub(a,b)=%d\n",sub(a,b));
      system("pause");
}

1.編譯主模組main.c 並指定include查詢的路徑
    gcc -I ./header -c main.c -o main.obj
2.編譯模組m1.c
    gcc -c mod1/m1.c -o mod1.obj
3.編譯模組m2.c
    gcc -c mod2/m2.c -o mod2.obj
4.將編譯的結果連結為一個exe程式
    gcc main.obj mod1/m1.obj mod2/m2.obj -o test.exe

實驗五、gcc生成動態庫dll檔案

目錄結構:
myfunc
    myfunc.h
    myfunc.c
main.c

程式碼:
myfunc.h

#ifndef MYFUNC
    #define MYFUNC
    int add(int,int);
#endif

myfunc.c

int add(int x,int y)
{
    return x+y;
}

main.c

#include <stdio.h>
#include <stdlib.h>
int add(int,int);
int main()
{
        int a=10,b=2;
        printf("add(a,b)=%d\n",add(a,b));
        system("pause");
}

編譯思路:
    首先將myfunc.c編譯為動態庫檔案myfunc.dll,myfunc.h檔案可以供外面呼叫
    然後編譯main.c檔案並使用myfunc.dll連結為main.exe可執行檔案
    將myfunc.dll拷貝到main.exe同一個目錄下,雙擊main.exe可檢視效果

1.編譯myfunc.c檔案為動態庫myfunc.dll
    cd myfunc
    gcc myfunc.c -shared -o myfunc.dll
2.編譯main.c檔案並連結為main.exe可執行程式
    cd ..
    gcc main.c myfunc/myfunc.dll -o main.exe
3.將myfunc/myfunc.dll檔案拷貝至與main.exe同目錄後雙擊執行main.exe

實驗六、gcc生成靜態庫lib檔案

目錄結構:
    staticmod
        mod.h
        mod.c
    main.c

程式碼:
mod.h
    

#ifndef MOD
    #define MOD
    int add(int,int);
#endif


mod.c
    

int add(int x,int y)
{
     return x+y;
}


main.c
    

#include <stdio.h>
#include <stdlib.h>

int add(int,int);
int main()
{
     int a=1,b=6;
     printf("add(a,b)=%d\n",add(a,b));
     system("pause");
     return 0;
}

實現思路:
    首先將mod.c編譯為靜態連結庫 mod.lib(僅mod.c就可以了)
    然後編譯main.c生成main.exe,生成後的main.exe可單獨執行
1.將mod.c編譯生成靜態連結庫
    cd staticmod
    gcc -c mod.c -o mod.obj
    使用ar將obj檔案打包成.lib檔案
    ar -crv mod.lib mod.obj
2.編譯main.c生成main.exe可執行程式
    cd ..
    gcc main.c staticmod/mod.lib -o main.exe
    雙擊生成後的main.exe即可執行
    

實驗七、gcc生成的多個動態庫相互引用

目錄結構:
mod1
    m1.c
    m1.h
mod2
    m2.h
    m2.c
mod3
    m3.h
    m3.c
main.c

程式碼:
m1.h
    

#ifndef MOD1
    #define MOD1
    int func1(x,y);
#endif


m1.c
    

int func1(int x,int y)
{
      return x+y;
}


m2.h
    

#ifndef MOD2
    #define MOD2
    int func2(int,int);
#endif


m2.c
    

int func1(int,int);
int func2(int x,int y)
{
      int res=func1(x,y);
      res=res+2;
      return res;
}


m3.h
  

#ifdefine MOD3
    #define MOD3
    int func3(int,int);
#endif


m3.c
  

int func2(int,int);
int func3(int x,int y)
{
      int res=func2(x,y);
      res+=3;
      return res;
}


main.c
    

#include <stdio.h>
#include <stdlib.h>
int func3(int,int);
int main()
{
     int a=10,b=2;
     printf("func3(a,b)=%d\n",func3(a,b));
     system("pause");
     return 0;
}

實現思路:
    首先將m1.c編譯為動態庫m1.dll,m2.c編譯為m2.dll,m3.c編譯為m3.dll
    然後將main.c編譯並連結為main.exe,將m1.dll,m2.dll,m3.dll拷貝到main.exe同目錄下,然後雙擊main.exe執行可以看到效果
1.將m1.c編譯為m1.dll
    cd mod1
    gcc -shared m1.c -o m1.dll
2.將m2.c編譯為m2.dll
    cd ../mod2
    gcc -shared m2.c ../mod1/m1.dll -o m2.dll
3.將m3.c編譯為m3.dll
    cd ../mod3
    gcc -shared m3.c ../mod2/m2.dll -o m3.dll
4.將main.c編譯為main.exe
    cd ..
    gcc main.c mod3/m3.dll -o main.exe
    將m1.dll,m2.dll,m3.dll拷貝到main.exe同目錄下,雙擊main.exe即可看到效果

實驗八、gcc生成的多個靜態庫相互引用

mod1是一個靜態庫,mod2是一個靜態庫引用了mod1,主模組main引用了mod2
目錄結構:
mod1
    m1.h
    m1.c
mod2
    m2.h
    m2.c
main.c

程式碼:
m1.h
    

#ifndef MOD1
    #define MOD1
    int func1(int,int);
#endif


m1.c
    

int func1(int x,int y)
{
      return x+y;
}


m2.h
    

#ifndef MOD2
    #define MOD2
    int func2(int,int);
#endif


m2.c
    

int func1(int,int);
int func2(int x,int y)
{
      int res=func1(x,y);
      res+=3;
      return res;
}


main.c
  

 #include <stdio.h>
 #include <stdlib.h>

 int func2(int,int);
 int main()
 {
       int a=10,b=5;
       printf("func2(a,b)=%d\n",func2(a,b));
       system("pause");
 }


實現思路:
    首先將mod1編譯成obj檔案,可以考慮繼續打包成lib檔案
    然後將mod2編譯成obj檔案,然後將mod1的obj檔案和mod2的obj檔案一塊打包成m2.lib檔案
    最後編譯main.c引用m2.lib檔案即可
1.將mod1編譯成obj檔案
    cd mod1
    gcc -c m1.c -o m1.obj
    下一條命令可選
    ar -crv m1.lib m1.obj
2.將mod2編譯成obj檔案
    cd ../mod2
    gcc -c m2.c -o m2.obj
    將m1.obj和m2.obj聯合打包成m2.lib檔案
    ar -crv m2.lib ../mod1/m1.obj m2.obj
3.編譯main.c
    cd ..
    gcc main.c mod2/m2.lib -o main.exe
    雙擊執行main.exe即可看到效果

實驗九、gcc生成exe同時引用動態庫和靜態庫

主模組同時引用靜態庫和動態庫:
mod1是一個靜態庫,mod2是一個動態庫,主模組main引用了mod1和mod2
目錄結構:
mod1
    m1.h
    m1.c
mod2
    m2.h
    m2.c
main.c
程式碼:
m1.h
    

#ifndef MOD1
    #define MOD1
    int func1(int,int);
#endif


m1.c
    

int func1(int x,int y)
{
      return x+y;
}


m2.h
    

#ifndef MOD2
    #define MOD2
    int func2(int,int);
#endif


m2.c
    

int func2(int x,int y)
{
     return x-y;
}


main.c
    

#include <stdio.h>
#include <stdlib.h>

int func1(int,int);
int func2(int,int);
int main()
{
     int a=10,b=5;
     printf("func1(a,b)=%d\n",func1(a,b));
     printf("func2(a,b)=%d\n",func2(a,b));
     system("pause");
}


實現思路:
    首先將mod1編譯成obj並繼續打包成lib檔案,將mod2直接編譯為dll檔案
    然後編譯main.c引用m1.lib和m2.dll檔案即可,將m2.dll拷貝到main.exe同目錄雙擊執行即可
1.將mod1編譯成obj檔案並打包成lib檔案
    cd mod1
    gcc -c m1.c -o m1.obj
    ar -crv m1.lib m1.obj
2.將mod2編譯成dll檔案
    cd ../mod2
    gcc -shared m2.c -o m2.all
3.編譯main.c
    cd ..
    gcc main.c mod1/m1.lib mod2/m2.dll -o main.exe
    將m2.dll拷貝到main.exe同目錄,雙擊main.exe執行即可看到效果


實驗十、gcc靜態庫引用動態庫

mod1是動態庫,mod2是靜態庫並且引用mod1,,主模組引用mod2
目錄結構:
    mod1
        m1.h
        m1.c
    mod2
        m2.h
        m2.c
    main.c

程式碼:
m1.h
    

#ifndef MOD1
    #define MOD1
    int func1(int,int);
#endif


m1.c
    

int func1(int x,int y)
{
    return x+y;
}


m2.h
    

#ifndef MOD2
    #define MOD2
    int func2(int,int);
#endif


m2.c
    

int func1(int,int);
int func2(int x,int y)
{
     int res=func1(x,y);
     return res+3;
}


main.c
    

#include <stdio.h>
#include <stdlib.h>

int func2(int,int);
int main()
{
    int a=15,b=2;
    printf("func2(a,b)=%d\n",func2(a,b));
    system("pause");
}


實現思路:
    首先將mod1編譯為m1.dll
    然後將mod2編譯為m2.obj並將m2.obj打包為m2.lib
    最後編譯main.c並引用m2.lib和m1.dll生成main.exe
    將m1.dll拷貝至main.exe同目錄,雙擊執行即可看到效果

實驗十一、gcc動態庫引用靜態庫

mod1是靜態庫,mod2是動態庫並且引用mod1,主模組引用mod2
目錄結構:
mod1
    m1.h
    m1.c
mod2
    m2.h
    m2.c
main.c
程式碼:
m1.h
    

#ifndef MOD1
    #define MOD1
    int func1(int,int);
#endif


m1.c
    

int func1(int x,int y)
{
      return x+y;
}


m2.h
    

#ifndef MOD2
#define MOD2
    int func2(int,int);
#endif


m2.c
    

int func1(int,int);
int func2(int x,int y)
{
      int res=func1(x,y);
      return res+6;
}


main.c
  

#include <stdio.h>
#include <stdlib.h>

int func2(int,int);
int main()
{
     int a=12,b=3;
     printf("func2(a,b)=%d\n",func2(a,b));
     system("pause");
}


實現思路:
    首先將m1.c編譯為m1.obj並打包為m1.lib
    然後將m2.c編譯為m2.dll(gcc -shared m2.c ../mod1/m1.lib -o m2.dll)
    最後編譯主模組,引用了m2.dll,將m2.dll拷貝至main.exe同目錄,雙擊main.exe即可看到效果
1.將m1.c編譯為m1.obj並打包為m1.lib
    cd mod1
    gcc -c m1.c -o m1.obj
    ar -crv m1.lib m1.obj
2.將m2.c編譯為m2.dll
    cd ../mod2
    gcc -shared m2.c ../mod1/m1.lib -o m2.dll
3.編譯main.c
    cd ..
    gcc main.c mod2/m2.dll -o main.exe
    然後將m2.dll拷貝至main.exe同目錄,雙擊main.exe即可看到效果
    
    
    

相關推薦

c語言模組化開發(GCC編譯例項)

c語言編譯步驟，即一個*.c檔案是如何一步步成為*.exe的? 參見：C語言真正的編譯過程 window下GCC(minGW)的安裝 參見：MinGW下載安裝 GCC常見命令： 參見：Linux GCC常用命令 本人理解的c語言編譯過程、中間檔案、常用命令 &n

C語言模組化程式設計

注：不想看我的心路歷程的同學可以直接看加粗字型。 學習過C語言的同學們想必都聽說過模組化程式設計，各類C語言書籍也都陳列了模組化程式設計的好處。 筆者是積體電路類的本科學生，在大一下的時候學校開設C語言程式設計課程，但是如何進行模組化程式設計卻幾乎沒有書籍提起，

C語言Windows程序開發—MessageBox函數介紹【第01天】

class ner windows.h can lpctstr 字符串 return napi ext （一）MessageBox函數的參數介紹： 1 int MessageBox ( 2 HWND hWnd, //彈出Messa

C語言Windows程序開發—TextOut函數介紹【第02天】

菜單 stock rec null 主函數 callback 介紹 關閉 windows.h （一）TextOut函數的參數介紹： 1 BOOL TextOut ( //如果函數調用成功，返回TRUE，否則，返回FALSE 2 H

js-模組化開發總結

一.模組開發的概念 模組化開發是什麼：模組化開發是一種生產方式，這種方式生產效率高，維護成本低。從軟體開發的角度說，模組化開發是一種開發模式，寫程式碼的一種方式，開發效率高，維護成本低。 為什麼需要模組化開發：當一個專案開發的越來越複雜的時候，會遇到一些問題,比如命名衝突（重新命名），檔

模組化開發(requireJS)

模組化 在前端使用模組化開發，可以將程式碼根據功能實施模組的劃分，每個模組功能（職責）單一，在需要更改對應的功能的時候，只需要對指定的模組進行修改，其他模組不受任何影響。 為什麼要進行前端模組化？ 達到公共模組的複用 可以很好的解決全域性變數汙染的問題 可以很好的解決各個功能之間的依賴關係

javascript 模組化開發

一、為什麼會有模組化 1. 當一個專案開發的越來越複雜的時候，會遇到一些問題，比如： 命名衝突：當專案由團隊進行協作開發的時候，不同開發人員的變數和函式命名可能相同；即使是一個開發，當開發週期比較長的時候，也有可能會忘記之前使用了什麼變數，從而導致重複命名，導致命

沒有前戲，簡明扼要的進入主題——什麼是模組化開發？

模組化開發，一個模組就是一個實現特定功能的檔案，有了模組我們就可以更方便的使用別人的程式碼，要用什麼功能就載入什麼模組。 模組化開發的4點好處： 　　1 避免變數汙染，命名衝突 　　2  提高程式碼複用率 　　3 提高維護性 　　4 依賴關係的管理

初識模組化開發工具：

初識模組化開發工具：git 是分散式程式碼管理工具，管理程式碼的npm 是包管理工具，管理外掛、工具啊，是個轉換器，他是哪來的了，他是伴隨node下載下來的，版本也是伴隨node變化；node 是個後臺的環境；首先安裝node，然後用命令安裝browserify：npm install -g browseri

C語言Windows程式開發—Windows視窗樣式與常用控制元件樣式【第04天】

（一）Windows視窗（MDICLIENT）樣式介紹 1 /* Windows視窗樣式 */ 2 WS_BORDER //帶有邊框的視窗 3 WS_CAPTION //帶有標題欄的視窗 4 WS_CHILD

ABP 支援模組化開發

第一步，在MVC專案 Application_Start開啟支援模組化開發 需在Web專案下面新建PlugIns資料夾 AbpBootstrapper.PlugInSources.AddFolder(Server.MapPath("/PlugIns")); MvcApplication

C語言檔案操作 和 預編譯命令

//read檔案 int main(){ char *path = "D:\\friends.txt"; FILE *fp = fopen(path, "r"); char buff[500]; while (fgets(buff,50,fp)){ printf("%s\n", b

模組化開發的模組

nodejs學習過程中自行整理，方便後期回顧查詢 1.最小的單元 ：函式，變數，某個單一的動作 function single action 2.類（class） function 一組相關動作.或者屬性組合 3.模組（module） 多組相關的類的集合   AMD  CMD

C 語言 分數化小數

輸入正整數 a,b,c, 輸出 a/b 的小數形式, 精確到小數點後 c 位。a,b≤10 6 ,c≤100。輸入包含多組資料, 結束標記為 a=b=c=0。 樣例輸入: 1 6 4 0 0 0 樣例輸出: C

C語言的預處理、編譯、彙編、連結

一、預處理 預處理指令的執行主要包含下列事情： 1.標頭檔案的包含 2.註釋的刪除 3.巨集定義的替換 4.條件編譯的選擇 指令：gcc  -E test.c -o test.i     /* 呼叫的是前處理器c

Android模組化開發、元件化開發；

模組化開發：優點嘛，專案過大時便於管理； 1、在根目錄的gradle.properties檔案下新增 isBuildModule=false； 使用isBuildModule來控制這個是Library還是獨立的APP； 2、建立一個新的Module，在其build.gra

C語言 __DATE__ __TIME__ Keil IAR 編譯時間格式化

庫檔案 #include "stdlib.h"//字元轉數字int atoi (const char * str); void Get_Compile_Time(uint8_t *Year, uint8_t *Month, uin

藉助Gradle Plugin解決模組化開發中模組如何對外暴露介面

直奔主題，在模組化開發中，模組間的資料交流大多數同學會採用以介面作為通訊協議的方式。需要面對的問題有以下幾點： 介面由誰來維護？ 這個問題簡單，由提供服務的模組來維護。 介面怎麼暴露？ 打成jar包，釋出到maven。 介面在哪裡維護？ 現在可以參考的方案有三種：一. 所有相關模組的

前端模組化開發規範之AMD（可不是處理器哦！）

首先強調下，我們這裡提到的AMD可不是計算機的處理器哦！ 繼CommonJS之後，雙出現了一種非同步載入模組的方法。就是AMD，全稱為：Asynchronous module definition。 它的使用方法依然很簡單。 定義一個模組： define('user', ['

前端模組化開發規範之ES6

直接上程式碼啦！ 匯入 import { getList } from './userService' 或者 import userService from './userService' 匯出 export default { userService }