A. c語言中不用空格怎麼把格子空出來
自己數一下格子，調整一下對位。
printf("a,b:%3d%3d\n",a,b);
printf("x,y:%.6f,%.6f\n",x,y);
printf("x,y:%-15.6f,%-15.6f\n",x,y);
printf("x,y:%8.2f,%.4f\n",x,y);
printf("x,y:%.6e,%.2e\n",x,y);
printf("n,n,n:%7d,%7o,%7x\n",n,n,n); //輸出 n 的十進制、 八進制和十六進制的值
printf("u,u,u:%u,%o,%x\n",u,u,u); //輸出 u 的十進制、八進制和十六進制的值
printf("STR1,STR2:%s,%5.3s\n", STR1,STR2);
B. C語言#define的用法(2)
例如：如果x是一個宏參量，那麼#x可以把參數名轉化為相應的字元串。該過程稱為字元串化。
#include
#define PSQR(x) printf ("The square of " #x" is %d\n", ((x)*(x)))
int main (void)
{
int y = 2;
PSQR (y);
PSQR (2 + 4);
return 0;
}
輸出結果：
The square of y is 4
The square of 2 + 4 is 36
#include
#include
#define VEG(n) #n
int main()
{
char str[20];
strcpy(str,VEG(num));//num
printf("%s\n",str);//拷貝
return 0;
}
輸出結果：
num
預處理器的粘合劑：##運算符
和#運算符一樣，##運算符可以用於類函數宏的替換部分。另外，##還可用於類對象宏的替換部分。這個運算符把兩個語言符號組合成單個語言符號。
#include
#define XNAME(n) x##n
#define PRINT_XN(n) printf ("x"#n" = %d\n", x##n)
int main (void)
{
int XNAME (1) = 14; //變為 int x1 = 14;
int XNAME (2) = 20; //變為 int x2 = 20;
PRINT_XN (1); //變為 printf ("x1 = %d\n", x1);
PRINT_XN (2); //變為 printf ("x2 = %d\n", x2);
return 0;
}
輸出結果：
x1 = 14
x2 = 20
宏用於簡單函數：
#include
#define MAX(x,y) ((x)>(y) ? (x) : (y)) /*比較大小*/
#define ABS(x) ((x) < 0 ? -(x) : (x)) /*絕對值*/
#define ISSIGN(x) ((x) == '+' || (x) == '-' ? 1 : 0) /*正負號*/
int main()
{
printf ("較大的為： %d\n", MAX(5,3));
printf ("絕對值為： %d\n", ABS (-2));
printf ("正負號為： %d\n", ISSIGN ('+'));
return 0;
}
輸出結果：
較大的為： 5
絕對值為： 2
正負號為： 1
下面是需要注意的幾點：
1、宏的名字中不能有空格，但是在替代字元串中可以使用空格。ANSI C 允許在參數列表中使用空格。
2、用圓括弧括住每個參數，並括住宏的整體定義。
3、用大寫字母表示宏函數名，便於與變數區分。
4、有些編譯器限制宏只能定義一行。即使你的編譯器沒有這個限制，也應遵守這個限制。
5、宏的一個優點是它不檢查其中的變數類型，這是因為宏處理字元型字元串，而不是實際值。
面試：用預處理指令#define 聲明一個常數，用以表明1年中有多少秒(忽略閏年問題)
#define SEC (60*60*24*365)UL
考察內容：
1、懂得預處理器將為你計算常量表達式的值，因此，可直接寫出你是如何計算一年中有多少秒而不是計算出實際的值，這樣更清晰而沒有代價。
2、意識到這個表達式將使一個16 位機的整形數溢出，因此要用到長整形符號 L ，告訴編譯器這個常數是長整形數。
3、如果你在你的表達式中用到UL(表示無符號長整型)，那麼你有了一個好的`起點。
面試：寫一個“標准”宏MIN ，這個宏輸入兩個參數並返回較小的一個
#define MIN(A,B) ((A) <= (B) ? (A) : (B))
考察內容：
1、三目表達式的使用
2、使用必須的足夠多的圓括弧來保證以正確的順序進行運行和結合
3、進一步討論，在宏中不要使用增量或減量運算符
參看：宏名必須用大寫字母嗎?
研究：C語言中用宏定義(define)表示數據類型和用typedef定義數據類型有什麼區別?
宏定義只是簡單的字元串代換，是在預處理完成的，而typedef是在編譯時處理的，它不是作簡單的代換，而是對類型說明符重新命名。被命名的標識符具有類型定義說明的功能。
請看下面的例子：
#define P1 int *
typedef (int *) P2
從形式上看這兩者相似，但在實際使用中卻不相同。
下面用P1、P2說明變數時就可以看出它們的區別：
P1 a, b; 在宏代換後變成： int *a, b; 表示 a 是指向整型的指針變數，而 b 是整型變數。
P2 a, b; 表示a,b都是指向整型的指針變數。因為PIN2是一個類型說明符。
由這個例子可見，宏定義雖然也可表示數據類型， 但畢竟是作字元代換。在使用時要分外小心，以避出錯。
總結，typedef和#define的不同之處：
1、與#define不同，typedef 給出的符號名稱僅限於對類型，而不是對值。
2、typedef 的解釋由編譯器，而不是是處理器執行。
3、雖然它的范圍有限，但在其受限范圍內，typedef 比 #define 更靈活。
用於定義字元串，尤其是路徑
A),#define ENG_PATH_1 E:\English\listen_to_this\listen_to_this_3
B),#define ENG_PATH_2 “ E:\English\listen_to_this\listen_to_this_3”
A 為 定義路徑， B 為定義字元串
C), #define ENG_PATH_3 E:\English\listen_to_this\listen\
_to_this_3
還沒發現問題?這里用了 4 個反斜杠，到底哪個是接續符?回去看看接續符反斜杠。反斜杠作為接續符時，
在本行其後面不能再有任何字元，空格都不行。所以，只有最後一那給 ENG_PATH_1 加上雙引號不就成了：“ENG_PATH_1”。但是請注意：有的系統里規定路徑的要用雙反斜杠“ \\” ,比如：
#define ENG_PATH_4 E:\\English\\listen_to_this\\listen_to_this_3
C. c語言 define 怎麼用的
有三種用法，例如替代多行的代碼、條件編譯，還有典型的宏定義，具體如下：
1、define最重要的用法是條件編譯
#ifdef WINDOWS
......
......
#endif
#ifdef LINUX
......
......
#endif
可以在編譯的時候通過#define設置編譯環境
2、典型的使用方法
使用宏定義我們可以自己根據自己的習慣來定義甚至改變C語言的語法習慣，例如：
#define BEGIN {
#define END }
int main()BEGIN
printf ("DEFINE---- ");
定義一個循環
#define LOOP for(;;)
重新定義數據類型
#define IT int
3、define可以替代多行的代碼，在每一個換行的時候加上一個""
#define MAX(X,Y) do {
語句1;
語句2;
/* 注釋的寫法 */
} while(0) /* (no trailing ; ) */
(3)c語言define中無空格擴展閱讀：
關於上述中用 #define 定義標識符的一般形式為：
1、#define 標識符常量 //注意, 最後沒有分號
2、#define 和 #include 一樣，也是以「#」開頭的，凡是以「#」開頭的均為預處理指令，#define也不例外。
3、#define又稱宏定義，標識符為所定義的宏名，簡稱宏，標識符的命名規則與前面講的變數的命名規則是一樣的。
4、#define 的功能是將標識符定義為其後的常量，一經定義，程序中就可以直接用標識符來表示這個常量。
D. C語言宏定義的對象可以有空格嗎
可以有空格。
多個語句都是可以的。
#define ABC electric amp
會替代ABC為electric amp
E. C語言，#define語句的用法。
1.簡單的宏定義
格式：#define 標識符 替換列表
說明：替換列表可以是數，字元串字面量，標點符號，運算符，標識符，關鍵字，字元常量。
注意：替換列表是可以為空的
典型錯誤：
#defineN=100
inta[N];/*這樣會成為inta[=100],這里會處理成為一種標識記號一樣*/
#defineN100;
inta[N];/*帶分號的定義會成為inta[100;],這是一種很常見的錯誤*/
#definepin(int*);
pina,b;
int*a,b;/*本意是a和b都是int型指針，但是實際上變成int*a,b;a是int型指針，而b是int型變數。這是應該使用typedef來代替define，這樣a和b就都是int型指針了。*/
典型的使用方法：
使用宏定義可以自己根據自己的習慣來定義甚至改變C語言的語法習慣，例如：
#defineBEGIN{
#defineEND}
intmain()BEGIN
printf("DEFINE----
");
END定義一個循環
#defineLOOPfor(;;)
重新定義數據類型
#defineITint
2.帶參數的宏
#define 標識符（x1,x2,x3...xn） 替換列表 （注意：x1,x2,x3..是宏的參數，標識符和其左括弧之間不能有空格）
使用方法：
#defineMAX(x,y)((x)>(y)?(x):(y))
i=MAX(j+k,m-n);
替換為：
i=MAX((j+k)>(m-n)?(j+k):(m-n));
#defineSI_EX(n)((n)%2==0)
if(SI_EX(i))i++;
替換為：
if(SI_EX((i)%2==0))
通過以上例子可以看出，標識符帶參數（X1，X2，X3.....）在替換時會被替換列表（Y1，Y2，Y3....）對應的替換，但是和順序無關。
3.宏的特殊單行定義
#defineA(x)T_##x
#defineB（x)#@x
#defineC（x)#x
x=1
替換為：
A(1)------> T_1 （T_##x,##符號是記號粘黏符號，將前後的字元粘黏起來。）
B(1)------> '1' （ #@x , #@ 符號會將宏的參數進行字元串字面量化，並且加『』號）
C(1)------> "1" （ #x ,#符號會將宏的參數進行字元串字面量化，並且加""號）
4.define的多行定義
define可以替代多行的代碼，在每一個換行的時候加上一個""
#defineMAX(X,Y)do{
語句1;
語句2;
/*注釋的寫法*/
}while(0)/*(notrailing;)*/5.在大規模的開發過程中，特別是跨平台和系統的軟體里，define最重要的功能是條件編譯。
#ifdefWINDOWS
......
......
#endif
#ifdefLINUX
......
......
#endif
可以在編譯的時候通過#define設置編譯環境
6.取消宏
#undef標識符
7.條件編譯
#ifdefXXX…(#else)…#endif
8.預定義宏
在C語言中收錄了一些有用的宏，這些宏是提供當前編譯信息的。
__LINE__ 被編譯文件的行數
（整型）
__FILE__ 被編譯文件的名字 （字元型）
__DATE__ 編譯日期 （字元型）
__TIME__ 編譯時間 （字元型）
__STDC__ 如果編譯器接受標准C，那麼值為1. （整型）
通常在編譯的時候可以用這些預定義的宏來進行排錯，例如：
一般情況下，當出現除零的情況時編譯器是沒有提示的，可以自定義一個解決辦法。
#defineCHECKZERO(divisor)
if(divisor==0)
printf("***ATTEMPTTODIVIDEBYZEROINLINE%doffile%s*** ",__LINE__,__FILE__);
引用方法
CHECKZERO(j);
k=i/j;
F. #define有空格有效嗎
有效。
#define空格僅僅在定義的時候有效，在使用這個宏函數的時候，空格會被編譯器忽略掉。
空格是計算機上的鍵，表示一個空的字元。
G. c語言define用法舉例
C語言中#define用法總結：
1、簡單的宏定義
#define標識符替換列表（替換列表可以是數，字元串字面量，標點符號，運算符，標識符，關鍵字，字元常量。注意：替換列表是可以為空的）。
典型錯誤：
#define N =100
int a[N]；/*這樣會成為int a[=100]，這里會處理成為一種標識記號一樣*/
#define N 100;
int a[N]; /*帶分號的定義會成為int a[100；]，這是一種很常見的錯誤*/
#define pin(int*);
pin a，b；
int* a,b；/*本意是a和b都是int型指針，但是實際上變成int* a,b；a是int型指針，而b是int型變數。這是應該使用typedef來代替define，這樣a和b就都是int型指針了。*/
2、帶參數的宏
#define標識符（x1，x2，x3...xn） 替換列表 （注意：x1，x2，x3..是宏的參數，標識符和其左括弧之間不能有空格）
使用方法：
#define MAX(x，y) ((x)>(y)?(x)：(y))
i=MAX(j+k，m-n)；
3、宏的特殊單行定義
#define A(x) T_##x
#define B（x) #@x
#define C（x) #x
x=1
替換為：
A(1)------> T_1 （T_##x,##符號是記號粘黏符號，將前後的字元粘黏起來。）
B(1)------> '1' （ #@x , #@ 符號會將宏的參數進行字元串字面量化，並且加『』號）
C(1)------> "1" （ #x ,#符號會將宏的參數進行字元串字面量化，並且加""號）
4、define的多行定義
define可以替代多行的代碼，在每一個換行的時候加上一個""
#define MAX(X,Y) do {
語句1;
語句2;
/* 注釋的寫法 */
} while(0) /* (no trailing ; ) */
H. #define 是什麼意思 中間都沒空格
#define表示表示定義一個東西
比如#define
MAX_SIZE
100
//有空格
然後程序中就可以一直用MAX_SIZE代表整數100了
再比如#define
_DEBUG
//沒空格
表示定義了_DEBUG，只是表示定義了這個東西，以後可以通過
#ifdef
_DEBUG來判斷是否定義_DEBUG
I. c語言中空格一定要打上嗎
C語言語句對空白字元不敏感，所以大部分空格不是必須的。
1 由符號組成的操作符，與標識符之間的空格可以省略。
2 由字母組成的操作符，與標識符之間的空格不可以省略，如
#define PRINT
這里的define 和PRINT之間的空格就是不能省略的。
3 由符號組成的操作符之間的空格不能省略。如
i = a+ ++j;
是不可以寫成
i = a+++j;的。
4 除以上幾種情況外，用於字元串中的空格，由於要在字元串中起到分隔的作用，不可以省略。如"this is for test"這樣的字元串，是為了閱讀方便而加入的，這時省略掉不會對程序有太大影響，但是會影響程序的執行結果。
除不可省略的空格，是為了讓編譯系統正確編譯，其餘的空格或空白字元均是為了讓程序有更好的可讀性。即讓程序變得好看。所以在書寫代碼時，加入一定量的空白字元是很有必要的，最好不要省略。
J. c語言中define的用法
C語言是計算機軟體領域非常經典的編程語言,unix、linux等眾多操作系統均是由C語言編寫而成。而在硬體控制、底層驅動等應用領域,C語言更是具有不可替代的作用。下面我就跟你們詳細介紹下c語言中define的用法，希望對你們有用。
c語言中define的用法如下：
#define是C語言中提供的宏定義命令，其主要目的是為程序員在編程時提供一定的方便，並能在一定程度上提高程序的運行效率，但學生在學習時往往不能 理解該命令的本質，總是在此處產生一些困惑，在編程時誤用該命令，使得程序的運行與預期的目的不一致，或者在讀別人寫的程序時，把運行結果理解錯誤，這對 C語言的學習很不利。
1. #define命令剖析
1.1 #define的概念
#define命令是C語言中的一個宏定義命令，它用來將一個標識符定義為一個字元串，該標識符被稱為宏名，被定義的字元串稱為替換文本。
該命令有兩種格式：一種是簡單的宏定義，另一種是帶參數的宏定義。
(1) 簡單的宏定義：
#define <宏名><字元串>
例： #define PI 3.1415926
(2) 帶參數的宏定義
#define <宏名> (<參數表>) <宏體>
例： #define A(x) x
一個標識符被宏定義後，該標識符便是一個宏名。這時，在程序中出現的是宏名，在該程序被編譯前，先將宏名用被定義的字元串替換，這稱為宏替換，替換後才進行編譯，宏替換是簡單的替換。
1.2 宏替換發生的時機
為了能夠真正理解#define的作用，讓我們來了解一下對C語言源程序的處理過程。當我們在一個集成的開發環境如Turbo C中將編寫好的源程序進行編譯時，實際經過了預處理、編譯、匯編和連接幾個過程，見圖1。
源程序預處理器修改後的源程序編譯器匯編程序匯編器可重定位的目標程序連接器可執行的目標程序圖1C語言的編譯過程
其中預處理器產生編譯器的輸出，它實現以下的功能：
（1） 文件包含
可以把源程序中的#include 擴展為文件正文，即把包含的.h文件找到並展開到#include 所在處。
（2） 條件編譯
預處理器根據#if和#ifdef等編譯命令及其後的條件，將源程序中的某部分包含進來或排除在外，通常把排除在外的語句轉換成空行。
（3） 宏展開
預處理器將源程序文件中出現的對宏的引用展開成相應的宏 定義，即本文所說的#define的功能，由預處理器來完成。
經過預處理器處理的源程序與之前的源程序有所有不同，在這個階段所進行的工作只是純粹的替換與展開，沒有任何計算功能，所以在學習#define命令時只要能真正理解這一點，這樣才不會對此命令引起誤解並誤用。
2#define使用中的常見問題解析
2.1 簡單宏定義使用中出現的問題
在簡單宏定義的使用中，當替換文本所表示的字元串為一個表達式時，容易引起誤解和誤用。如下例：
例1 #define N 2+2
void main()
{
int a=N*N;
printf(“%d”,a);
}
(1) 出現問題：在此程序中存在著宏定義命令，宏N代表的字元串是2+2，在程序中有對宏N的使用，一般同學在讀該程序時，容易產生的問題是先求解N為2＋2＝4，然後在程序中計算a時使用乘法，即N*N=4*4=16,其實該題的結果為8，為什麼結果有這么大的偏差?
(2)問題解析：如1節所述，宏展開是在預處理階段完成的，這個階段把替換文本只是看作一個字元串，並不會有任何的計算發生，在展開時是在宏N出現的地方 只是簡單地使用串2＋2來代替N，並不會增添任何的符號，所以對該程序展開後的結果是a=2+2*2+2，計算後=8，這就是宏替換的實質，如何寫程序才 能完成結果為16的運算呢？
(3)解決辦法：將宏定義寫成如下形式
#define N (2+2)
這樣就可替換成(2+2)*(2+2)=16
2.2 帶參數的宏定義出現的問題
在帶參數的宏定義的使用中，極易引起誤解。例如我們需要做個宏替換能求任何數的平方，這就需要使用參數，以便在程序中用實際參數來替換宏定義中的參數。一般學生容易寫成如下形式：
#define area(x) x*x
這在使用中是很容易出現問題的，看如下的程序
void main()
{
int y=area(2+2);
printf(“%d”,y);
}
按理說給的參數是2+2，所得的結果應該為4*4=16，但是錯了，因為該程序的實際結果為8，仍然是沒能遵循純粹的簡單替換的規則，又是先計算再替換 了，在這道程序里，2+2即為area宏中的參數，應該由它來替換宏定義中的x，即替換成2+2*2+2=8了。那如果遵循(1)中的解決辦法，把2+2 括起來，即把宏體中的x括起來，是否可以呢？#define area(x) (x)*(x)，對於area(2+2)，替換為(2+2)*(2+2)=16，可以解決，但是對於area(2+2)/area(2+2)又會怎麼樣 呢，有的學生一看到這道題馬上給出結果，因為分子分母一樣，又錯了，還是忘了遵循先替換再計算的規則了，這道題替換後會變為 (2+2)*(2+2)/(2+2)*(2+2)即4*4/4*4按照乘除運算規則，結果為16/4*4=4*4=16，那應該怎麼呢？解決方法是在整個 宏體上再加一個括弧，即#define area(x) ((x)*(x))，不要覺得這沒必要，沒有它，是不行的。
要想能夠真正使用好宏定義，那麼在讀別人的程序時，一定要記住先將程序中對宏的使用全部替換成它所代表的字元串，不要自作主張地添加任何其他符號，完全展 開後再進行相應的計算，就不會寫錯運行結果。如果是自己編程使用宏替換，則在使用簡單宏定義時，當字元串中不只一個符號時，加上括弧表現出優先順序，如果是 帶參數的宏定義，則要給宏體中的每個參數加上括弧，並在整個宏體上再加一個括弧。看到這里，不禁要問，用宏定義這么麻煩，這么容易出錯，可不可以摒棄它， 那讓我們來看一下在C語言中用宏定義的好處吧。
3 宏定義的優點
(1) 方便程序的修改
使用簡單宏定義可用宏代替一個在程序中經常使用的常量，這樣在將該常量改變時，不用對整個程序進行修改，只修改宏定義的字元串即可，而且當常量比較長時， 我們可以用較短的有意義的標識符來寫程序，這樣更方便一些。我們所說的常量改變不是在程序運行期間改變，而是在編程期間的修改，舉一個大家比較熟悉的例 子，圓周率π是在數學上常用的一個值，有時我們會用3.14來表示，有時也會用3.1415926等，這要看計算所需要的精度，如果我們編制的一個程序中 要多次使用它，那麼需要確定一個數值，在本次運行中不改變，但也許後來發現程序所表現的精度有變化，需要改變它的值， 這就需要修改程序中所有的相關數值，這會給我們帶來一定的不便，但如果使用宏定義，使用一個標識符來代替，則在修改時只修改宏定義即可，還可以減少輸入 3.1415926這樣長的數值多次的情況，我們可以如此定義 #define pi 3.1415926，既減少了輸入又便於修改，何樂而不為呢？
(2) 提高程序的運行效率
使用帶參數的宏定義可完成函數調用的功能，又能減少系統開 銷，提高運行效率。正如C語言中所講，函數的使用可以使程序更加模塊化，便於組織，而且可重復利用，但在發生函數調用時，需要保留調用函數的現場，以便子 函數執行結束後能返回繼續執行，同樣在子函數執行完後要恢復調用函數的現場，這都需要一定的時間，如果子函數執行的操作比較多，這種轉換時間開銷可以忽 略，但如果子函數完成的功能比較少，甚至於只完成一點操作，如一個乘法語句的操作，則這部分轉換開銷就相對較大了，但使用帶參數的宏定義就不會出現這個問 題，因為它是在預處理階段即進行了宏展開，在執行時不需要轉換，即在當地執行。宏定義可完成簡單的操作，但復雜的操作還是要由函數調用來完成，而且宏定義 所佔用的目標代碼空間相對較大。所以在使用時要依據具體情況來決定是否使用宏定義。
形式參數不能用帶引號的字元串替換。
但是，如果在替換文本中，參數名以#作為前綴則結果將被擴展為 由 實際參數 替換 此實際參數的帶引號的字元串。
例如，可以將它與字元串連接運算結合起來編寫一個調試列印宏：
#define dprint（expr） printf（#expr “ = %\n”，expr）
使用語句 dprint（x/y）;
調用宏時，該宏將被擴展為：printf（“x/y”“ = %\n”，x/y）;
其中的字元串被連接起來了，這樣便等價於printf（“x/y = %\n”，x/y）;
在實際參數中，每個雙引號 “ 將被替換為 \” ；反斜杠\將被替換為\\,因此替換後的字元串是合法的字元串常量。
預處理運算符 ## 為宏擴展提供了一種連接實際參數的手段。如果替換文本中的參數與 ## 相鄰，則該參數將被實際參數替換，##與前後的空白符將被刪除，並對替換後的結果重新掃描。
例如，下面定義的宏paste用於連接兩個參數
#define paste(front, back) front ## back
因此，宏調用past（name,1）的結果將建立記號name1.
c語言中沒有swap這個函數，C語言不支持重載，也沒有模版的概念，所以對於每一種類型，都要寫出相應的swap，如
intSwap (int *, int *);
longSwap (long *, long *);
stringSwap (char *, char *);
宏定義swap（t，x，y）以交換t類型的兩個參數（要使用程序塊結構）。
程序如下：
#include <iostream.h>
#define SWAP(t,x,y) \
{\
t temp = *y;\
*y = *x;\
*x = temp;\
}
main()
{
int a = 10, b = 5;
SWAP(int,&a,&b)
cout << a << endl << b<<endl;
}
用\換行，\的意思是說把下一行看作和這行是同一行.換行必須要反斜杠,而且\後面直接回車,不能有空格。