1. 程式人生 > >C/C++程式從編譯到最終生成可執行檔案的過程分析

C/C++程式從編譯到最終生成可執行檔案的過程分析

     *******************************************************篇一******************************************************************************************** 

     電子計算機所使用的是由“0”和“1”組成的二進位制數,二進位制是計算機的語言的基礎。計算機發明之初,人們只能降貴紆尊,用計算機的語言去命令計算機幹這幹那,一句話,就是寫出一串串由“0”和“1”組成的指令序列交由計算機執行,這種語言,就是機器語言。想象一下老前輩們在打孔機面前數著一個一個孔的情景,噓,小聲點,你的驚嚇可能使他們錯過了一個孔,結果可能是導致一艘飛船飛離軌道阿。

        為了減輕使用機器語言程式設計的痛苦,人們進行了一種有益的改進:用一些簡潔的英文字母、符號串來替代一個特定的指令的二進位制串,比如,用“A D D”代表加法,“M O V”代表資料傳遞等等,這樣一來,人們很容易讀懂並理解程式在幹什麼,糾錯及維護都變得方便了,這種程式設計語言就稱為組合語言,即第二代計算機語言。然而計算機是不認識這些符號的,這就需要一個專門的程式,專門負責將這些符號翻譯成二進位制數的機器語言,這種翻譯程式被稱為彙編程式。因為彙編指令和機器語言之間有著一一對應的關係,這可比英譯漢或漢譯英簡單多了。

      高階語言是偏向人,按照人的思維方式設計的,機器對這些可是莫名奇妙,不知所謂。魚與熊掌的故事在計算機語言中發生了。於是必須要有一個橋樑來銜接兩者,造橋可不是一件簡單的事情。當你越想方便,那橋就得越複雜。那高階語言是如何變成機器語言的呢,這個過程讓我慢慢道來。

       編譯:將原始碼轉換為機器可認識程式碼的過程。編譯程式讀取源程式(字元流),對之進行詞法和語法的分析,將高階語言指令轉換為功能等效的彙編程式碼,再由彙編程式轉換為機器語言,並且按照作業系統對可執行檔案格式的要求連結生成可執行程式。

C源程式->編譯預處理->編譯->優化程式->彙編程式->連結程式->可執行檔案 

1.編譯預處理  讀取c源程式,對其中的偽指令(以#開頭的指令)和特殊符號進行處理。 

偽指令主要包括以下四個方面

(1)巨集定義指令,如# define Name TokenString,#undef等。對於前一個偽指令,預編譯所要作得的是將程式中的所有Name用TokenString替換,但作為字串常量的Name則不被替換。對於後者,則將取消對某個巨集的定義,使以後該串的出現不再被替換。 

(2)條件編譯指令,如#ifdef,#ifndef,#else,#elif,#endif,等等。這些偽指令的引入使得程式設計師可以通過定義不同的巨集來決定編譯程式對哪些程式碼進行處理。預編譯程式將根據有關的檔案,將那些不必要的程式碼過濾掉。 

(3)標頭檔案包含指令,如#include "FileName"或者#include <FileName>等。在標頭檔案中一般用偽指令#define定義了大量的巨集(最常見的是字元常量),同時包含有各種外部符號的宣告。採用標頭檔案的目的主要是為了使某些定義可以供多個不同的C源程式使用。因為在需要用到這些定義的C源程式中,只需加上一條#include語句即可,而不必再在此檔案中將這些定義重複一遍。預編譯程式將把標頭檔案中的定義統統都加入到它所產生的輸出檔案中,以供編譯程式對之進行處理。 

包含到c源程式中的標頭檔案可以是系統提供的,這些標頭檔案一般被放在/usr/include目錄下。在程式中#include它們要使用尖括號(<>)。另外開發人員也可以定義自己的標頭檔案,這些檔案一般與c源程式放在同一目錄下,此時在#include中要用雙引號("")。

(4)特殊符號,預編譯程式可以識別一些特殊的符號。例如在源程式中出現的LINE標識將被解釋為當前行號(十進位制數),FILE則被解釋為當前被編譯的C源程式的名稱。預編譯程式對於在源程式中出現的這些串將用合適的值進行替換。

預編譯程式所完成的基本上是對源程式的“替代”工作。經過此種替代,生成一個沒有巨集定義、沒有條件編譯指令、沒有特殊符號的輸出檔案。這個檔案的含義同沒有經過預處理的原始檔是相同的,但內容有所不同。下一步,此輸出檔案將作為編譯程式的輸出而被翻譯成為機器指令。

2.編譯階段

經過預編譯得到的輸出檔案中,將只有常量。如數字、字串、變數的定義,以及C語言的關鍵字,如main,if,else,for,while,{,},+,-,*,\,等等。預編譯程式所要作得工作就是通過詞法分析和語法分析,在確認所有的指令都符合語法規則之後,將其翻譯成等價的中間程式碼表示或彙編程式碼。 

3.優化階段

優化處理是編譯系統中一項比較艱深的技術。它涉及到的問題不僅同編譯技術本身有關,而且同機器的硬體環境也有很大的關係。優化一部分是對中間程式碼的優化。這種優化不依賴於具體的計算機。另一種優化則主要針對目的碼的生成而進行的。上圖中,我們將優化階段放在編譯程式的後面,這是一種比較籠統的表示。

對於前一種優化,主要的工作是刪除公共表示式、迴圈優化(程式碼外提、強度削弱、變換迴圈控制條件、已知量的合併等)、複寫傳播,以及無用賦值的刪除,等等。

後一種型別的優化同機器的硬體結構密切相關,最主要的是考慮是如何充分利用機器的各個硬體暫存器存放的有關變數的值,以減少對於記憶體的訪問次數。另外,如何根據機器硬體執行指令的特點(如流水線、RISC、CISC、VLIW等)而對指令進行一些調整使目的碼比較短,執行的效率比較高,也是一個重要的研究課題。 

經過優化得到的彙編程式碼必須經過彙編程式的彙編轉換成相應的機器指令,方可能被機器執行。 

4.彙編過程

彙編過程實際上指把組合語言程式碼翻譯成目標機器指令的過程。對於被翻譯系統處理的每一個C語言源程式,都將最終經過這一處理而得到相應的目標檔案。目標檔案中所存放的也就是與源程式等效的目標的機器語言程式碼。

 目標檔案由段組成。通常一個目標檔案中至少有兩個段:

程式碼段  該段中所包含的主要是程式的指令。該段一般是可讀和可執行的,但一般卻不可寫。  

資料段  主要存放程式中要用到的各種全域性變數或靜態的資料。一般資料段都是可讀,可寫,可執行的。

UNIX環境下主要有三種類型的目標檔案: 

(1)可重定位檔案  其中包含有適合於其它目標檔案連結來建立一個可執行的或者共享的目標檔案的程式碼和資料。

 (2)共享的目標檔案  這種檔案存放了適合於在兩種上下文裡連結的程式碼和資料。第一種事連結程式可把它與其它可重定位檔案及共享的目標檔案一起處理來建立另一個目標檔案;第二種是動態連結程式將它與另一個可執行檔案及其它的共享目標檔案結合到一起,建立一個程序映象。

 (3)可執行檔案  它包含了一個可以被作業系統建立一個程序來執行之的檔案。

彙編程式生成的實際上是第一種型別的目標檔案。對於後兩種還需要其他的一些處理方能得到,這個就是連結程式的工作了。

5.連結程式

由彙編程式生成的目標檔案並不能立即就被執行,其中可能還有許多沒有解決的問題。例如,某個原始檔中的函式可能引用了另一個原始檔中定義的某個符號(如變數或者函式呼叫等);在程式中可能呼叫了某個庫檔案中的函式,等等。所有的這些問題,都需要經連結程式的處理方能得以解決。

連結程式的主要工作就是將有關的目標檔案彼此相連線,也即將在一個檔案中引用的符號同該符號在另外一個檔案中的定義連線起來,使得所有的這些目標檔案成為一個能夠被作業系統裝入執行的統一整體。

根據開發人員指定的同庫函式的連結方式的不同,連結處理可分為兩種: 

(1)靜態連結  在這種連結方式下,函式的程式碼將從其所在地靜態連結庫中被拷貝到最終的可執行程式中。這樣該程式在被執行時這些程式碼將被裝入到該程序的虛擬地址空間中。靜態連結庫實際上是一個目標檔案的集合,其中的每個檔案含有庫中的一個或者一組相關函式的程式碼。

 (2)動態連結  在此種方式下,函式的程式碼被放到稱作是動態連結庫或共享物件的某個目標檔案中。連結程式此時所作的只是在最終的可執行程式中記錄下共享物件的名字以及其它少量的登記資訊。在此可執行檔案被執行時,動態連結庫的全部內容將被對映到執行時相應程序的虛地址空間。動態連結程式將根據可執行程式中記錄的資訊找到相應的函式程式碼。 

     對於可執行檔案中的函式呼叫,可分別採用動態連結或靜態連結的方法。使用動態連結能夠使最終的可執行檔案比較短小,並且當共享物件被多個程序使用時能節約一些記憶體,因為在記憶體中只需要儲存一份此共享物件的程式碼。但並不是使用動態連結就一定比使用靜態連結要優越。在某些情況下動態連結可能帶來一些效能上損害。

  經過上述五個過程,C源程式就最終被轉換成可執行檔案了

上一節我們介紹了程式語言的種類,其中包括機器語言、組合語言和高階語言。

*************************************篇二*************************************************************************************************************************

C/C++程式編譯步驟詳解
來源: ChinaUnix部落格  日期: 2007.04.24 07:30 (共有0條評論) 我要評論


C/C++程式編譯步驟詳解
C/C++語言很多人都比較熟悉,這基本上是每位大學生必學的一門程式語言,通常還都是作為程式設計入門語言學的,並且課程大多安排在大一。剛上大學,孩子們還都很乖,學習也比較認真,用心。所以,C/C++語言掌握地也都不錯,不用說編譯程式,就是寫個上幾百行的程式都不在話下,但是他們真的知道C/C++程式編譯的步驟麼?
我想很多人都不甚清楚,如果他接下來學過“編譯原理”,也許能說個大概。VC的“舒適”開發環境遮蔽了很多編譯的細節,這無疑降低了初學者的入門門檻,但是也“剝奪”了他們“知其所以然”的權利,致使很多東西只能死記硬背,遇到相關問題就“丈二”。實際上,我也是在學習Linux環境下程式設計的過程中才逐漸弄清楚C/C++原始碼是如何一步步變成可執行檔案的。
總體來說,C/C++原始碼要經過:預處理、編譯、彙編和連線四步才能變成相應平臺下的可執行檔案。大多數時候,程式設計師通過一個命令就能完成上述四個步驟。比如下面這段C的“Hello world!”程式碼:
File: hw.c
#include stdio.h>
int main(int argc, char *argv[])
{
        printf("Hello World!\n");
        return 0;
}
如果用gcc編譯,只需要一個命令就可以生成可執行檔案hw:
[email protected] hw $ gcc -o hw hw.c
[email protected] hw $ ./hw Hello World! 
我們可以用-v引數來看看gcc到底在背後都做了些什麼動作:
Reading specs from /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/specs
Configured with: /var/tmp/portage/sys-devel/gcc-3.4.6-r2/work/gcc-3.4.6/configure --prefix=/usr --bindir=/usr/i686-pc-linux-gnu/gcc-bin/3.4.6 --includedir=/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/include --datadir=/usr/share/gcc-data/i686-pc-linux-gnu/3.4.6 --mandir=/usr/share/gcc-data/i686-pc-linux-gnu/3.4.6/man --infodir=/usr/share/gcc-data/i686-pc-linux-gnu/3.4.6/info --with-gxx-include-dir=/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/include/g++-v3 --host=i686-pc-linux-gnu --build=i686-pc-linux-gnu --disable-altivec --enable-nls --without-included-gettext --with-system-zlib --disable-checking --disable-werror --enable-secureplt --disable-libunwind-exceptions --disable-multilib --disable-libgcj --enable-languages=c,c++,f77 --enable-shared --enable-threads=posix --enable-__cxa_atexit --enable-clocale=gnu
Thread model: posix
gcc version 3.4.6 (Gentoo 3.4.6-r2, ssp-3.4.6-1.0, pie-8.7.10)
/usr/libexec/gcc/i686-pc-linux-gnu/3.4.6/cc1 -quiet -v hw.c -quiet -dumpbase hw.c -mtune=pentiumpro -auxbase hw -version -o /tmp/ccYB6UwR.s
ignoring nonexistent directory "/usr/local/include"
ignoring nonexistent directory "/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../../i686-pc-linux-gnu/include"
#include "..." search starts here:
#include ...> search starts here:
/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/include
/usr/include
End of search list.
GNU C version 3.4.6 (Gentoo 3.4.6-r2, ssp-3.4.6-1.0, pie-8.7.10) (i686-pc-linux-gnu)
        compiled by GNU C version 3.4.6 (Gentoo 3.4.6-r2, ssp-3.4.6-1.0, pie-8.7.9).
GGC heuristics: --param ggc-min-expand=81 --param ggc-min-heapsize=97004
/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../../i686-pc-linux-gnu/bin/as -V -Qy -o /tmp/ccq8uGED.o /tmp/ccYB6UwR.s
GNU assembler version 2.17 (i686-pc-linux-gnu) using BFD version 2.17
/usr/libexec/gcc/i686-pc-linux-gnu/3.4.6/collect2 --eh-frame-hdr -m elf_i386 -dynamic-linker /lib/ld-linux.so.2 -o hw /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../crt1.o /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../crti.o /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/crtbegin.o -L/usr/lib/gcc/i686-pc-linux-gnu/3.4.6 -L/usr/lib/gcc/i686-pc-linux-gnu/3.4.6 -L/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../../i686-pc-linux-gnu/lib -L/usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../.. /tmp/ccq8uGED.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/crtend.o /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../crtn.o
稍微整理一下,去掉一些冗餘資訊後,如下:
cc1 hw.c -o /tmp/ccYB6UwR.s
as -o /tmp/ccq8uGED.o /tmp/ccYB6UwR.s
ld -o hw /tmp/ccq8uGED.o
以上三個命令分別對應於編譯步驟中的預處理+編譯、彙編和連線。預處理和編譯還是放在了一個命令(cc1)中進行的,可以把它再次拆分為以下兩步:
cpp -o hw.i hw.c
cc1 hw.i -o /tmp/ccYB6UwR.s
一個精簡過的能編譯以上hw.c檔案的Makefile如下:
.PHONY: clean
all: hw
hw: hw.o
        ld -dynamic-linker /lib/ld-linux.so.2 -o hw /usr/lib/crt1.o \
                /usr/lib/crti.o \
                /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/crtbegin.o \
                hw.o -lc \
                /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/crtend.o \
                /usr/lib/crtn.o
hw.o: hw.s
        as -o hw.o hw.s
hw.s: hw.i
        /usr/libexec/gcc/i686-pc-linux-gnu/3.4.6/cc1 -o hw.s hw.c
hw.i: hw.c
        cpp -o hw.i hw.c
clean:
        rm -rf hw.i hw.s hw.o
當然,上面Makefile中的一些路徑是我係統上的具體情況,你的可能與我的不同。
接下來我們按照編譯順序看看編譯器每一步都做了什麼。
首先是預處理,預處理後的檔案hw.i:
# 1 "hw.c"
# 1 ""
# 1 ""
...
__extension__ typedef __quad_t __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
...
extern int remove (__const char *__filename) __attribute__ ((__nothrow__));
extern int rename (__const char *__old, __const char *__new) __attribute__ ((__nothrow__));
...
int main(int argc, char *argv[])
{
printf("Hello World!\n");
return 0;
}
注:由於檔案比較大,所以只留下了少部分具有代表性的內容。
可以看見前處理器把所有要包含(include)的檔案(包括遞迴包含的檔案)的內容都新增到了原始的C原始檔中,然後把其輸出到輸出檔案,除此之外,它還展開了所有的巨集定義,所以在前處理器的輸出檔案中你將找不到任何巨集。這也提供了一個檢視巨集展開結果的簡便方法。
第二步“編譯”,就是把C/C++程式碼“翻譯”成彙編程式碼:
.file "hw.c"
        .section .rodata
.LC0:
        .string "Hello World!\n"
        .text
.globl main
        .type main, @function
main:
        pushl %ebp
        movl %esp, %ebp
        subl $8, %esp
        andl $-16, %esp
        movl $0, %eax
        addl $15, %eax
        addl $15, %eax
        shrl $4, %eax
        sall $4, %eax
        subl %eax, %esp
        subl $12, %esp
        pushl $.LC0
        call printf
        addl $16, %esp
        movl $0, %eax
        leave
        ret
        .size main, .-main
        .section .note.GNU-stack,"",@progbits
        .ident "GCC: (GNU) 3.4.6 (Gentoo 3.4.6-r2, ssp-3.4.6-1.0, pie-8.7.10)"
這個彙編檔案比預處理後的C/C++檔案小了很多,去除了很多不必要的東西,比如說沒用到的型別宣告和函式宣告等。
第三步“彙編”,將第二步輸出的彙編程式碼翻譯成符合一定格式的機器程式碼,在Linux上一般表現為ELF目標檔案。
[email protected] hw $ file hw.o
hw.o: ELF 32-bit LSB relocatable, Intel 80386, version 1 (SYSV), not stripped
最後一步“連線”,將上步生成的目標檔案和系統庫的目標檔案和庫檔案連線起來,最終生成了可以在特定平臺執行的可執行檔案。為什麼還要連線系統庫中的某些目標檔案(crt1.o, crti.o等)呢?這些目標檔案都是用來初始化或者回收C執行時環境的,比如說堆記憶體分配上下文環境的初始化等,實際上crt也正是C RunTime的縮寫。這也暗示了另外一點:程式並不是從main函式開始執行的,而是從crt中的某個入口開始的,在Linux上此入口是_start。以上Makefile生成的是動態連線的可執行檔案,如果要生成靜態連線的可執行檔案需要將Makefile中的相應段修改:
hw: hw.o
    ld -m elf_i386 -static -o hw /usr/lib/crt1.o \
        /usr/lib/crti.o \
        /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/crtbeginT.o \
        -L/usr/lib/gcc/i686-pc-linux-gnu/3.4.6 \
        -L/usr/i686-pc-linux-gnu/lib \
        -L/usr/lib/ \
        hw.o --start-group -lgcc -lgcc_eh -lc --end-group \
        /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/crtend.o \
        /usr/lib/gcc/i686-pc-linux-gnu/3.4.6/../../../crtn.o
至此,一個可執行檔案才最終建立完成。通常的專案中並不需要把編譯過程分得如此之細,前三步一般是合為一體的,在Makefile中表現如下:
hw.o: hw.c
    gcc -o hw.o -c hw.c
實際上,如果對hw.c進行了什麼更改,那麼前三步大多數情況下都是不可避免的。所以把他們寫在一起也並沒有什麼壞處,相反倒可以用--pipe引數告訴編譯器用管道替代臨時檔案,從而提升編譯的效率。

相關推薦

C/C++程式編譯最終生成執行檔案過程分析

     *******************************************************篇一*******************************************************************************************

Linux C 源程式 編譯連線生成 執行檔案

源程式 test.c第一種 ,編譯 gcc -c test.c -o test.o              連線 gcc -o test test.o第二種。              編譯連線              gcc -o test test.c執行    ./

.Net Core 2.0 程式編譯出exe執行檔案方法

.Net Core 2.0 程式 用vs生成後無exe啟動項,如果需要生成exe執行檔案可以: 1.修改專案的csproj檔案內容 原始: <PropertyGroup> <OutputType>Exe</OutputType> <

C語言中沒有main函式生成執行程式的幾種方法

轉自:http://www.linuxidc.com/Linux/2013-09/90061.htm 1、define預處理指令 這種方式很簡單,只是簡單地將main字串用巨集來代替,或者使用##拼接字串。示例程式如下: #include <stdio.h>

'假定以下程式編譯和連線後生成執行檔案PROG.EXE,如果在此執行檔案所在目錄的DOS提示符下鍵入:PROG ABCDEFGH IJKL<回車>,則輸出結果為( ). void main( int argc, char *argv[]) { while(--argc>

main(int argc,char *argv[])函式的兩個形參,第一個int argc,是記錄你輸入在命令列(你題目中說的操作就是命令列輸入)上的字串個數;第二個*argv[]是個指標陣列,存放輸入在命令列上的命令(字串)。當命令列輸入PROG ABCDEFGH IJKL時,記錄了3

C++原始碼生成執行檔案的四個步驟

以GCC編譯器為例: 第一步,預處理,包括語法檢查等工作。 $ gcc -P abc.c 會生成abc.i檔案。 第二步,編譯,由源程式生成組合語言程式碼。 $ gcc -S abc.c 會生成abc.s檔案,這個檔案就是彙編程式碼。 第三步,彙編,編譯器生成目的碼,一個源

C++原始碼如何生成執行檔案

先看一段最簡單的程式碼: #include <stdio.h> int main (int argc,char* arg[]) { printf("hello world"); return 0; } 如何把上面的程式碼轉換成可執行的程式碼呢,通常我們可以用g

maven工程編譯生成執行JAR包命令

在JAVA持續整合構建中,需要從SVN check out的程式碼編譯並打成可執行JAR包,高手告訴我maven命令如何? 我用mvn compile package或mvn jar:jar都能打成jar包,但不能執行 利用HUDSON+MAVEN編譯打包java mav

四、Android.mk之編譯生成執行檔案

一、簡介 對於學過Linux核心的來說,想要去編譯一個檔案,生成可執行檔案也好,打包成庫也罷,都是使用Makefile來管理編譯的。那麼對於Android底層開發來講,也是需要把咱們寫的程式碼,編譯成可執行檔案或者其他可用的檔案,才能使用起來。再Android對這些檔案的管

Python指令碼建立執行檔案

Python是我最喜歡的程式語言之一。話雖這麼說,如果你曾經不得不部署一個用Python編寫的應用程式,那麼你就知道它有多痛苦。 幸運的是,有一些非常棒的開源工具可用於將Python程式打包成獨立的二進位制可執行檔案,其中包含執行應用程式所需的一切(即Python直譯器

將Python程式(.py)轉換為Windows執行檔案(.exe)

將Python程式(.py)轉換為Windows可執行檔案(.exe) python開發者向普通windows使用者分享程式,要給程式加圖形化的介面(EasyGUI 學習文件)(在前面的課程中目前只學習了最簡單的EasyGui,後面還會繼續學習 GUI的終極選擇:Tkinter,敬請期待),

怎樣用Eclipse將Java原始碼生成執行檔案

eclipse將java原始碼生成jar可執行檔案 用eclipse做了一個web專案的自動化測試,自己用的時候倒是很方便,開啟eclipse直接執行即可,但是分享給其他小夥伴用的時候就不太方便,希望

makefile簡單編寫-生成執行檔案

makefile 要想把寫好的程式放到linux下編譯,必不可少的要使用到makefile檔案。makefile帶來的好處就是——“自動化編譯”,一旦寫好,只需要一個make命令,整個工程完全自動編譯,極大的提高了軟體開發的效率。下面講下makefile簡單的

Linux中原始檔生成執行檔案過程

原始檔通過編譯、連結形成可執行檔案 編譯 編譯可以分為三部分:預編譯,編譯,彙編 預編譯:main.c gcc     -E      main.c 編譯:main.i gcc     -S     main.i 彙編:main.s gcc     -c 

(接上篇)反編譯兩種執行檔案

上篇地址:http://blog.csdn.net/eliot_shao/article/details/78648314 上篇主要內容回顧: 上篇內容介紹了靜態編譯生成靜態庫,然後連結靜態庫生成可執行檔案的過程;也對比介紹了動態編譯生成動態庫然後連結動態庫生成可執行檔案的

QT--生成執行檔案

QT 生成的可執行檔案exe在其他電腦還不能使用需要附帶DLL方法:windows下用cmd進入qt專案對應的release檔案中 然後執行windeployqt test.exe那麼對應的資料夾中會生成對應的dll檔案,一起打包就可以用了

Matlab 生成執行檔案

相信很多用Matlbab開發的同學們都對Matlab強大的工具包所吸引,但是並不是所以環境都支援對M檔案執行,在沒有安裝Matlab的電腦上我們該如何M檔案進行運算呢。首選當然是把M檔案匯出成一個可在WINDOWS上執行的EXE檔案了。下面開始說說如何匯出:      

python如何呼叫編譯後的執行檔案

本人計算機萌新一枚,從今天開始寫點平時遇到的問題,可能只是一個解決辦法或者一些小小的感悟。或許研究得沒那麼深入,但也希望能夠分享一些自己的經驗。可能格式或者某些說法有些錯誤,望指正,謝謝。 前情提要 在工作的時候,對方發了一個寫好並且編譯好的包,lin

android JNI執行NDK編譯成的執行檔案

1.android環境的可執行檔案的生成 所謂的android下的可執行檔案,其實就是一般的c/c++程式碼使用NDK編譯出來的應用程式。它和linux下用gcc編譯出來的程式和windows系統下的.exe檔案是一樣的。要將程式碼編譯成可執行檔案只需要將編譯so的inc

Golang 在windows下編譯Linux下執行檔案

Golang 支援交叉編譯,在一個平臺上生成另一個平臺的可執行程式,最近使用了一下,非常好用,這裡備忘一下。 Windows 下編譯Linux 64位可執行程式 SET CGO_ENABLED=0 SET GOOS=linux SET GOARCH=amd64 go