對宏命令的處理是

1. C語言的編譯系統對宏命令的處理是

前言：宏實質就是編譯器在對代碼進行編譯之前進行的一個「查找替換」工作，就跟你在處理文檔時用wps/word/記事本等進行「查找替換」操作一樣。
c語言的編譯系統對宏命令的處理是（）
a。在程序運行時進行的
b。在對源程序中其他成分正式編譯之前進行的
c。在程序連續時進行的
d。和c程序中的其他語句同時進行編譯
答：選b。在對源程序中其他成分正式編譯之前進行的
2,
#define
n
2
/*
在預編譯時將用下面代碼中n替換成2
*/
#define
m
n+1
/*
在預編譯時將m替換成n+1（即2+1，n會再被替換成2）*/
#define
num
2*m+1
/*
如上：在預編譯時num替換成2*m+1，即2*n+1+1，即2*2+1+1*/
main()
{int
i;
for(i=1;i<=num;i++)printf("%d\n",i);
/*
*
如上所述，上句展開為：for(i=1;i<=2*2+1+1;i++)printf("%d\n",i);
*
所以：循環將執行6次
*/
}
/*
切記注意：每一個宏百進行替換時只是替換「正文」中的內容，而不包括預編譯語句的內容，
否則就會像不少人理解的那樣，錯誤地認為第2個題中的循環將執行7次
*/

2. 魔獸世界宏命令設置

代碼如下：

第一種：這個是自動選擇敵方目標的，自動選擇你正前方距離較近的目標，如果已經有了一個敵方目標就不會自動選擇了

#showtooltip

/targetenemy [target=target,help][target=target,noexists][target=target,dead]

/cast 技能

第二種：這個是不換目標的，比如你正在看著坦克，而他正在打怪，你就會打他的目標，但是你的目標還是T

#showtooltip

/cast [@target,harm][@targettarget,harm][@targettargettarget,harm

[@targettargettargettarget,harm]技能

wow宏設置步驟如下:

1.進入游戲後,Esc」→「宏命令設置」打開宏的操作界面。

(2)對宏命令的處理是擴展閱讀

不管你想鎖定什麼目標，/target 目標名字/focus/cast 技能名稱點這個宏就會自動切換到目標了，並且設為焦點並且釋放魔法另外，如果不知道對方的名字，那麼如下/targetenemy /focus/cast 技能名稱它會立刻找到你身邊最近的敵人，鎖定目標，釋放魔法。

焦點目標（focus）是一個類似target、player的單位代號。它允許你關聯一個玩家或者定義的NPC。最簡單的焦點目標（focus）用法就是：Focus target和Target focus。

Focus target可以將你當前的目標設為焦點目標（focus），或者是在你的沒有目標的時候取消設定的焦點目標（focus）。Target focus會選中你設定的焦點目標（focus）。

第一行表示，當你的焦點目標（focus）不存在時，或者當焦點目標（focus）死亡時，或者當焦點目標（focus）是友善單位時，將當前目標設定為焦點目標（focus）。

第二行表示，當你的焦點目標（focus）不存在時，停止宏。如果第一行沒有設定焦點目標（focus），則這一行就會將這個宏停止。第三行，對焦點目標（focus）釋放恐懼術。

計算機科學里的宏（Macro)，是一種批量批處理的稱謂。一般說來，宏是一種規則或模式，或稱語法替換 ，用於說明某一特定輸入（通常是字元串）如何根據預定義的規則轉換成對應的輸出（通常也是字元串)。這種替換在預編譯時進行，稱作宏展開。

所謂宏，就是一些命令組織在一起，作為一個單獨命令完成一個特定任務。Microsoft Word中對宏定義為：「宏就是能組織到一起作為一獨立的命令使用的一系列word命令，它能使日常工作變得更容易」。Word使用宏語言Visual Basic將宏作為一系列指令來編寫。

計算機科學里的宏是一種抽象的,根據一系列預定義的規則替換一定的文本模式。Excel 辦公軟體自動集成了「VBA」高級程序語言，用此語言編制出的程序就叫「宏」。

使用「VBA」需要有一定的編程基礎，並且還會耗費大量的時間，因此，絕大多數的使用者僅使用了Excel的一般製表功能，很少使用到「VBA」。

參考資料 :知識站-wow自動選擇目標宏

3. 10. C語言的編譯系統對宏命令的處理是（ ）。

前言：宏實質就是編譯器在對代碼進行編譯之前進行的一個「查找替換」工作，就跟你在處理文檔時用WPS/談搭WORD/記事本等進行「查找替換」操作一樣。

C語言的編譯系統對宏命令的處理是（）
A。在程序運行時進行的
B。在對源程序中其他成分正式編譯之前進行的
C。在程序連續時進行的
D。和C程序中的其他語句同時進行編譯

答：選B。在對源程序中其他成分正式編譯之前進行的

2,
#define N 2 /* 在預編譯時將用下面代碼中N替換成2 */
#define M N+1 /* 在預編譯時將M替換成N+1（即2+1，N會再被替換成嘩羨2）*/
#define NUM 2*M+1 /* 如上：在預編譯時NUM替換成2*M+1，即2*N+1+1，即2*2+1+1*/
main()
{int i;
for(i=1;i<=NUM;i++)printf("%d\亂侍拍n",i);
/*
* 如上所述，上句展開為：for(i=1;i<=2*2+1+1;i++)printf("%d\n",i);
* 所以：循環將執行6次
*/
}

/* 切記注意：每一個宏百進行替換時只是替換「正文」中的內容，而不包括預編譯語句的內容， 否則就會像不少人理解的那樣，錯誤地認為第2個題中的循環將執行7次 */

4. WOW宏命令下線宏命令丟失如何處理

這是一個很悲哀的問題。
我們唯一能做的是，下線的時候按正常布罩退 不要強退。還有不要修改宏 重新做一個也可以 還有最好把宏設置在單人物身上（公用的很容易不見）
注意好以上幾點，一般情況下 你不動他 他是不會不見的
如果真的2天不見3個的話 建議你把宏弄好 備份 不見的時候 復制 粘貼
目前沒有解決辦法
（除非你 把人物文檔拷貝下來。到哪裡上網都復制一遍）

5. EXCEL裡面的「宏」怎麼用

1、通常首先添加「宏」選項。具體路徑是單擊左上角的Microsoft圖標，然後選擇：「Excel選項」 - 「常用」，選中「功能區顯示開發工具」選項卡，然後您可以看到「開發」有一個選項「工具」在Excel選項卡中。

6. 電氣三班c語言選擇題

下面說法不正確的是（）。
調用函數時，實參可以是表達式
調用函數時，實參和形參可以共用內存單元
調用函數時，將實參的值復制給形參，使實參變數和形參變數在數值上相等
調用函數時，實參與形參的類型必須一致
~B
~~~6
下面函數調用語句含有實參的個數為（）。
func((exp1,exp2),(exp3,exp4,exp5));
1
2
3
5
~B
~~~6
在C語言中，函數調用時（）。
實參和形參各占獨立的存儲單元
實參和形參共用存儲單元
由系統自動確定實參和形參是否共用存儲單元
由用戶指定實參和形參是否共用存儲單元
~A
~~~6
C語言規定，程序中各函數之間（）。
既允許直接遞歸調用也允許間接遞歸調用
既不允許直接遞歸調用也不允許間接遞歸調用
允許直接遞歸調用不允許間接遞歸調用
不允許直接遞歸調用允許間接遞歸調用
~A
~~~8
下列能正確定義一維數組的選項是（）。
int a[5]={0,1,2,3,4,5};
char a[]={0,1,2,3,4,5};
char a={'A','B','C'};
int a[5]="0123";
~B
~~~8
下列敘述中錯誤的是（）。
對於double類型數組，不可以直接用數組名對數組進行整體輸入或輸出
數組名代表的是數組所佔存儲區的首地址，其值不可改變
在程序執行中，數組元素的下標超出所定義的下標范圍時，系統將給出「下標越界」的出錯信息
可以通過賦初值的方式確定數組元素的個數
~C
~~~8
有下列程序：
#include <string.h>
main()
{ char p[]={'a','b','c'},q[10]={'a','b','c'};
printf("%d%d\n",strlen(p),strlen(q));
}
下列敘述中正確的是（）。
在給p和q數組賦初值時，系統會自動添加字元串結束符，故輸出的長度都為3
由於p數組中沒有字元串結束符，長度不能確定，但q數組中字元串長度為3
由於q數組中沒有字元串結束符，長度不能確定，但p數組中字元串長度為3
由於p和q數組中都沒有字元串結束符，故長度都不能確定
~A
~~~8
若要求從鍵盤讀入含有空格字元的字元串，應使用函數（）。
getc()
gets()
getchar()
scanf()
~B
~~~8
當用戶要求輸入的字元串中含有空格時，應使用的輸入函數是（）。
scanf()
getchar()
gets()
getc()
~C
~~~8
當有定義語句：char s[10];,若要從終端給s輸入5個字元，錯誤的輸入語句是（）。
gets(&s[0]);
scanf("%s",s+1);
gets(s);
scanf("%s",s[1]);
~D
~~~8
當以下敘述中錯誤的是（）。
gets函數用於從終端讀入字元串
getchar函數用於從磁碟文件讀入字元
fputs函數用於把字元串輸出到文件
fwrite函數用於以二進制形式輸出數據到文件
~B
下列關於字元串的敘述中正確的是（）。
C語言中有字元串類型的常量和變數
兩個字元串中的字元個數相同時才能進行字元串大小的比較
可以用關系運算符對字元串的大小進行比較
空串一定比空格打頭的字元串小
~D
~~~8
下面能正確進行字元串賦值的是（）。
char s[5]={"ABCDE"};
char s[5]={'A','B','C','D','E'};
char*s; s="ABCDE";
char*s;printf("%s",s);
~C
~~~8
字元串"\\\"ABCDEF\"\\"的長度是（）。
15
10
7
8
~B
~~~8
下面各語句行中，能正確進行賦值字元串操作的是（）。
char s[5]={'a','b','c','d','e'};
char *s;gets(s);
char *s;*s="ABCDEF";
char s[5];scanf("%s",&s);
~B
~~~8
設已執行預編譯命令#include<string.h>,以下程序段的輸出結果是（）。
char s[]="abcdefg";
printf("%d\n",strlen(s));
7
8
9
10
~A
~~~8
若已包括頭文件<string.h>且已有定義char s1[18],s2={"ABCDE"}和int i，現要將字元串"ABCDE"賦給s1,下述語句錯誤的是（）。
strcpy(s1,s2);
strcpy(s1,"ABCDE");
s1="ABCDE";
for(i=0;i<6;i++)
s1[i]=s2[i];
~C

###
~~~7
*以下程序的輸出結果是[<4>]。
*#include<stdio.h>
*main()
*{
* int a[5]={2,4,6,8,10},*p;
* p=a;p++;
* printf("%d",*p);
*}
~~~7
*以下程序的輸出結果是[<3 5>]。
*#include<stdio.h>
*void swap(int *a,int *b)
*{
* int *t ;
* t=a;a=b;b=t;
*}
*main()
*{
* int i=3,j=5,*p=&i,*q=&j;
* swap(p,q);printf("%d %d",*p,*q);
*}
~~~7
*下面程序段的運行結果是[<68>]。
*char str[]="ABCD",*p=str;
*printf("%d\n",*(p+3));

###
~~~7
設已有定義：float x;，則下列對指針變數p進行定義且賦初值的語句中正確的是( )。
float *p=1024;
int *p=(float)x;
float p=&x;
float *p=&x;
~D
~~~7
設有定義語句int (*f)(int);，則以下敘述正確的是( )。
f是基類型為int的指針變數
f是指向函數的指針變數，該函數具有一個int類型的形態
f是指向int類型一維數組的指針變數
f是函數名，該函數的返回值是其類型為int類型的地址
~B
~~~7
設有定義：int n1=0,n2,*p=&n2,*q=&n1;，以下賦值語句中與n2=n1;語句等價的是( )。
*p=*q
p=q
*p=&n1;
p=*q
~A
~~~7
在16位編譯系統上，若有定義int a[]={10,20,30},*p=&a;，當執行p++;後，下列說法錯誤的是( )。
p向高地址移了一個位元組
p向高地址移了一個存儲單元
p向高地址移了兩個位元組
p與n+1等價
~A
~~~7
若有定義語句：int k[2][3],*pk[3];，則下列語句中正確的是( )。
pk=k;
pk[0]=&k[1][2];
pk=k[0];
pk[1]=k;
~B
~~~7
若有定義：char(*p)[6];則標識符p( )。
是一個指向字元型變數的指針
是一個指針數組名
是一個指針變數，它指向一個含有6個字元型元素的一維數組
定義不合法
~C
~~~7
下面程序段的運行結果是( )。
#include<stdio.h>
void main()
{ char str[]="abc",*p=str;
printf("%d\n",*(p+3));
}
67
0
字元'C'的地址
字元'C'
~B
~~~7
若有以下定義，則對a數組元素的正確引用是( )。
int a[5],*p=a;
*&a[5]
*a+1
*(p+5)
*(a+2)
~D

###
~~~3
C語言中用[<非0>]表示邏輯"真"，用[<0>]表示邏輯值"假"。
~~~3
C語言中邏輯運算符[<!>]的優先順序高於算術運算符。
~~~3
當a=1，b=2，c=3時，以下if語句執行後，a、b、c中的值分別為[<3>]、[<2>]、[<2>]。
if(a>c)
b=a;a=c;c=b;
~~~3
以下程序段的輸出結果是[<死循環>]
int k,n,m;
n=10;m=1;k=1;
while(k<=n) m*=2;
printf("%d\n",m);
~~~3
以下程序的輸出結果是[<-1>]
main()
{
int x=2;
while(x--);
printf("%d\n",x);
}
~~~3
以下程序段：
s=1.0;
for(k=1;k<=n;k++)
s=s+1.0/(k*(k+1))
printf("%f\n",s);
請填空，使下面的程序段的功能完全與之等同。
s=0.0
[<d=1.0>]
k=0;
do
{
s=s+d;
[<k++>]
d=1.0/(k*(k+1));
}
while[<k<=n>]
printf("%f\n",s);
~~~3
以下程序功能是：從鍵盤上輸入若干個學生的成績，統計並輸出最高成績和最低成績，當輸入負數時結束輸入。請填空。
main()
{
float x,amax,amin;
scanf("%f",&x);
amax=x;
amin=x;
while[<x>=0>]
{
if(x>amax) amax=x;
if[<x<amin>] amin=x;
scanf("%f",&x);
}
printf("\namax=%f\namin=%f\n",amax,amin);
}
~~~5
若有定義int a[3][5];則排列在數組中的第九個元素是[<a[1][3]>]
~~~5
strlen("How are you\n")的值是[<12>]
~~~5
C語言中字元串結束的標志是[<'\0'>]
~~~5
寫出一個名為s的單精度實型一維數組，長度是6，所有元素初值均為0，其數組定義語句是[<float s[6]={0};>]
~~~5
strcmp("how","How")的值是[<32或者>0>]
~~~6
C語言程序執行的開始處是[<main函數>]
~~~6
C程序中的一個函數由兩部分組成，即[<聲明部分>]和[<執行部分>]
~~~6
為了保證被調用函數不返回任何值，其函數定義的類型應為[<void>]
~~~6
下面pi函數的功能是，根據以下公式返回滿足精度ε要求的∏的值。請填空。∏/2=1+1/3+(1/3)*(2/5)+(1/3)*(2/5)*（3/7)+(1/3)*(2/5)*（3/7)*(4/9)+...
double pi(double eps)
{double s=0.0,t=1.0;
int n;
for([<n=1>];t>eps;n++)
{
s+=t;
t=n*t/(2*n+1);
}
return (2.0*[<s>]);
}
~~~6
以下函數用以求x的y次方。請填空。
double fun(double x,int y)
{
int i;double z;
for(i=1;i[<<=y>];i++)
z=[<Z*x>];
return z;
}
~~~6
以下程序的功能是計算s=0!+1!+2!+3!+...+n!。請填空。
long f(int n)
{ int i; long s;
s=[<1L>];
for(i=1;i<=n;i++) s=[<S*i>];
return s;
}
main()
{
long s;int k,n;
scanf("%d",&n);
s=[<0>];
for(k=0;k<=n;k++) s=s+[<f(k)>];
printf("%ld\n",s);
}

###
~~~3
下列運算符中優先順序最高的運算符是()。
!
%
-=
&&
~A
~~~3
下列運算符中優先順序最低的運算符是()。
||
!=
<=
+
~A
~~~3
為表示關系x≥y≥z,應使用的C語言表達式是()。
(x>=y)&&(y>=z)
(x>=y)AND(y>=z)
(x>=y>=z)
(x>=y)&(y>=z)
~A
~~~3
設a、b和c都是int型變數，且a=3，b=4，c=5；則以下的表達式中，值為0的表達式是()。
a&&b
a<=b
a||b+c&&b-c
!(a<b)&&!c||1
~D
~~~5
若有int s[4]={1,2,3,4};則s[s[0]+2*s[2]-s[3]]的值是()。
1
2
3
4
~D
~~~5
對數組的描述正確的是()。
數組一旦定義去大小是固定的，但數組元素的類型可以不同
數組一旦定義去大小是固定的，但數組元素的類型必須相同
數組一旦定義去大小是可變的，但數組元素的類型可以不同
數組一旦定義去大小是可變的，但數組元素的類型必須相同
~B
~~~5
對字元串"Boy"進行完整賦值的操作是()
char s[3]={'B','o','y'}
char s[]="Boy"
char s[3]={"Boy"}
char s[3];s="Boy"
~B
~~~5
在c語言中引用數組元素時，其數組下標的數組類型允許是()
整型常量
整型表達式
整型常量或整型表達式
任何類型的表達式
~C
~~~5
對以下說明語句的正確理解是()
*int a[10]={6,7,8,9,10}
將5個初值依次賦給a[1]至a[5]
將5個初值依次賦給a[0]至a[4]
將5個初值依次賦給a[6]至a[10]
因為數組長度與初值的個數不相同，所以此語句不正確
~B
~~~5
以下程序段給數組所有元素輸入數據，應在下劃線處填入的是()
*main()
*{
*int a[10],i=0;
*while(i<10) scanf("%d",_______);
*:
*:
*}
a+(i++)
&a(i+1)
a+i
&a[++i]
~D
~~~5
以下程序的輸出結果是()
*main()
*{
* int a[]={2,4,6,8},y=1,x,*p;
*p=&a[1];
*for(x=0;x<3;x++) y+=*(p+x);
*printf("%d\n",y);
*}
17
18
19
20
~C
~~~6
下述函數定義形式正確的是()
int f(int x;int y)
int f(int x, y)
int f(int x,int y)
int f(x,y:y)
~C
~~~6
關於函數參數，說法正確的是()
實參與其對應的形參各自佔用獨立的內存單元
實參與其對應的形參共同佔用一個內存單元
只有當實參和形參同名時才佔用同一個內存單元
形參是虛擬的，不佔用內存單元
~A
~~~6
用數組名作為函數的實參時，傳遞給形參的是()
數組的首地址
數組的第一個元素
數組中的全部元素
數組的元素個數
~A
~~~6
復合語句中定義的變數的作用范圍是()
整個源文件
整個函數
整個程序
所定義的復合語句
~D
~~~6
一個函數的返回值由()確定
return語句中的表達式
調用函數的類型
系統默認的類型
被調用函數的類型
~D
~~~6
以下說法正確的是()
C語言程序總是從第一個定義的函數開始執行
在C語言程序設計中，要調用的函數必須在main函數中定義
C語言程序總是從main函數開始執行
C語言程序中的main函數必須放在程序的開始部分
~C
~~~6
以下函數的類型是()
*fff(float x)
*{
*printf("",x*x);
*}
與參數x的類型相同
void類型
int類型
無法確定
~C
~~~6
以下程序的輸出結果是()
*fun(int a,int b)
*{int c;
*c=a+b;
*retutn c;
*}
*main()
*{int x=6,y=7,z=8,r;
*r=func((x--,y++,x+y),z--);
*printf("%d\n",r);
*}
11
20
21
31
~C
~~~10
當說明一個結構體變數時，系統分配給它的內存是()
各成員所需內存總量的總和
結構中第一個成員所需內存量
成員中占內存量最大者所需的容量
結構中最後一個成員所需內存量
~A
~~~10
設有以下說明語句：
*struct stu
*{int a;
* float b;
*}stutype;
*則下面敘述不正確的是()
strut是結構體類型的關鍵字
strut stu是用戶定義的結構體類型
stutype是用戶定義的結構體類型名
a和b都是結構體成員名
~C
~~~10
C語言結構體類型變數在執行期間()
所有成員一直駐留在內存中
只有一個成員駐留在內存中
部分成員駐留在內存中
沒有成員駐留在內存中
~A
~~~11
若想對文本文件只進行讀操作，打開此文件的方式為()
"r"
"W"
"a"
"r+"
~A
~~~11
如果要打開C盤file文件夾下的abc.dat文件，fopen函數中第一個參數應為()
c:file\abc.dat
c:\file\abc.dat
"c:\file\abc.dat"
"c:\\file\\abc.dat"
~D
~~~11
用fopen函數打開文件，操作完畢後用()函數關閉它
fopen
open
fclose
close
~C
~~~11
以下可作為函數fopen中第一個參數的正確格式是()
c:user\test.txt
c:\user\test.txt
"c:\user\test.txt"
"c:\\user\\test.txt"
~D
~~~11
若執行fopen函數時發生錯誤，則函數的返回值是()
地址值
0
1
EOF
~B
~~~11
若要用fopen函數打開一個新的二進制文件，該文件要既能讀也能寫，則文件方式字元串應是()
"ab++"
"wb+"
"rb+"
"ab"
~B
若以"a+"方式打開一個已存在的文件，則以下敘述正確的是()
文件打開時，原有文件內容不被刪除，位置指針移到文件末尾，可作添加和讀操作
文件打開時，原有文件內容不被刪除，位置指針移到文件開頭，可作重寫和讀操作
文件打開時，原有文件內容不被刪除，只可作寫操作
以上各種說法皆不正確
~A

###
~~~9
下列程序的功能時：給r輸入數據後計算半徑為r的圓面積s。程序在編譯時出錯。
main()
{ int r; float s;
scanf("%d",&r);
s=pi*r*r;
printf("s=%f\n",s);
}
出錯的原因是（）。
注釋語句書寫位置錯誤
存放圓半徑的變數r不應該定義為整型
輸出語句中格式描述符號非法
計算圓面積的賦值語句中使用了非法變數
~D
~~~9
以下敘述錯誤的是（）。
在程序中凡是以「#」開始的語句行都是預處理命令行
預處理命令行的最後不能以分號表示結束
#define MAX是合法的宏定義命令行
C程序對預處理命令行的處理是在程序執行的過程中進行的
~C
~~~9
下列敘述中正確的是（）。
預處理命令行必須位於源文件的開頭
在源文件的一行上可以有多條預處理命令
宏名必須用大寫字母表示
宏替換不佔用程序的運行空間
~D
~~~9
若程序中有宏定義行：#define N 100，則下列敘述中正確的是（）。
宏定義中定義了標識符N的值為整數100
在編譯程序對C源程序進行預處理時用100替換標識符N
對C源程序進行編譯時用100替換標識符N
在運行時用100替換標識符N
~B
~~~9
程序
#include <stdio.h>
#define M 5
#define N M+M
main()
{ int k;
k=N*N*5;
printf("%d\n",k);
}
的輸出結果是（）。
100
50
55
45
~C
~~~9
下列敘述中正確的是（）。
預處理命令行必須位於C源程序的起始位置
在C語言中，預處理命令行都以#開頭
每個C程序必須在開頭包含預處理命令行：#include<stdio.h>
C語言的預處理不能實現宏定義和條件編譯的功能
~B
~~~9
C語言的編譯系統對宏命令的處理是（）。
在系統對源程序進行編譯前
和其他語句的編譯同時進行
在程序連接時進行
在程序運行時進行
~A
~~~9
以下敘述中不正確的是（）。
預處理命令行都必須以「#」號開始，結尾不加分號
在程序中凡是以「#」開始的語句行都是預處理命令行
C程序在執行過程中對預處理命令進行處理
預處理命令可以放在程序的任何位置
~C
~~~9
下面敘述中正確的是（）。
C語言中預處理是指完成宏替換和文件包含指定的文件的調用
預處理命令只能位於C源程序文件的首部
預處理命令可以放在程序中的任何位置
預處理命令結尾需要加分號
~C
~~~9
以下有關宏替換的敘述不正確的是（）。
使用宏定義可以嵌套
宏定義僅僅是符號替換
雙引號中出現的宏名不替換
宏名必須用大寫字母表示
~D