編譯指令重復執行嗎

❶ 簡述將源程序編譯成可執行程序的過程

一個源程序到一個可執行程序的過程：預編譯、編譯、匯編、鏈接。其中，編譯是主要部分，其中又分為六個部分：詞法分析、語法分析、語義分析、中間代碼生成、目標代碼生成和優化。

預編譯：主要處理源代碼文件中的以「#」開頭的預編譯指令。處理規則如下：

1、刪除所有的#define，展開所有的宏定義。

2、處理所有的條件預編譯指令，如「#if」、「#endif」、「#ifdef」、「#elif」和「#else」。

3、處理「#include」預編譯指令，將文件內容替換到它的位置，這個過程是遞歸進行的，文件中包含其他文件。

4、刪除所有的注釋，「//」和「/**/」。

5、保留所有的#pragma 編譯器指令，編譯器需要用到他們，如：#pragma once 是為了防止有文件被重復引用。

6、添加行號和文件標識，便於編譯時編譯器產生調試用的行號信息，和編譯時產生編譯錯誤或警告是能夠顯示行號。

(1)編譯指令重復執行嗎擴展閱讀：

編譯過程中語法分析器只是完成了對表達式語法層面的分析，語義分析器則對表達式是否有意義進行判斷，其分析的語義是靜態語義——在編譯期能分期的語義，相對應的動態語義是在運行期才能確定的語義。

其中，靜態語義通常包括：聲明和類型的匹配，類型的轉換，那麼語義分析就會對這些方面進行檢查，例如將一個int型賦值給int*型時，語義分析程序會發現這個類型不匹配，編譯器就會報錯。

❷ 如何讓一個命令反復執行若干次

1.for
循環語句

for
語句格式為
:

for(
表達式
1;
表達式
2;
表達式
3)

語句
:/*
循環體
*/

該語句執行過程如下
:

①先對表達式
1
賦初值
;

②判別表達式
2
是否滿足給定條件
,
若其值為真
,
滿足循環條件
,
則執行
循環體內語句
,
然後執行表達式
3,
進入第二次循環
,
再判別表達式
2……;否
則判斷表達式
2
的值為假
,
不滿足條件
,
就終止
for
循環
,
執行循環體外語
句。
for
語句語法流程如下圖所示
:

@@01L14300.GIF;
圖
1.@@

例題
:f7_1.c

# include

main ()

{

int n,nu;

nu=0;

for (n=1;n<=200;n++)

點擊此處添加圖片說明

nu+=n;

printf ("nu=%d\n",nu);

}

編譯並執行後
,
屏幕顯示
:

nu=20100

在程序中
,for
語句小括弧內的三個表達式分別為
:n=1;n<=200;n++
。
表
達式
1,n=1
是給
n
賦初值
,
表達式
2
是關系表達式
,n
小於等於
200
時
,
表達
式都為真
,
則執行循環體內的語句
nu+=n;(
即
nu=nu+n;),
然後執行表達式
3(n++),
進入下一輪循環
;
若
n
大於
200
時
,
表達式
2
為假
,
則終止循環
,
執行
printf()
語句
,
在屏幕上列印出
:nu=20100
。

幾種特殊
for
語句的用法
:

(1)for
小括弧內三個表達式為空

例
for(;;)

printf ("test");

在小括弧內只有兩個分號
,
無表達式。表示無限循環。這種無限循環適
用於菜單選擇程序中。
具體的：http://wenku..com/link?url=dTWyK99jmWEZq9r-Cvgh9jpcAhiH_isbqOuDit5RFE_

❸ 編譯執行和解釋執行的區別

一、主體不同

1、編譯執行：由編譯程序將目標代碼一次性編譯成目標程序，再由機器運行目標程序。

2、解釋執行：將源語言直接作為源程序輸入，解釋執行解釋一句後就提交計算機執行一句，並不形成目標程序。

二、優勢不同

1、編譯執行：相比解釋執行編譯執行效率高，佔用資源小，適合復雜程序

2、解釋執行：開發速度快，出現嚴重BUG的幾率小。

三、缺點不同

1、編譯執行：兼容性差，例如在windows平台上寫的編譯程序一般不可以在unix平台上運行。

2、解釋執行：解析需要時間，不生成目標程序而是一句一句的執行的方式會造成計算機資源的浪費，即執行效率低。

❹ 程序重復運行代碼

當一個或者多個指令（程序）重復多次(次數可知)時，可使用FOR指令。
FOR為有限次循環指令。
程序循環結構用於描述一段程序的重復循環執行。由FOR和NEXT指令構成程序的循環體。FOR指令標記循環的開始，NEXT指令為循環體的結束指令。
FOR指令為指令盒格式，主要參數有使能輸入EN、當前值計數器INDX、循環次數初始值INIT和循環計數終值FINAL。

❺ 64位gcc編譯浮點加法為什麼每次mov指令都執行兩次

這個，你需要先查一下x86_64傳遞參數的規則。浮點數是用 xmm0, xmm1,xmm2,xmm3來傳遞參數的。

你還需要了解一下SIMD指令集。

http://en.wikipedia.org/wiki/X86_calling_conventions

我不知道為什麼你反匯編出來是這樣。我自己測試了一下，反匯編結果比你的簡單多了。

你的編譯器，可能規則和我的稍有不同。比我的復雜一些。

大概翻譯如下：

0x00000000004014f0<+0>:push%rbp
0x00000000004014f1<+1>:sub$0x4,%rsp
0x00000000004014f5<+5>:lea0x80(%rsp),%rbp
0x00000000004014fd<+13>:movss%xmm0,-0x6c(%rbp)====>參數s保存在xmm0中，把它壓到棧上位置為-0x6c(%rbp)
0x0000000000401502<+18>:movss-0x6c(%rbp),%xmm0====>xmm0可以保存4個float,這樣，僅僅把-0x6c(%rbp)位置的一個floats傳遞到xmm0寄存器，准備做float的運算
0x0000000000401507<+23>:addss%xmm0,%xmm0====>2個float相加，相加結果保存在xmm0中
0x000000000040150b<+27>:movss%xmm0,-0x80(%rbp)==>把相加的結果，保存在棧上位置為-0x80(%rbp)，但是這里是4個float,其中高位三個都是0.0,最低位一個是s+s的結果
0x0000000000401510<+32>:mov-0x80(%rbp),%eax==>eax是保存結果的規定寄存器，保存一份結果，這下只會保存最低位的float,也就是我們需要的結果
0x0000000000401513<+35>:mov%eax,-0x80(%rbp)==>傳回去，有點繞，本質上是編譯器的不同，一些編譯器有一些特定的規則,主要的目的是為了下面傳遞給xmm0，只能從棧上穿，movss指令只能這樣用。
0x0000000000401516<+38>:movss-0x80(%rbp),%xmm0==>返回結果需要保存在xmm0中，所以又傳給它了。為什麼要穿來傳去呢，因為xmm0可以保存4個float,可以同時進行4個float運算，上面的步驟是為了保證，只有最後一個float運算的結果被保存，前面三個float，結果都是0.0,但是不管是什麼，結果都被忽略了。
0x000000000040151b<+43>:add$0x4,%rsp==>清除棧，返回
0x000000000040151f<+47>:pop%rbp
0x0000000000401520<+48>:retq

❻ C語言既可以編譯執行又可以解釋執行嗎 編譯執行怎麼解釋 解釋執行又怎麼解釋

C 語言程序僅可以解釋執行。

解釋程序是將源程序(如BASIC)作為輸入，解釋一句後就提交計算機執行一句，並不形成目標程序。編譯程序是把高級語言(如FORTRAN、COBOL、Pascal、C等)源程序作為輸入，進行翻譯轉換，產生出機器語言的目標程序，然後再讓計算機執行這個目標程序，得到計算結果。

相對於編譯性語言，其優點是可移植性好，只要有解釋器環境，程序就可以在不同的操作系統上運行。

缺點是代碼需要有專門的解釋器，在程序運行時，除要給用戶程序本身分配內存空間外，解釋器也佔用系統資源，所以其運行速度較慢。另外，也很難達到像C、C++那樣操作系統底層操作的目的。

解釋型語言常用於，一是對運行速度要求不高（如一些網頁腳本等）的場合，二是對跨平台（操作系統的兼容性）有要求的場合。

(6)編譯指令重復執行嗎擴展閱讀

1、Python和Java語言，專門有一個解釋器能夠直接執行Python程序，每個語句都是執行的時候才翻譯。

2、Python代碼在運行前，會先編譯成中間代碼，每個 .py 文件將被換轉成pyc 文件，pyc 就是一種位元組碼文件，它是與平台無關的中間代碼。不管放在 Windows 還是 Linux 平台都可以執行，運行時將由虛擬機逐行把位元組碼翻譯成目標代碼。

❼ c++頭文件中的開頭代碼是啥意思

if
!defined
xxx
#define
xxxx
這是預編譯指令，是說，如果代碼中沒有定義xxx，則定義xxx，目的是，在引用文件時，防止重復定義
比如：在aaa.h中定義了AAA變數，
而在main.cpp
中#include
「AAA.h」,main.cpp也同時要使用fun.cpp.
並且在fun.cpp
中也#include「AAA.h」
那麼如果沒有預編譯指令的話
兩個文件都定義了AAA這個變數.那麼就造成了AAA的多次定義。
/*****************************/
/***文件一***main.cpp***********/
#include
"AAA.h"
int
main()
.....
/**文件二*****AAA.h************/
const
int
AAA
=
123;
/**文件三*****fun.cpp**************/
#include
"AAA.h"
.....
這樣，main文件包含了AAA變數的定義，由於main文件中會調用的fun.cpp，而fun.cpp文件包含了AAA.h也就是定義了AAA，
所以就會造成main文件定義了兩次AAA變數。
如果使用了預編譯指令，
則可以在定義了一次之後
不知道我說清楚了沒有，清楚了就請加分吧
不再定義第二次
由於

❽ 單片機執行完main主程序之後，會一遍接一遍的反復再執行嗎

不會。要在主程序結束前加一條返回指令。
C的可以main前面加一條while(1),匯編的可以在主程序結束後面加一條LJMP MAIN

❾ 頭文件重復編譯

只要簡單的理解為用頭文件裡面的內容替換#include的地方，就可以了。
之所以會重復編譯，是因為你的頭文件有可能相互直接include或者間接include，
直接點比如你add.c中直接使用兩次#include "stdio.h",又stdio.h中有定義函數scanf();
編譯時，編譯器會找到兩個scanf()函數體，編譯失敗。
而加上#ifndef _dedd
#define _dedd
#include"stdio.h"
#endif
（在任何引用stdio.h頭文件的時候都這樣寫），那麼，在第一次編譯器把stdio.h包含過來後，
後面#include "stdio.h"的地方都會檢測到 _dedd已經 define了，所以不會再包含該頭文件。

❿ Python同一個程序只需一次編譯,即可重復執行

咨詢記錄 · 回答於2021-12-01