参? http://otl.sourceforge.net/otl3_stream_class.htm
50 2.06
<1:536704> 18:31:58.068 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:536704> 18:34:04.713 [00001] There are 3612066 records is loaded!
100 1.38
<1:2085112> 18:36:23.727 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:2085112> 18:38:01.923 [00001] There are 3612066 records is loaded!
1.23
<1:2085112> 18:38:06.941 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:2085112> 18:39:29.849 [00001] There are 3612066 records is loaded!
200 1.02
<1:1499250> 18:41:47.711 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1499250> 18:42:49.300 [00001] There are 3612066 records is loaded!
<1:1499250> 18:42:54.312 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1499250> 18:43:53.717 [00001] There are 3612066 records is loaded!
500 0.43
<1:1978536> 18:45:57.790 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1978536> 18:46:40.685 [00001] There are 3612066 records is loaded!
<1:1978536> 18:45:09.982 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1978536> 18:45:52.787 [00001] There are 3612066 records is loaded!
1000 0.35
<1:1597632> 18:47:42.973 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1597632> 18:48:17.715 [00001] There are 3612066 records is loaded!
<1:1597632> 18:48:22.718 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1597632> 18:49:01.119 [00001] There are 3612066 records is loaded!
<1:1597632> 18:51:17.837 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1597632> 18:51:24.416 [10001] Signal 31 recieved.
<1:1597632> 18:49:49.976 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:1597632> 18:50:28.192 [00001] There are 3612066 records is loaded!
2000 0.34
<1:2883830> 18:51:47.365 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:2883830> 18:52:21.163 [00001] There are 3612066 records is loaded!
<1:2883830> 18:52:26.166 [00001] The load SQL is [select USER_NUMBER from dr_gsm_931_20050831 where 1=1 ]
<1:2883830> 18:53:01.576 [00001] There are 3612066 records is loaded!
参? http://otl.sourceforge.net/otl3_ex113.htm
]]>
C语言中对旉和日期的处理
Chuck Allison
Chuck Allison是盐湖城?/span>Latter Day教堂总部下耶稣教堂家族历史研究处的软g体系设计?/span>。他拥有数学学士和数学硕士学位。他?/span>1975qv开始编E，?/span>1984qv他开始从?/span>c语言的教学和开发。他目前的兴是面向对象的技术及其教肌Ӏ他?/span>X3J16Q?/span>ANSI C ++标准化委员会的一员?/span>发?/span>e-mail?/span>allison@decus.orgQ或者拨打电话到(801)240-4510均可以与他取得联pR?/span>
大部分的操作pȝ有办法得到当前的日期和时间。通过定义?em>time.h的库函数Q?span>ANSI C能以许多不同的Ş式得到这个信息。函?em>timeq回一个类型ؓtime_t的|通常为longQ，该函数在q行期间对当前的日期和时间进行编码。然后你可以这个返回g递给其他能对该D行解码和格式化的函数?/span>
Listing 1中的E序使用函数timeQ?em>localtime?em>strftime以不同的形式输出当前的日期和旉。函?em>localtime把已l编码的旉解码成如下的structQ?/font>
struct tm
{
int tm_sec; /* (0 - 61) */
int tm_min; /* (0 - 59) */
int tm_hour; /* (0 - 23) */
int tm_mday; /* (1 - 31) */
int tm_mon; /* (0 - 11) */
int tm_year; /* past 1900 */
int tm_wday; /* (0 - 6) */
int tm_yday; /* (0 - 365) */
int tm_isdst; /* daylight savings flag */
};
每次当你调用localtime的时候，它会重写一个静态的l构q返回该l构的地址Q因此同一时刻在一个程序中只能取得一个这Ll构Q而不能做明显的拷贝）。函?/font>ctimeq回一个指向静态字W串的指针，该字W串以标准的格式包含了完整的旉和日期?/font>strftimeҎ用户的指定格式格式化字符Ԍ例如Q?/span>%A代表一周中每一天的名称Q?/span>Table 1列出了格式描q符的完整列表?/span>
旉/日期q算
通过改变tml构里的|可对旉/日期q行q算?a >Listing 2中的E序展示了如何计将来某天的日期和以Uؓ单位所计算出的E序执行旉。注意函?em>time的语法（参数time_t由地址传入Qƈ非作为函数的q回|。函?em>mktime改变tml构的|以便日期和时间在一个合适的范围内，之后day-of-week (tm_wday)和day-of-year (tm_yday)域进行相应的更新?em>mktime?em>tml构中日期和旉的值置于合适的范围之内Q相应的更新day of week (tm-wday)和day of year (tm-yday)的倹{这U情况发生在当一个日期超Z你的实现能够支持的范围的时候。例如，我的MS-DOS的编译器不能~码1970q?月䆾之前的日期。函?em>asctimeq回tm参数所描述旉的标准字W串Q因?em>ctime (&tval)与asctime (localtime(&tval)是相{的)。函?em>difftimeq回用秒做单位的两个time_t的差?/span>
如果需要处理超出系l范围的日期Q或者需要计两个日期的间隔又不是用U来做单位，那你需要设计自qdate~码?a >Listing 3 ?a >Listing 5中的应用E序通过使用一个简单的month-day-yearl构Q展CZ定两个日期间隔的年数、月份数和天数的技术。日期的相减像你在学里做的减法那P例如Q首先进行天数的相减Q如果需要就向月份数借位Q以此类推）。注意蟩q的q䆾都被计算q去了。ؓ了简略v见，date_interval函数假设日期都是有效的，q且W一个日期在W二个日期之前。函数返回一个指向静?em>Datel构的指针，该结构包含了我们惌的答案?/span>
文g旉/日期?/span>
大多数操作系lؓ文gl护旉/日期戟뀂至你能得知一个文件最后被修改的时间。（常用?em>make工具使用q一信息来决定一个文件是否需要被重新~译Q或者一个应用程序是否需要被重新q接Q。由于文件系l在不同q_上有所不同Q没有什么通用的函数得C个文件的旉/日期戻I因此ANSI 标准没有定义q样的函数。然而，大多数流行的操作pȝQ包括MS-DOS和VAX/VMSQ提供了UNIX函数statQ该函数q回相关的文件信息，包括?em>time_t表示的最后修Ҏ间?/span>
Listing 6中的E序使用stat?em>difftime来确定是?em>time1.c?em>time2.c更新Q例如，是否最q被修改q）?/font>
如果你需要更C个文件的旉/日期戛_当前旉Q可单的重写文g的第一个字节。虽然实际内容ƈ未改变，但你的文件系l会认ؓ文g已经被改变了Qƈ且会相应的更新时?日期戟뀂（知道你的文gpȝQ在VAX/VMS下，当你得到一个文件的新版本的时候，旧的版本仍会被保留）。这U技术叫?#8220;‘touching’一个文?#8221;?a >Listing 7?em>touch的实现在指定文g不存在的时候会创徏一个新文g。注意文件以“binary”模式打开Q在打开模式字符串中由字W?em>b军_—在来的专栏中我会详细讨论文g处理的问题）?/span>
?span>1Q?em>strftime的格式描q符
Code Sample Output
---------------------------------------------
%a Wed
%A Wednesday
%b Oct
%B October
%c Wed Oct 07 13:24:27 1992
%d 07 (day of month [01-31])
%H 13 (hour in [00-23])
%I 01 (hour in [01-12])
%j 281 (day of year [001-366])
%m 10 (month [01-12])
%M 24 (minute [00-59])
%p PM
%S 27 (second [00-59] )
%U 40 (Sunday week of year [00-52])
%w 3 (day of week [0-6])
%W 40 (Monday week of year [00-52])
%x Wed Oct 7, 1992
%X 13:24:27
%y 92
%Y 1992
%Z EDT (daylight savings indicator)
Listing 1 time1.c ?采用不同格式输出当前的日期和旉
#include <stdio.h>
#include <time.h>
#define BUFSIZE 128
main()
{
time_t tval;
struct tm *now;
char buf[BUFSIZE];
char *fancy_format =
"Or getting really fancy:\n"
"%A, %B %d, day %j of %Y.\n"
"The time is %I:%M %p.";
/* Get current date and time */
tval = time(NULL);
now = localtime(&tval);
printf("The current date and time:\n"
"%d/%02d/%02d %d:%02d:%02d\n\n",
now->tm_mon+1, now->tm_mday, now->tm_year,
now->tm_hour, now->tm_min, now->tm_sec);
printf("Or in default system format:\n%s\n",
ctime(&tval));
strftime(buf,sizeof buf,fancy_format,now);
puts(buf);
return 0;
}
/* Output
The current date and time:
10/06/92 12:58:00
Or in default system format:
Tue Oct 06 12:58:00 1992
Or getting really fancy:
Tuesday, October 06, day 280 of 1992.
The time is 12:58 PM.
*/
/* End of File */
Listing 2 time2.c ?em>展示如何计算来某一天的日期以及以秒为单位计出的执行时?/em>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
main()
{
time_t start, stop;
struct tm *now;
int ndays;
/* Get current date and time */
time(&start);
now = localtime(&start);
/* Enter an interval in days */
fputs("How many days from now? ",stderr);
if (scanf("%d",&ndays) !=1)
return EXIT_FAILURE;
now->tm_mday += ndays;
if (mktime(now) != -1)
printf("New date: %s",asctime(now));
else
puts("Sorry. Can't encode your date.");
/* Calculate elapsed time */
time(&stop);
printf("Elapsed program time in seconds: %f\n",
difftime(stop,start));
return EXIT_SUCCESS;
}
/* Output
How many days from now? 45
New date: Fri Nov 20 12:40:32 1992
Elapsed program time in seconds: 1.000000
*/
/* End of File */
Listing 3 date.h ?一个简单的日期l构
struct Date
{
int day;
int month;
int year;
};
typedef struct Date Date;
Date* date_interval(const Date *, const Date *);
/* End of File */
Listing 4 date_int.c ?计算两个日期的间?/em>
/* date_int.c: Compute duration between two dates */
#include "date.h"
#define isleap(y) \
((y)%4 == 0 && (y)%100 != 0 || (y)%400 == 0)
static int Dtab [2][13] =
{
{0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}
};
Date *date_interval(const Date *d1, const Date *d2)
{
static Date result;
int months, days, years, prev_month;
/* Compute the interval - assume d1 precedes d2 */
years = d2->year - d1->year;
months = d2->month - d1->month;
days = d2->day - d1->day;
/* Do obvious corrections (days before months!)
*
* This is a loop in case the previous month is
* February, and days < -28.
*/
prev_month = d2->month - 1;
while (days < 0)
{
/* Borrow from the previous month */
if (prev_month == 0)
prev_month = 12;
--months;
days += Dtab[isleap(d2->year)][prev_month--];
}
if (months < 0)
{
/* Borrow from the previous year */
--years;
months += 12;
}
/* Prepare output */
result.month = months;
result.day = days;
result.year = years;
return &result;
}
/* End of File */
Listing 5 tdate.c ?举例说明日期间隔函数的?/em>
/* tdate.c: Test date_interval() */
#include <stdio.h>
#include <stdlib.h>
#include "date.h"
main()
{
Date d1, d2, *result;
int nargs;
/* Read in two dates - assume 1st precedes 2nd */
fputs("Enter a date, MM/DD/YY> ",stderr);
nargs = scanf("%d/%d/%d%*c", &d1.month,
&d1.day, &d1.year);
if (nargs != 3)
return EXIT_FAILURE;
fputs("Enter a later date, MM/DD/YY> ",stderr);
nargs = scanf("%d/%d/%d%*c", &d2.month,
&d2.day, &d2.year);
if (nargs != 3)
return EXIT_FAILURE;
/* Compute interval in years, months, and days */
result = date_interval(&d1, &d2);
printf("years: %d, months: %d, days: %d\n",
result->year, result->month, result->day);
return EXIT_SUCCESS;
}
/* Sample Execution:
Enter a date, MM/DD/YY> 10/1/51
Enter a later date, MM/DD/YY> 10/6/92
years: 41, months: 0, days: 5 */
/* End of File */
Listing 6 ftime.c ?定是否time1.c?/em>time2.c更新
/* ftime.c: Compare file time stamps */
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <time.h>
main()
{
struct stat fs1, fs2;
if (stat("time1.c",&fs1) == 0 &&
stat("time2.c",&fs2) == 0)
{
double interval =
difftime(fs2.st_mtime,fs1.st_mtime);
printf("time1.c %s newer than time2.c\n",
(interval < 0.0) ? "is" : "is not");
return EXIT_SUCCESS;
}
else
return EXIT_FAILURE;
}
/* Output
time1.c is not newer than time2.c */
/* End of File */
Listing 7 touch.c ?em>通过覆盖旧文件或者创Z个新的文件来更新旉?/em>
/* touch.c: Update a file's time stamp */
#include <stdio.h>
void touch(char *fname)
{
FILE *f = fopen(fname,"r+b");
if (f != NULL)
{
char c = getc(f);
rewind(f);
putc(c,f);
}
else
fopen(fname,"wb");
fclose(f);
}
/* End of File */
]]>
一、函数的调用语法
函数调用Q很像变量的使用Q也是以“$”来标识的Q其语法如下Q?
$(<function>; <arguments>;)
或是
${<function>; <arguments>;}
q里Q?lt;function>;是函数名，make支持的函C多?lt;arguments>;是函数的参数Q参数间以逗号“,”分隔Q而函数名和参C间以“I格”分隔。函数调用以“$”开_以圆括号或花括号把函数名和参数括赗感觉很像一个变量，是不是？函数中的参数可以使用变量Qؓ了风格的l一Q函数和变量的括h好一P如?#8220;$(subst a,b,$(x))”q样的Ş式，而不?#8220;$(subst a,b,${x})”的Ş式。因为统一会更清楚Q也会减一些不必要的麻烦?
q是来看一个示例：
comma:= ,
empty:=
space:= $(empty) $(empty)
foo:= a b c
bar:= $(subst $(space),$(comma),$(foo))
在这个示例中Q?(comma)的值是一个逗号?(space)使用?(empty)定义了一个空|$(foo)的值是“a b c”Q?(bar)的定义用Q调用了函数“subst”Q这是一个替换函敎ͼq个函数有三个参敎ͼW一个参数是被替换字ԌW二个参数是替换字串Q第三个参数是替换操作作用的字串。这个函C是?(foo)中的I格替换成逗号Q所?(bar)的值是“a,b,c”?
二、字W串处理函数
$(subst <from>;,<to>;,<text>;)
名称Q字W串替换函数——subst?
功能Q把字串<text>;中的<from>;字符串替换成<to>;?
q回Q函数返回被替换q后的字W串?
CZQ?
$(subst ee,EE,feet on the street)Q?
?#8220;feet on the street”中的“ee”替换?#8220;EE”Q返回结果是“fEEt on the strEEt”?
$(patsubst <pattern>;,<replacement>;,<text>;)
名称Q模式字W串替换函数——patsubst?
功能Q查?lt;text>;中的单词Q单词以“I格”?#8220;Tab”?#8220;回R”“换行”分隔Q是否符合模?lt;pattern>;Q如果匹配的话，则以<replacement>;替换。这里，<pattern>;可以包括通配W?#8220;%”Q表CZQ意长度的字串。如?lt;replacement>;中也包含“%”Q那么，<replacement>;中的q个“%”是<pattern>;中的那个“%”所代表的字丌Ӏ（可以?#8220;\”来{义，?#8220;\%”来表C真实含义的“%”字符Q?
q回Q函数返回被替换q后的字W串?
CZQ?
$(patsubst %.c,%.o,x.c.c bar.c)
把字?#8220;x.c.c bar.c”W合模式[%.c]的单词替换成[%.o]Q返回结果是“x.c.o bar.o”
备注Q?
q和我们前面“变量章节”说过的相关知识有点相伹{如Q?
“$(var:<pattern>;=<replacement>;)”
相当?
“$(patsubst <pattern>;,<replacement>;,$(var))”Q?
?#8220;$(var: <suffix>;=<replacement>;)”
则相当于
“$(patsubst %<suffix>;,%<replacement>;,$(var))”?
例如有：objects = foo.o bar.o baz.oQ?
那么Q?#8220;$(objects:.o=.c)”?#8220;$(patsubst %.o,%.c,$(objects))”是一L?
$(strip <string>;)
名称Q去I格函数——strip?
功能Q去?lt;string>;字串中开头和l尾的空字符?
q回Q返回被LI格的字W串倹{?
CZQ?
$(strip a b c )
把字?#8220;a b c ”d开头和l尾的空|l果?#8220;a b c”?
$(findstring <find>;,<in>;)
名称Q查扑֭W串函数——findstring?
功能Q在字串<in>;中查?lt;find>;字串?
q回Q如果找刎ͼ那么q回<find>;Q否则返回空字符丌Ӏ?
CZQ?
$(findstring a,a b c)
$(findstring a,b c)
W一个函数返?#8220;a”字符ԌW二个返?#8220;”字符ԌI字W串Q?
$(filter <pattern...>;,<text>;)
名称Q过滤函数——filter?
功能Q以<pattern>;模式qo<text>;字符串中的单词，保留W合模式<pattern>;的单词。可以有多个模式?
q回Q返回符合模?lt;pattern>;的字丌Ӏ?
CZQ?
sources := foo.c bar.c baz.s ugh.h
foo: $(sources)
cc $(filter %.c %.s,$(sources)) -o foo
$(filter %.c %.s,$(sources))q回的值是“foo.c bar.c baz.s”?
$(filter-out <pattern...>;,<text>;)
名称Q反qo函数——filter-out?
功能Q以<pattern>;模式qo<text>;字符串中的单词，去除W合模式<pattern>;的单词。可以有多个模式?
q回Q返回不W合模式<pattern>;的字丌Ӏ?
CZQ?
objects=main1.o foo.o main2.o bar.o
mains=main1.o main2.o
$(filter-out $(mains),$(objects)) q回值是“foo.o bar.o”?
$(sort <list>;)
名称Q排序函数——sort?
功能Q给字符?lt;list>;中的单词排序Q升序）?
q回Q返回排序后的字W串?
CZQ?(sort foo bar lose)q回“bar foo lose” ?
备注Qsort函数会去?lt;list>;中相同的单词?
$(word <n>;,<text>;)
名称Q取单词函数——word?
功能Q取字符?lt;text>;中第<n>;个单词。（从一开始）
q回Q返回字W串<text>;中第<n>;个单词。如?lt;n>;?lt;text>;中的单词数要大，那么q回I字W串?
CZQ?(word 2, foo bar baz)q回值是“bar”?
$(wordlist <s>;,<e>;,<text>;)
名称Q取单词串函数——wordlist?
功能Q从字符?lt;text>;中取?lt;s>;开始到<e>;的单词串?lt;s>;?lt;e>;是一个数字?
q回Q返回字W串<text>;中从<s>;?lt;e>;的单词字丌Ӏ如?lt;s>;?lt;text>;中的单词数要大，那么q回I字W串。如?lt;e>;大于<text>;的单词数Q那么返回从<s>;开始，?lt;text>;l束的单词串?
CZQ?nbsp;$(wordlist 2, 3, foo bar baz)q回值是“bar baz”?
$(words <text>;)
名称Q单词个数统计函数——words?
功能Q统?lt;text>;中字W串中的单词个数?
q回Q返?lt;text>;中的单词数?
CZQ?(words, foo bar baz)q回值是“3”?
备注Q如果我们要?lt;text>;中最后的一个单词，我们可以q样Q?(word $(words <text>;),<text>;)?
$(firstword <text>;)
名称Q首单词函数——firstword?
功能Q取字符?lt;text>;中的W一个单词?
q回Q返回字W串<text>;的第一个单词?
CZQ?(firstword foo bar)q回值是“foo”?
备注Q这个函数可以用word函数来实玎ͼ$(word 1,<text>;)?
以上Q是所有的字符串操作函敎ͼ如果搭配混合使用Q可以完成比较复杂的功能。这里，举一个现实中应用的例子。我们知道，make使用“VPATH”变量来指?#8220;依赖文g”的搜索\径。于是，我们可以利用q个搜烦路径来指定编译器对头文g的搜索\径参数CFLAGSQ如Q?
override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))
如果我们?#8220;$(VPATH)”值是“src:../headers”Q那?#8220;$(patsubst %,-I%,$(subst :, ,$(VPATH)))”返?#8220;-Isrc -I../headers”Q这正是cc或gcc搜烦头文件\径的参数?
三、文件名操作函数
下面我们要介l的函数主要是处理文件名的。每个函数的参数字符串都会被当做一个或是一pd的文件名来对待?
$(dir <names...>;)
名称Q取目录函数——dir?
功能Q从文g名序?lt;names>;中取出目录部分。目录部分是指最后一个反斜杠Q?#8220;/”Q之前的部分。如果没有反斜杠Q那么返?#8220;./”?
q回Q返回文件名序列<names>;的目录部分?
CZQ?nbsp;$(dir src/foo.c hacks)q回值是“src/ ./”?
$(notdir <names...>;)
名称Q取文g函数——notdir?
功能Q从文g名序?lt;names>;中取出非目录部分。非目录部分是指最后一个反斜杠Q?#8220;/”Q之后的部分?
q回Q返回文件名序列<names>;的非目录部分?
CZQ?nbsp;$(notdir src/foo.c hacks)q回值是“foo.c hacks”?
$(suffix <names...>;)
名称Q取后缀函数——suffix?
功能Q从文g名序?lt;names>;中取出各个文件名的后~?
q回Q返回文件名序列<names>;的后~序列Q如果文件没有后~Q则q回I字丌Ӏ?
CZQ?(suffix src/foo.c src-1.0/bar.c hacks)q回值是“.c .c”?
$(basename <names...>;)
名称Q取前缀函数——basename?
功能Q从文g名序?lt;names>;中取出各个文件名的前~部分?
q回Q返回文件名序列<names>;的前~序列Q如果文件没有前~Q则q回I字丌Ӏ?
CZQ?(basename src/foo.c src-1.0/bar.c hacks)q回值是“src/foo src-1.0/bar hacks”?
$(addsuffix <suffix>;,<names...>;)
名称Q加后缀函数——addsuffix?
功能Q把后缀<suffix>;加到<names>;中的每个单词后面?
q回Q返回加q后~的文件名序列?
CZQ?(addsuffix .c,foo bar)q回值是“foo.c bar.c”?
$(addprefix <prefix>;,<names...>;)
名称Q加前缀函数——addprefix?
功能Q把前缀<prefix>;加到<names>;中的每个单词后面?
q回Q返回加q前~的文件名序列?
CZQ?(addprefix src/,foo bar)q回值是“src/foo src/bar”?
$(join <list1>;,<list2>;)
名称Q连接函数——join?
功能Q把<list2>;中的单词对应地加?lt;list1>;的单词后面。如?lt;list1>;的单词个数要?lt;list2>;的多Q那么，<list1>;中的多出来的单词保持原栗如?lt;list2>;的单词个数要?lt;list1>;多，那么Q?lt;list2>;多出来的单词被复制?lt;list2>;中?
q回Q返回连接过后的字符丌Ӏ?
CZQ?(join aaa bbb , 111 222 333)q回值是“aaa111 bbb222 333”?br>
]]>
使用条g判断Q可以让makeҎq行时的不同情况选择不同的执行分支。条件表辑ּ可以是比较变量的|或是比较变量和常量的倹{?
一、示?
下面的例子，判断$(CC)变量是否“gcc”Q如果是的话Q则使用GNU函数~译目标?
libs_for_gcc = -lgnu
normal_libs =
foo: $(objects)
ifeq ($(CC),gcc)
$(CC) -o foo $(objects) $(libs_for_gcc)
else
$(CC) -o foo $(objects) $(normal_libs)
endif
可见Q在上面CZ的这个规则中Q目?#8220;foo”可以Ҏ变量“$(CC)”值来选取不同的函数库来编译程序?
我们可以从上面的CZ中看C个关键字Qifeq、else和endif。ifeq的意思表C条件语句的开始，q指定一个条件表辑ּQ表辑ּ包含两个参数Q以逗号分隔Q表辑ּ以圆括号括v。else表示条g表达式ؓ假的情况。endif表示一个条件语句的l束QQ何一个条件表辑ּ都应该以endifl束?
当我们的变量$(CC)值是“gcc”Ӟ目标foo的规则是Q?
foo: $(objects)
$(CC) -o foo $(objects) $(libs_for_gcc)
而当我们的变?(CC)g?#8220;gcc”Ӟ比如“cc”Q，目标foo的规则是Q?
foo: $(objects)
$(CC) -o foo $(objects) $(normal_libs)
当然Q我们还可以把上面的那个例子写得更简z一些：
libs_for_gcc = -lgnu
normal_libs =
ifeq ($(CC),gcc)
libs=$(libs_for_gcc)
else
libs=$(normal_libs)
endif
foo: $(objects)
$(CC) -o foo $(objects) $(libs)
二、语?
条g表达式的语法为：
<conditional-directive>;
<text-if-true>;
endif
以及Q?
<conditional-directive>;
<text-if-true>;
else
<text-if-false>;
endif
其中<conditional-directive>;表示条g关键字，?#8220;ifeq”。这个关键字有四个?
W一个是我们前面所见过?#8220;ifeq”
ifeq (<arg1>;, <arg2>;)
ifeq '<arg1>;' '<arg2>;'
ifeq "<arg1>;" "<arg2>;"
ifeq "<arg1>;" '<arg2>;'
ifeq '<arg1>;' "<arg2>;"
比较参数“arg1”?#8220;arg2”的值是否相同。当Ӟ参数中我们还可以使用make的函数。如Q?
ifeq ($(strip $(foo)),)
<text-if-empty>;
endif
q个CZ中用了“strip”函数Q如果这个函数的q回值是I（EmptyQ，那么<text-if-empty>;q效?
W二个条件关键字?#8220;ifneq”。语法是Q?
ifneq (<arg1>;, <arg2>;)
ifneq '<arg1>;' '<arg2>;'
ifneq "<arg1>;" "<arg2>;"
ifneq "<arg1>;" '<arg2>;'
ifneq '<arg1>;' "<arg2>;"
其比较参?#8220;arg1”?#8220;arg2”的值是否相同，如果不同Q则为真。和“ifeq”cM?
W三个条件关键字?#8220;ifdef”。语法是Q?
ifdef <variable-name>;
如果变量<variable-name>;的值非I，那到表达式ؓ真。否则，表达式ؓ假。当Ӟ<variable-name>;同样可以是一个函数的q回倹{注意，ifdef只是试一个变量是否有|其ƈ不会把变量扩展到当前位置。还是来看两个例子：
CZ一Q?
bar =
foo = $(bar)
ifdef foo
frobozz = yes
else
frobozz = no
endif
CZ二：
foo =
ifdef foo
frobozz = yes
else
frobozz = no
endif
W一个例子中Q?#8220;$(frobozz)”值是“yes”Q第二个则是“no”?
W四个条件关键字?#8220;ifndef”。其语法是：
ifndef <variable-name>;
q个我就不多说了Q和“ifdef”是相反的意思?
?lt;conditional-directive>;q一行上Q多余的I格是被允许的，但是不能以[Tab]键做为开始（不然p认ؓ是命令）。而注释符“#”同样也是安全的?#8220;else”?#8220;endif”也一P只要不是以[Tab]键开始就行了?
特别注意的是Qmake是在dMakefile时就计算条g表达式的|q根据条件表辑ּ的值来选择语句Q所以，你最好不要把自动化变量（?#8220;$@”{）攑օ条g表达式中Q因动化变量是在q行时才有的?
而且Qؓ了避免乱，make不允许把整个条g语句分成两部分放在不同的文g中?br>
]]>
q有一U设|变量值的Ҏ是用define关键字。用define关键字设|变量的值可以有换行Q这有利于定义一pd的命令（前面我们讲过“命o?#8221;的技术就是利用这个关键字Q?
define指示W后面跟的是变量的名字，而重起一行定义变量的|定义是以endef关键字结束。其工作方式?#8220;=”操作W一栗变量的值可以包含函数、命令、文字，或是其它变量。因为命令需要以[Tab]键开_所以如果你用define定义的命令变量中没有以[Tab]键开_那么make׃会把其认为是命o?
下面的这个示例展CZdefine的用法：
define two-lines
echo foo
echo $(bar)
endef
七、环境变?
makeq行时的pȝ环境变量可以在make开始运行时被蝲入到Makefile文g中，但是如果Makefile中已定义了这个变量，或是q个变量由make命o行带入，那么pȝ的环境变量的值将被覆盖。（如果make指定?#8220;-e”参数Q那么，pȝ环境变量覆盖Makefile中定义的变量Q?
因此Q如果我们在环境变量中设|了“CFLAGS”环境变量Q那么我们就可以在所有的Makefile中用这个变量了。这对于我们使用l一的编译参数有比较大的好处。如果Makefile中定义了CFLAGSQ那么则会用Makefile中的q个变量Q如果没有定义则使用pȝ环境变量的|一个共性和个性的l一Q很?#8220;全局变量”?#8220;局部变?#8221;的特性?
当make嵌套调用Ӟ参见前面?#8220;嵌套调用”章节Q，上层Makefile中定义的变量会以pȝ环境变量的方式传递到下层的Makefile中。当Ӟ默认情况下，只有通过命o行设|的变量会被传递。而定义在文g中的变量Q如果要向下层Makefile传递，则需要用exprot关键字来声明。（参见前面章节Q?
当然Q我q不推荐把许多的变量都定义在pȝ环境中，q样Q在我们执行不用的MakefileӞ拥有的是同一套系l变量，q可能会带来更多的麻烦?
八、目标变?
前面我们所讲的在Makefile中定义的变量都是“全局变量”Q在整个文gQ我们都可以讉Kq些变量。当Ӟ“自动化变?#8221;除外Q如“$<”{这U类量的自动化变量就属于“规则型变?#8221;Q这U变量的g赖于规则的目标和依赖目标的定义?
当然Q我样同样可以ؓ某个目标讄局部变量，q种变量被称?#8220;Target-specific Variable”Q它可以?#8220;全局变量”同名Q因为它的作用范围只在这条规则以及连带规则中Q所以其g只在作用范围内有效。而不会媄响规则链以外的全局变量的倹{?
其语法是Q?
<target ...>; : <variable-assignment>;
<target ...>; : overide <variable-assignment>;
<variable-assignment>;可以是前面讲q的各种赋D辑ּQ如“=”?#8220;:=”?#8220;+=”或是“Q?”。第二个语法是针对于make命o行带入的变量Q或是系l环境变量?
q个Ҏ非常的有用Q当我们讄了这样一个变量，q个变量会作用到p个目标所引发的所有的规则中去。如Q?
prog : CFLAGS = -g
prog : prog.o foo.o bar.o
$(CC) $(CFLAGS) prog.o foo.o bar.o
prog.o : prog.c
$(CC) $(CFLAGS) prog.c
foo.o : foo.c
$(CC) $(CFLAGS) foo.c
bar.o : bar.c
$(CC) $(CFLAGS) bar.c
在这个示例中Q不全局?(CFLAGS)的值是什么，在prog目标Q以及其所引发的所有规则中Qprog.o foo.o bar.o的规则）Q?(CFLAGS)的值都?#8220;-g”
九、模式变?
在GNU的make中，q支持模式变量（Pattern-specific VariableQ，通过上面的目标变量中Q我们知道，变量可以定义在某个目标上。模式变量的好处是Q我们可以给定一U?#8220;模式”Q可以把变量定义在符合这U模式的所有目标上?
我们知道Qmake?#8220;模式”一般是臛_含有一?#8220;%”的，所以，我们可以以如下方式给所有以[.o]l尾的目标定义目标变量：
%.o : CFLAGS = -O
同样Q模式变量的语法?#8220;目标变量”一P
<pattern ...>; : <variable-assignment>;
<pattern ...>; : override <variable-assignment>;
override同样是针对于pȝ环境传入的变量，或是make命o行指定的变量?nbsp;
]]>
q里介绍两种变量的高U用方法，W一U是变量值的替换?
我们可以替换变量中的共有的部分，其格式是“$(var:a=b)”或是“${var:a=b}”Q其意思是Q把变量“var”中所有以“a”字串“l尾”?#8220;a”替换?#8220;b”字串。这里的“l尾”意思是“I格”或是“l束W?#8221;?
q是看一个示例吧Q?
foo := a.o b.o c.o
bar := $(foo:.o=.c)
q个CZ中，我们先定义了一?#8220;$(foo)”变量Q而第二行的意思是?#8220;$(foo)”中所有以“.o”字串“l尾”全部替换?#8220;.c”Q所以我们的“$(bar)”的值就?#8220;a.c b.c c.c”?
另外一U变量替换的技术是?#8220;静态模?#8221;Q参见前面章节）定义的，如：
foo := a.o b.o c.o
bar := $(foo:%.o=%.c)
q依赖于被替换字串中的有相同的模式，模式中必d含一?#8220;%”字符Q这个例子同栯$(bar)变量的gؓ“a.c b.c c.c”?nbsp;
W二U高U用法是—?#8220;把变量的值再当成变量”。先看一个例子：
x = y
y = z
a := $($(x))
在这个例子中Q?(x)的值是“y”Q所?($(x))是$(y)Q于?(a)的值就?#8220;z”。（注意Q是“x=y”Q而不?#8220;x=$(y)”Q?
我们q可以用更多的层次Q?
x = y
y = z
z = u
a := $($($(x)))
q里?(a)的值是“u”Q相关的推导留给读者自己去做吧?
让我们再复杂一点，使用?#8220;在变量定义中使用变量”的第一个方式，来看一个例子：
x = $(y)
y = z
z = Hello
a := $($(x))
q里?($(x))被替换成?($(y))Q因?(y)值是“z”Q所以，最l结果是Qa:=$(z)Q也是“Hello”?
再复杂一点，我们再加上函敎ͼ
x = variable1
variable2 := Hello
y = $(subst 1,2,$(x))
z = y
a := $($($(z)))
q个例子中，“$($($(z)))”扩展?#8220;$($(y))”Q而其再次被扩展ؓ“$($(subst 1,2,$(x)))”?(x)的值是“variable1”Qsubst函数?#8220;variable1”中的所?#8220;1”字串替换?#8220;2”字串Q于是，“variable1”变成“variable2”Q再取其|所以，最l，$(a)的值就?(variable2)的值—?#8220;Hello”。（喔，好不ҎQ?
在这U方式中Q或要可以用多个变量来l成一个变量的名字Q然后再取其|
first_second = Hello
a = first
b = second
all = $($a_$b)
q里?#8220;$a_$b”l成?#8220;first_second”Q于是，$(all)的值就?#8220;Hello”?
再来看看l合W一U技术的例子Q?
a_objects := a.o b.o c.o
1_objects := 1.o 2.o 3.o
sources := $($(a1)_objects:.o=.c)
q个例子中，如果$(a1)的值是“a”的话Q那么，$(sources)的值就?#8220;a.c b.c c.c”Q如?(a1)的值是“1”Q那?(sources)的值是“1.c 2.c 3.c”?
再来看一个这U技术和“函数”?#8220;条g语句”一同用的例子Q?
ifdef do_sort
func := sort
else
func := strip
endif
bar := a d b g q c
foo := $($(func) $(bar))
q个CZ中，如果定义?#8220;do_sort”Q那么：foo := $(sort a d b g q c)Q于?(foo)的值就?#8220;a b c d g q”Q而如果没有定?#8220;do_sort”Q那么：foo := $(sort a d b g q c)Q调用的是strip函数?
当然Q?#8220;把变量的值再当成变量”q种技术，同样可以用在操作W的左边Q?
dir = foo
$(dir)_sources := $(wildcard $(dir)/*.c)
define $(dir)_print
lpr $($(dir)_sources)
endef
q个例子中定义了三个变量Q?#8220;dir”Q?#8220;foo_sources”?#8220;foo_print”?
四、追加变量?
我们可以使用“+=”操作W给变量q加|如：
objects = main.o foo.o bar.o utils.o
objects += another.o
于是Q我们的$(objects)值变成：“main.o foo.o bar.o utils.o another.o”Qanother.o被追加进MQ?
使用“+=”操作W，可以模拟Z面的q种例子Q?
objects = main.o foo.o bar.o utils.o
objects := $(objects) another.o
所不同的是Q用“+=”更ؓz?
如果变量之前没有定义q，那么Q?#8220;+=”会自动变?#8220;=”Q如果前面有变量定义Q那?#8220;+=”会承于前次操作的赋值符。如果前一ơ的?#8220;:=”Q那?#8220;+=”会以“:=”作ؓ其赋值符Q如Q?
variable := value
variable += more
{h于：
variable := value
variable := $(variable) more
但如果是q种情况Q?nbsp;
variable = value
variable += more
׃前次的赋值符?#8220;=”Q所?#8220;+=”也会?#8220;=”来做|那么岂不会发生变量的递补归定义，q是很不好的Q所以make会自动ؓ我们解决q个问题Q我们不必担心这个问题?
五、override 指示W?
如果有变量是通常make的命令行参数讄的，那么Makefile中对q个变量的赋g被忽略。如果你惛_Makefile中设|这cd数的|那么Q你可以使用“override”指示W。其语法是：
override <variable>; = <value>;
override <variable>; := <value>;
当然Q你q可以追加：
override <variable>; += <more text>;
对于多行的变量定义，我们用define指示W，在define指示W前Q也同样可以使用ovveride指示W，如：
override define foo
bar
endef
]]>
在Makefile中的定义的变量，像是C/C++语言中的宏一P他代表了一个文本字Ԍ在Makefile中执行的时候其会自动原模原样地展开在所使用的地斏V其与C/C++所不同的是Q你可以在Makefile中改变其倹{在Makefile中，变量可以使用?#8220;目标”Q?#8220;依赖目标”Q?#8220;命o”或是Makefile的其它部分中?
变量的命名字可以包含字符、数字，下划U（可以是数字开_Q但不应该含?#8220;:”?#8220;#”?#8220;=”或是I字W（I格、回车等Q。变量是大小写敏感的Q?#8220;foo”?#8220;Foo”?#8220;FOO”是三个不同的变量名。传l的Makefile的变量名是全大写的命名方式，但我推荐使用大小写搭配的变量名，如：MakeFlags。这样可以避免和pȝ的变量冲H，而发生意外的事情?
有一些变量是很奇怪字Ԍ?#8220;$<”?#8220;$@”{，q些是自动化变量Q我会在后面介绍?
一、变量的基础
变量在声明时需要给予初|而在使用Ӟ需要给在变量名前加?#8220;$”W号Q但最好用括?#8220;Q）”或是大括?#8220;{}”把变量给包括h。如果你要用真实的“$”字符Q那么你需要用“$$”来表C?
变量可以使用在许多地方，如规则中?#8220;目标”?#8220;依赖”?#8220;命o”以及新的变量中。先看一个例子：
objects = program.o foo.o utils.o
program : $(objects)
cc -o program $(objects)
$(objects) : defs.h
变量会在使用它的地方_地展开Q就像C/C++中的宏一P例如Q?
foo = c
prog.o : prog.$(foo)
$(foo)$(foo) -$(foo) prog.$(foo)
展开后得刎ͼ
prog.o : prog.c
cc -c prog.c
当然Q千万不要在你的Makefile中这样干Q这里只是D个例子来表明Makefile中的变量在用处展开的真实样子。可见其是一?#8220;替代”的原理?
另外Q给变量加上括号完全是ؓ了更加安全地使用q个变量Q在上面的例子中Q如果你不想l变量加上括P那也可以Q但我还是强烈徏议你l变量加上括受?
二、变量中的变?
在定义变量的值时Q我们可以用其它变量来构造变量的|在Makefile中有两种方式来在用变量定义变量的倹{?
先看W一U方式，也就是简单的使用“=”P?#8220;=”左侧是变量，右侧是变量的|右侧变量的值可以定义在文g的Q何一处，也就是说Q右侧中的变量不一定非要是已定义好的|其也可以使用后面定义的倹{如Q?
foo = $(bar)
bar = $(ugh)
ugh = Huh?
all:
echo $(foo)
我们执行“make all”会打出变量$(foo)的值是“Huh?”Q?nbsp;$(foo)的值是$(bar)Q?(bar)的值是$(ugh)Q?(ugh)的值是“Huh?”Q可见，变量是可以用后面的变量来定义的?
q个功能有好的地方，也有不好的地方，好的地方是，我们可以把变量的真实值推到后面来定义Q如Q?
CFLAGS = $(include_dirs) -O
include_dirs = -Ifoo -Ibar
?#8220;CFLAGS”在命令中被展开Ӟ会是“-Ifoo -Ibar -O”。但q种形式也有不好的地方，那就是递归定义Q如Q?
CFLAGS = $(CFLAGS) -O
或：
A = $(B)
B = $(A)
q会让make陷入无限的变量展开q程中去Q当Ӟ我们的make是有能力这L定义Qƈ会报错。还有就是如果在变量中用函敎ͼ那么Q这U方式会让我们的makeq行旉常慢Q更p糕的是Q他会用得两个make的函?#8220;wildcard”?#8220;shell”发生不可预知的错误。因Z不会知道q两个函C被调用多次?
Z避免上面的这U方法，我们可以使用make中的另一U用变量来定义变量的Ҏ。这U方法用的?#8220;:=”操作W，如：
x := foo
y := $(x) bar
x := later
其等价于Q?
y := foo bar
x := later
值得一提的是，q种ҎQ前面的变量不能使用后面的变量，只能使用前面已定义好了的变量。如果是q样Q?
y := $(x) bar
x := foo
那么Qy的值是“bar”Q而不?#8220;foo bar”?
上面都是一些比较简单的变量使用了，让我们来看一个复杂的例子Q其中包括了make的函数、条件表辑ּ和一个系l变?#8220;MAKELEVEL”的用：
ifeq (0,${MAKELEVEL})
cur-dir := $(shell pwd)
whoami := $(shell whoami)
host-type := $(shell arch)
MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
endif
关于条g表达式和函数Q我们在后面再说Q对于系l变?#8220;MAKELEVEL”Q其意思是Q如果我们的make有一个嵌套执行的动作Q参见前面的“嵌套使用make”Q，那么Q这个变量会记录了我们的当前Makefile的调用层数?
下面再介l两个定义变量时我们需要知道的Q请先看一个例子，如果我们要定义一个变量，其值是一个空|那么我们可以q样来：
nullstring :=
space := $(nullstring) # end of the line
nullstring是一个Empty变量Q其中什么也没有Q而我们的space的值是一个空根{因为在操作W的双是很难描qC个空格的Q这里采用的技术很用Q先用一个Empty变量来标明变量的值开始了Q而后面采?#8220;#”注释W来表示变量定义的终止，q样Q我们可以定义出其值是一个空格的变量。请注意q里关于“#”的用，注释W?#8220;#”的这U特性值得我们注意Q如果我们这样定义一个变量：
dir := /foo/bar # directory to put the frobs in
dirq个变量的值是“/foo/bar”Q后面还跟了4个空|如果我们q样使用q样变量来指定别的目录—?#8220;$(dir)/file”那么完蛋了?
q有一个比较有用的操作W是“?=”Q先看示例：
FOO ?= bar
其含义是Q如果FOO没有被定义过Q那么变量FOO的值就?#8220;bar”Q如果FOO先前被定义过Q那么这条语什么也不做Q其{h于：
ifeq ($(origin FOO), undefined)
FOO = bar
endif
]]>
在一些大的工E中Q我们会把我们不同模块或是不同功能的源文件放在不同的目录中，我们可以在每个目录中都书写一个该目录的MakefileQ这有利于让我们的Makefile变得更加地简z，而不至于把所有的东西全部写在一个Makefile中，q样会很隄护我们的MakefileQ这个技术对于我们模块编译和分段~译有着非常大的好处?
例如Q我们有一个子目录叫subdirQ这个目录下有个Makefile文gQ来指明了这个目录下文g的编译规则。那么我们L的Makefile可以q样书写Q?
subsystem:
cd subdir && $(MAKE)
其等价于Q?
subsystem:
$(MAKE) -C subdir
定义$(MAKE)宏变量的意思是Q也许我们的make需要一些参敎ͼ所以定义成一个变量比较利于维护。这两个例子的意思都是先q入“subdir”目录Q然后执行make命o?
我们把这个Makefile叫做“LMakefile”QLMakefile的变量可以传递到下的Makefile中（如果你显C的声明Q，但是不会覆盖下层的Makefile中所定义的变量，除非指定?#8220;-e”参数?
如果你要传递变量到下Makefile中，那么你可以用这L声明Q?
export <variable ...>;
如果你不惌某些变量传递到下Makefile中，那么你可以这样声明：
unexport <variable ...>;
如：
CZ一Q?
export variable = value
其等价于Q?
variable = value
export variable
其等价于Q?
export variable := value
其等价于Q?
variable := value
export variable
CZ二：
export variable += value
其等价于Q?
variable += value
export variable
如果你要传递所有的变量Q那么，只要一个exportp了。后面什么也不用跟，表示传递所有的变量?
需要注意的是，有两个变量，一个是SHELLQ一个是MAKEFLAGSQ这两个变量不管你是否exportQ其L要传递到下层Makefile中，特别是MAKEFILES变量Q其中包含了make的参C息，如果我们执行“LMakefile”时有make参数或是在上层Makefile中定义了q个变量Q那么MAKEFILES变量会是这些参敎ͼq会传递到下层Makefile中，q是一个系l的环境变量?
但是make命o中的有几个参数ƈ不往下传递，它们?#8220;-C”,“-f”,“-h”“-o”?#8220;-W”Q有关Makefile参数的细节将在后面说明）Q如果你不想往下层传递参敎ͼ那么Q你可以q样来：
subsystem:
cd subdir && $(MAKE) MAKEFLAGS=
如果你定义了环境变量MAKEFLAGSQ那么你得确信其中的选项是大安会用到的Q如果其中有“-t”,“-n”,?#8220;-q”参数Q那么将会有让你意想不到的结果，或许会让你异常地恐慌?
q有一个在“嵌套执行”中比较有用的参数Q?#8220;-w”或是“--print-directory”会在make的过E中输出一些信息，让你看到目前的工作目录。比如，如果我们的下Umake目录?#8220;/home/hchen/gnu/make”Q如果我们?#8220;make -w”来执行，那么当进入该目录Ӟ我们会看刎ͼ
make: Entering directory `/home/hchen/gnu/make'.
而在完成下层make后离开目录Ӟ我们会看刎ͼ
make: Leaving directory `/home/hchen/gnu/make'
当你使用“-C”参数来指定make下层MakefileӞ“-w”会被自动打开的。如果参C?#8220;-s”Q?#8220;--slient”Q或?#8220;--no-print-directory”Q那么，“-w”L失效的?
五、定义命令包
如果Makefile中出C些相同命令序列，那么我们可以些相同的命o序列定义一个变量。定义这U命令序列的语法?#8220;define”开始，?#8220;endef”l束Q如Q?
define run-yacc
yacc $(firstword $^)
mv y.tab.c $@
endef
q里Q?#8220;run-yacc”是这个命令包的名字，其不要和Makefile中的变量重名。在“define”?#8220;endef”中的两行是命o序列。这个命令包中的W一个命令是q行YaccE序Q因为YaccE序L生成“y.tab.c”的文Ӟ所以第二行的命令就是把q个文gҎ名字。还是把q个命o包放C个示例中来看看吧?
foo.c : foo.y
$(run-yacc)
我们可以看见Q要使用q个命o包，我们好像用变量一栗在q个命o包的使用中，命o?#8220;run-yacc”中的“$^”是“foo.y”Q?#8220;$@”是“foo.c”Q有兌U以“$”开头的Ҏ变量Q我们会在后面介l）Qmake在执行命令包Ӟ命o包中的每个命令会被依ơ独立执行?br>
]]>
每条规则中的命o和操作系lShell的命令行是一致的。make会一按顺序一条一条的执行命oQ每条命令的开头必M[Tab]键开_除非Q命令是紧跟在依赖规则后面的分号后的。在命o行之间中的空格或是空行会被忽略，但是如果该空格或I是以Tab键开头的Q那么make会认为其是一个空命o?
我们在UNIX下可能会使用不同的ShellQ但是make的命令默认是?#8220;/bin/sh”——UNIX的标准Shell解释执行的。除非你特别指定一个其它的Shell。Makefile中，“#”是注释符Q很像C/C++中的“//”Q其后的本行字符都被注释?
一、显C命?
通常Qmake会把其要执行的命令行在命令执行前输出到屏q上。当我们?#8220;@”字符在命令行前，那么Q这个命令将不被make昄出来Q最具代表性的例子是，我们用这个功能来像屏q显CZ些信息。如Q?
@echo 正在~译XXX模块......
当make执行Ӟ会输?#8220;正在~译XXX模块......”字串Q但不会输出命oQ如果没?#8220;@”Q那么，make输出：
echo 正在~译XXX模块......
正在~译XXX模块......
如果make执行Ӟ带入make参数“-n”?#8220;--just-print”Q那么其只是昄命oQ但不会执行命oQ这个功能很有利于我们调试我们的MakefileQ看看我们书写的命o是执行v来是什么样子的或是什么顺序的?
而make参数“-s”?#8220;--slient”则是全面止命o的显C?
二、命令执?
当依赖目标新于目标时Q也是当规则的目标需要被更新Ӟmake会一条一条的执行其后的命令。需要注意的是，如果你要让上一条命令的l果应用在下一条命令时Q你应该使用分号分隔q两条命令。比如你的第一条命令是cd命oQ你希望W二条命令得在cd之后的基上运行，那么你就不能把这两条命o写在两行上，而应该把q两条命令写在一行上Q用分号分隔。如Q?
CZ一Q?
exec:
cd /home/hchen
pwd
CZ二：
exec:
cd /home/hchen; pwd
当我们执?#8220;make exec”ӞW一个例子中的cd没有作用Qpwd会打印出当前的Makefile目录Q而第二个例子中，cdpv作用了，pwd会打印出“/home/hchen”?
make一般是使用环境变量SHELL中所定义的系lShell来执行命令，默认情况下用UNIX的标准Shell—?bin/sh来执行命令。但在MS-DOS下有点特D，因ؓMS-DOS下没有SHELL环境变量Q当然你也可以指定。如果你指定了UNIX风格的目录Ş式，首先Qmake会在SHELL所指定的\径中扑֯命o解释器，如果找不刎ͼ其会在当前盘W中的当前目录中LQ如果再找不刎ͼ其会在PATH环境变量中所定义的所有\径中L。MS-DOS中，如果你定义的命o解释器没有找刎ͼ其会l你的命令解释器加上诸如“.exe”?#8220;.com”?#8220;.bat”?#8220;.sh”{后~?
三、命令出?
每当命oq行完后Qmake会检每个命令的q回码，如果命oq回成功Q那么make会执行下一条命令，当规则中所有的命o成功q回后，q个规则q是成功完成了。如果一个规则中的某个命令出错了Q命令退出码非零Q，那么make׃l止执行当前规则Q这有可能l止所有规则的执行?
有些时候，命o的出错ƈ不表C就是错误的。例如mkdir命oQ我们一定需要徏立一个目录，如果目录不存在，那么mkdir成功执行，万事大吉Q如果目录存在，那么出错了。我们之所以用mkdir的意思就是一定要有这L一个目录，于是我们׃希望mkdir出错而终止规则的q行?
Z做到q一点，忽略命o的出错，我们可以在Makefile的命令行前加一个减?#8220;-”Q在Tab键之后）Q标Cؓ不管命oZ出错都认为是成功的。如Q?
clean:
-rm -f *.o
q有一个全局的办法是Q给make加上“-i”或是“--ignore-errors”参数Q那么，Makefile中所有命令都会忽略错误。而如果一个规则是?#8220;.IGNORE”作ؓ目标的，那么q个规则中的所有命令将会忽略错误。这些是不同U别的防止命令出错的ҎQ你可以Ҏ你的不同喜欢讄?
q有一个要提一下的make的参数的?#8220;-k”或是“--keep-going”Q这个参数的意思是Q如果某规则中的命o出错了，那么q目该规则的执行，但l执行其它规则?
]]>
在Makefile中，我们的依赖关pd能会需要包含一pd的头文gQ比如，如果我们的main.c中有一?#8220;#include "defs.h"”Q那么我们的依赖关系应该是：
main.o : main.c defs.h
但是Q如果是一个比较大型的工程Q你必需清楚哪些C文g包含了哪些头文gQƈ且，你在加入或删除头文gӞ也需要小心地修改MakefileQ这是一个很没有l护性的工作。ؓ了避免这U繁重而又Ҏ出错的事情，我们可以使用C/C++~译的一个功能。大多数的C/C++~译器都支持一?#8220;-M”的选项Q即自动扑֯源文件中包含的头文gQƈ生成一个依赖关pR例如，如果我们执行下面的命令：
cc -M main.c
其输出是Q?
main.o : main.c defs.h
于是q译器自动生成的依赖关p，q样一来，你就不必再手动书写若q文件的依赖关系Q而由~译器自动生成了。需要提醒一句的是，如果你用GNU的C/C++~译器，你得?#8220;-MM”参数Q不Ӟ“-M”参数会把一些标准库的头文g也包含进来?
gcc -M main.c的输出是Q?
main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h \
/usr/include/sys/cdefs.h /usr/include/gnu/stubs.h \
/usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h \
/usr/include/bits/types.h /usr/include/bits/pthreadtypes.h \
/usr/include/bits/sched.h /usr/include/libio.h \
/usr/include/_G_config.h /usr/include/wchar.h \
/usr/include/bits/wchar.h /usr/include/gconv.h \
/usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h \
/usr/include/bits/stdio_lim.h
gcc -MM main.c的输出则是：
main.o: main.c defs.h
那么Q编译器的这个功能如何与我们的Makefile联系在一起呢。因样一来，我们的Makefile也要Ҏq些源文仉新生成，让Makefile自已依赖于源文gQ这个功能ƈ不现实，不过我们可以有其它手D|q回地实现这一功能。GNUl织把编译器为每一个源文g的自动生成的依赖关系攑ֈ一个文件中Qؓ每一?#8220;name.c”的文仉生成一?#8220;name.d”的Makefile文gQ[.d]文g中就存放对应[.c]文g的依赖关pR?
于是Q我们可以写出[.c]文g和[.d]文g的依赖关p，q让make自动更新或自成[.d]文gQƈ把其包含在我们的主Makefile中，q样Q我们就可以自动化地生成每个文g的依赖关pM?
q里Q我们给Z一个模式规则来产生[.d]文gQ?
%.d: %.c
@set -e; rm -f $@; \
$(CC) -M $(CPPFLAGS) $< >; $@.$$$$; \
sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ >; $@; \
rm -f $@.$$$$
q个规则的意思是Q所有的[.d]文g依赖于[.c]文gQ?#8220;rm -f $@”的意思是删除所有的目标Q也是[.d]文gQ第二行的意思是Qؓ每个依赖文g“$<”Q也是[.c]文g生成依赖文gQ?#8220;$@”表示模式“%.d”文gQ如果有一个C文g是name.cQ那?#8220;%”是“name”Q?#8220;$$$$”意ؓ一个随机编PW二行生成的文g有可能是“name.d.12345”Q第三行使用sed命o做了一个替换，关于sed命o的用法请参看相关的用文档。第四行是删除临时文g?
总而言之，q个模式要做的事是在编译器生成的依赖关pM加入[.d]文g的依赖，x依赖关系Q?
main.o : main.c defs.h
转成Q?
main.o main.d : main.c defs.h
于是Q我们的[.d]文g也会自动更新了，q会自动生成了，当然Q你q可以在q个[.d]文g中加入的不只是依赖关p，包括生成的命令也可一q加入，让每个[.d]文g都包含一个完赖的规则。一旦我们完成这个工作，接下来，我们p把这些自动生成的规则放进我们的主Makefile中。我们可以用Makefile?#8220;include”命oQ来引入别的Makefile文gQ前面讲q）Q例如：
sources = foo.c bar.c
include $(sources:.c=.d)
上述语句中的“$(sources:.c=.d)”中的“.c=.d”的意思是做一个替换，把变?(sources)所有[.c]的字串都替换成[.d]Q关于这?#8220;替换”的内容，在后面我会有更ؓ详细的讲q。当Ӟ你得注意ơ序Q因为include是按ơ来载入文gQ最先蝲入的[.d]文g中的目标会成为默认目标?br>
]]>
Makefile的规则中的目标可以不止一个，其支持多目标Q有可能我们的多个目标同时依赖于一个文Ӟq且其生成的命o大体cM。于是我们就能把其合qv来。当Ӟ多个目标的生成规则的执行命o是同一个，q可能会可我们带来麻烦，不过好在我们的可以用一个自动化变量“$@”Q关于自动化变量Q将在后面讲qͼQ这个变量表C着目前规则中所有的目标的集合，q样说可能很抽象Q还是看一个例子吧?
bigoutput littleoutput : text.g
generate text.g -$(subst output,,$@) >; $@
上述规则{h于：
bigoutput : text.g
generate text.g -big >; bigoutput
littleoutput : text.g
generate text.g -little >; littleoutput
其中Q?$(subst output,,$@)中的“$”表示执行一个Makefile的函敎ͼ函数名ؓsubstQ后面的为参数。关于函敎ͼ在后面讲述。这里的q个函数是截取字W串的意思，“$@”表示目标的集合，像一个数l，“$@”依次取出目标Qƈ执于命o?
七、静态模?
静态模式可以更加容易地定义多目标的规则Q可以让我们的规则变得更加的有弹性和灉|。我们还是先来看一下语法：
<targets ...>;: <target-pattern>;: <prereq-patterns ...>;
<commands>;
...
targets定义了一pd的目标文Ӟ可以有通配W。是目标的一个集合?
target-parrtern是指明了targets的模式，也就是的目标集模式?
prereq-parrterns是目标的依赖模式Q它对target-parrtern形成的模式再q行一ơ依赖目标的定义?
q样描述q三个东西，可能q是没有说清楚，q是举个例子来说明一下吧。如果我们的<target-parrtern>;定义?#8220;%.o”Q意思是我们?lt;target>;集合中都是以“.o”l尾的，而如果我们的<prereq-parrterns>;定义?#8220;%.c”Q意思是?lt;target-parrtern>;所形成的目标集q行二次定义Q其计算Ҏ是，?lt;target-parrtern>;模式中的“%”Q也是L了[.o]q个l尾Q，qؓ其加上[.c]q个l尾QŞ成的新集合?
所以，我们?#8220;目标模式”或是“依赖模式”中都应该?#8220;%”q个字符Q如果你的文件名中有“%”那么你可以用反斜杠“\”q行转义Q来标明真实?#8220;%”字符?
看一个例子：
objects = foo.o bar.o
all: $(objects)
$(objects): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
上面的例子中Q指明了我们的目标从$object中获取，“%.o”表明要所有以“.o”l尾的目标，也就?#8220;foo.o bar.o”Q也是变量$object集合的模式，而依赖模?#8220;%.c”则取模式“%.o”?#8220;%”Q也是“foo bar”Qƈ为其加下“.c”的后~Q于是，我们的依赖目标就?#8220;foo.c bar.c”。而命令中?#8220;$<”?#8220;$@”则是自动化变量，“$<”表示所有的依赖目标集（也就?#8220;foo.c bar.c”Q，“$@”表示目标集（也就?#8220;foo.o bar.o”Q。于是，上面的规则展开后等价于下面的规则：
foo.o : foo.c
$(CC) -c $(CFLAGS) foo.c -o foo.o
bar.o : bar.c
$(CC) -c $(CFLAGS) bar.c -o bar.o
试想Q如果我们的“%.o”有几百个Q那U我们只要用q种很简单的“静态模式规?#8221;可以写完一堆规则，实在是太有效率了?#8220;静态模式规?#8221;的用法很灉|Q如果用得好Q那会一个很强大的功能。再看一个例子：
files = foo.elc bar.o lose.o
$(filter %.o,$(files)): %.o: %.c
$(CC) -c $(CFLAGS) $< -o $@
$(filter %.elc,$(files)): %.elc: %.el
emacs -f batch-byte-compile $<
$(filter %.o,$(files))表示调用Makefile的filter函数Q过?#8220;$filter”集，只要其中模式?#8220;%.o”的内宏V其的它内容Q我׃用多说了吧。这个例字展CZMakefile中更大的Ҏ?
]]>
在一些大的工E中Q有大量的源文gQ我们通常的做法是把这许多的源文g分类Qƈ存放在不同的目录中。所以，当make需要去扑֯文g的依赖关pLQ你可以在文件前加上路径Q但最好的Ҏ是把一个\径告诉makeQ让make在自动去找?
Makefile文g中的Ҏ变量“VPATH”是完成q个功能的，如果没有指明q个变量Qmake只会在当前的目录中去扑֯依赖文g和目标文件。如果定义了q个变量Q那么，make׃在当当前目录找不到的情况下，到所指定的目录中LL件了?
VPATH = src:../headers
上面的的定义指定两个目录Q?#8220;src”?#8220;../headers”Qmake会按照这个顺序进行搜索。目录由“冒号”分隔。（当然Q当前目录永q是最高优先搜索的地方Q?
另一个设|文件搜索\径的Ҏ是用make?#8220;vpath”关键字（注意Q它是全写的）Q这不是变量Q这是一个make的关键字Q这和上面提到的那个VPATH变量很类|但是它更为灵zR它可以指定不同的文件在不同的搜索目录中。这是一个很灉|的功能。它的用方法有三种Q?
1、vpath <pattern>; <directories>;
为符合模?lt;pattern>;的文件指定搜索目?lt;directories>;?
2、vpath <pattern>;
清除W合模式<pattern>;的文件的搜烦目录?
3、vpath
清除所有已被设|好了的文g搜烦目录?
vapth使用Ҏ中的<pattern>;需要包?#8220;%”字符?#8220;%”的意思是匚w零或若干字符Q例如，“%.h”表示所有以“.h”l尾的文件?lt;pattern>;指定了要搜烦的文仉Q?lt;directories>;则指定了<pattern>;的文仉的搜索的目录。例如：
vpath %.h ../headers
该语句表C，要求make?#8220;../headers”目录下搜索所有以“.h”l尾的文件。（如果某文件在当前目录没有扑ֈ的话Q?
我们可以q箋C用vpath语句Q以指定不同搜烦{略。如果连l的vpath语句中出C相同?lt;pattern>;Q或是被重复了的<pattern>;Q那么，make会按照vpath语句的先后顺序来执行搜烦。如Q?
vpath %.c foo
vpath % blish
vpath %.c bar
其表C?#8220;.c”l尾的文Ӟ先在“foo”目录Q然后是“blish”Q最后是“bar”目录?
vpath %.c foo:bar
vpath % blish
而上面的语句则表C?#8220;.c”l尾的文Ӟ先在“foo”目录Q然后是“bar”目录Q最后才?#8220;blish”目录?
]]>
最早先的一个例子中Q我们提到过一?#8220;clean”的目标，q是一?#8220;伪目?#8221;Q?
clean:
rm *.o temp
正像我们前面例子中的“clean”一P即然我们生成了许多文件编译文Ӟ我们也应该提供一个清除它们的“目标”以备完整地重~译而用?nbsp;Q以“make clean”来用该目标Q?
因ؓQ我们ƈ不生?#8220;clean”q个文g?#8220;伪目?#8221;q不是一个文Ӟ只是一个标{，׃“伪目?#8221;不是文gQ所以make无法生成它的依赖关系和决定它是否要执行。我们只有通过昄地指明这?#8220;目标”才能让其生效。当Ӟ“伪目?#8221;的取名不能和文g名重名，不然其就失去?#8220;伪目?#8221;的意义了?
当然Qؓ了避免和文g重名的这U情况，我们可以使用一个特D的标记“.PHONY”来显C地指明一个目标是“伪目?#8221;Q向make说明Q不是否有q个文gQ这个目标就?#8220;伪目?#8221;?
.PHONY : clean
只要有这个声明，不管是否?#8220;clean”文gQ要q行“clean”q个目标Q只?#8220;make clean”q样。于是整个过E可以这样写Q?
.PHONY: clean
clean:
rm *.o temp
伪目标一般没有依赖的文g。但是，我们也可以ؓ伪目标指定所依赖的文件。伪目标同样可以作ؓ“默认目标”Q只要将其放在第一个。一个示例就是，如果你的Makefile需要一口气生成若干个可执行文gQ但你只想简单地敲一个make完事Qƈ且，所有的目标文g都写在一个Makefile中，那么你可以?#8220;伪目?#8221;q个Ҏ：
all : prog1 prog2 prog3
.PHONY : all
prog1 : prog1.o utils.o
cc -o prog1 prog1.o utils.o
prog2 : prog2.o
cc -o prog2 prog2.o
prog3 : prog3.o sort.o utils.o
cc -o prog3 prog3.o sort.o utils.o
我们知道QMakefile中的W一个目标会被作为其默认目标。我们声明了一?#8220;all”的伪目标Q其依赖于其它三个目标。由于伪目标的特性是QL被执行的Q所以其依赖的那三个目标L不如“all”q个目标新。所以，其它三个目标的规则L会被册。也pC我们一口气生成多个目标的目的?#8220;.PHONY : all”声明?#8220;all”q个目标?#8220;伪目?#8221;?
随便提一句，从上面的例子我们可以看出Q目标也可以成ؓ依赖。所以，伪目标同样也可成Z赖。看下面的例子：
.PHONY: cleanall cleanobj cleandiff
cleanall : cleanobj cleandiff
rm program
cleanobj :
rm *.o
cleandiff :
rm *.diff
“make clean”清除所有要被清除的文g?#8220;cleanobj”?#8220;cleandiff”q两个伪目标有点?#8220;子程?#8221;的意思。我们可以输?#8220;make cleanall”?#8220;make cleanobj”?#8220;make cleandiff”命o来达到清除不同种cL件的目的?br>
]]>
在上面的例子中，先让我们看看edit的规则：
edit : main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
cc -o edit main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
我们可以看到[.o]文g的字W串被重复了两次Q如果我们的工程需要加入一个新的[.o]文gQ那么我们需要在两个地方加（应该是三个地方，q有一个地方在clean中）。当Ӟ我们的makefileq不复杂Q所以在两个地方加也不篏Q但如果makefile变得复杂Q那么我们就有可能会忘掉一个需要加入的地方Q而导致编译失败。所以，Zmakefile的易l护Q在makefile中我们可以用变量。makefile的变量也是一个字W串Q理解成C语言中的宏可能会更好?
比如Q我们声明一个变量，叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJQ反正不什么啦Q只要能够表Cobj文gp了。我们在makefile一开始就q样定义Q?
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
于是Q我们就可以很方便地在我们的makefile中以“$(objects)”的方式来使用q个变量了，于是我们的改良版makefile变成下面这个样子：
objects = main.o kbd.o command.o display.o \
insert.o search.o files.o utils.o
edit : $(objects)
cc -o edit $(objects)
main.o : main.c defs.h
cc -c main.c
kbd.o : kbd.c defs.h command.h
cc -c kbd.c
command.o : command.c defs.h command.h
cc -c command.c
display.o : display.c defs.h buffer.h
cc -c display.c
insert.o : insert.c defs.h buffer.h
cc -c insert.c
search.o : search.c defs.h buffer.h
cc -c search.c
files.o : files.c defs.h buffer.h command.h
cc -c files.c
utils.o : utils.c defs.h
cc -c utils.c
clean :
rm edit $(objects)
于是如果有新?nbsp;.o 文g加入Q我们只需单地修改一?nbsp;objects 变量可以了?
关于变量更多的话题，我会在后l给你一一道来?
]]>
概述
—?
什么是makefileQ或许很多Winodws的程序员都不知道q个东西Q因为那些Windows的IDE都ؓ你做了这个工作，但我觉得要作一个好的和professional的程序员Qmakefileq是要懂。这好像现在有q么多的HTML的编辑器Q但如果你想成ؓ一个专业h士，你还是要了解HTML的标识的含义。特别在Unix下的软g~译Q你׃能不自己写makefile了，会不会写makefileQ从一个侧面说明了一个h是否具备完成大型工程的能力?
因ؓQmakefile关系C整个工程的编译规则。一个工E中的源文g不计敎ͼ其按cd、功能、模块分别放在若q个目录中，makefile定义了一pd的规则来指定Q哪些文仉要先~译Q哪些文仉要后~译Q哪些文仉要重新编译，甚至于进行更复杂的功能操作，因ؓmakefile像一个Shell脚本一P其中也可以执行操作系l的命o?
makefile带来的好处就是—?#8220;自动化编?#8221;Q一旦写好，只需要一个make命oQ整个工E完全自动编译，极大的提高了软g开发的效率。make是一个命令工P是一个解释makefile中指令的命o工具Q一般来_大多数的IDE都有q个命oQ比如：Delphi的makeQVisual C++的nmakeQLinux下GNU的make。可见，makefile都成Z一U在工程斚w的编译方法?
现在讲述如何写makefile的文章比较少Q这是我惛_q篇文章的原因。当Ӟ不同产商的make各不相同Q也有不同的语法Q但其本质都是在“文g依赖?#8221;上做文章Q这里，我仅对GNU的makeq行讲述Q我的环境是RedHat Linux 8.0Qmake的版本是3.80。必竟，q个make是应用最为广泛的Q也是用得最多的。而且其还是最遵@于IEEE 1003.2-1992 标准的（POSIX.2Q?
在这文档中Q将以C/C++的源码作为我们基Q所以必然涉及一些关于C/C++的编译的知识Q相关于q方面的内容Q还请各位查看相关的~译器的文档。这里所默认的编译器是UNIX下的GCC和CC?
关于E序的编译和链接
—————————?
在此Q我惛_说关于程序编译的一些规范和ҎQ一般来_无论是C、C++、还是pasQ首先要把源文g~译成中间代码文Ӟ在Windows下也是 .obj 文gQUNIX下是 .o 文gQ即 Object FileQ这个动作叫做编译（compileQ。然后再把大量的Object File合成执行文gQ这个动作叫作链接（linkQ?
~译Ӟ~译器需要的是语法的正确Q函C变量的声明的正确。对于后者，通常是你需要告诉编译器头文件的所在位|（头文件中应该只是声明Q而定义应该放在C/C++文g中）Q只要所有的语法正确Q编译器可以编译出中间目标文g。一般来_每个源文仉应该对应于一个中间目标文ӞO文g或是OBJ文gQ?
链接Ӟ主要是链接函数和全局变量Q所以，我们可以使用q些中间目标文gQO文g或是OBJ文gQ来链接我们的应用程序。链接器q不函数所在的源文Ӟ只管函数的中间目标文ӞObject FileQ，在大多数时候，׃源文件太多，~译生成的中间目标文件太多，而在链接旉要明昑֜指出中间目标文g名，q对于编译很不方便，所以，我们要给中间目标文g打个包，在Windows下这U包?#8220;库文?#8221;QLibrary File)Q也是 .lib 文gQ在UNIX下，是Archive FileQ也是 .a 文g?
ȝ一下，源文仉先会生成中间目标文gQ再׃间目标文件生成执行文件。在~译Ӟ~译器只程序语法，和函数、变量是否被声明。如果函数未被声明，~译器会l出一个警告，但可以生成Object File。而在链接E序Ӟ链接器会在所有的Object File中找d数的实现Q如果找不到Q那到就会报链接错误码（Linker ErrorQ，在VC下，q种错误一般是QLink 2001错误Q意思说是说Q链接器未能扑ֈ函数的实现。你需要指定函数的Object File.
好，a归正传，GNU的make有许多的内容Q闲a叙Q还是让我们开始吧?
]]>
所以学习多U程~程最重要的不是学习API,而是理解什么才是多U程安全的代?br />
从例子说?br />
#include <windows.h>
#include <process.h>
long global1 = 0;
volatile long global2 = 0;
class MyClass
{
public:
MyClass() : m(0)
{
++m;
}
int fun(int v)
{
return m+v; //-----------9
}
void set(int v)
{
m = v; //-------------10
}
int m;
};
MyClass global_object; //-------------8
unsigned int __stdcall thread_fun1(void *param)
{
static int static2 = 0;
static MyClass static_object; //--------6
int local1 = 0;
++local1; //-------1
++static2; //-------2
++global1; //-------3
++global2; //-------4
InterlockedIncrement(&global1); //--------5
local1 = global_object.fun(local1); //----------7
global_object.set(local1); //---------------11
return 0;
}
unsigned int __stdcall thread_fun2(void *param)
{
++global1; //-------3
++global2; //-------4
InterlockedIncrement(&global1); //--------5
global_object.set(1); //-----------11
return 0;
}
int main()
{
HANDLE thread1 = (HANDLE)_beginthreadex(0,0,&thread_fun1,0,0,0); //thread 1
HANDLE thread2 = (HANDLE)_beginthreadex(0,0,&thread_fun1,0,0,0); //thread 2
HANDLE thread3 = (HANDLE)_beginthreadex(0,0,&thread_fun2,0,0,0); //thread 3
WaitForSingleObject(thread1,INFINITE);
WaitForSingleObject(thread2,INFINITE);
WaitForSingleObject(thread3,INFINITE);
return 0;
}
#include <process.h>
long global1 = 0;
volatile long global2 = 0;
class MyClass
{
public:
MyClass() : m(0)
{
++m;
}
int fun(int v)
{
return m+v; //-----------9
}
void set(int v)
{
m = v; //-------------10
}
int m;
};
MyClass global_object; //-------------8
unsigned int __stdcall thread_fun1(void *param)
{
static int static2 = 0;
static MyClass static_object; //--------6
int local1 = 0;
++local1; //-------1
++static2; //-------2
++global1; //-------3
++global2; //-------4
InterlockedIncrement(&global1); //--------5
local1 = global_object.fun(local1); //----------7
global_object.set(local1); //---------------11
return 0;
}
unsigned int __stdcall thread_fun2(void *param)
{
++global1; //-------3
++global2; //-------4
InterlockedIncrement(&global1); //--------5
global_object.set(1); //-----------11
return 0;
}
int main()
{
HANDLE thread1 = (HANDLE)_beginthreadex(0,0,&thread_fun1,0,0,0); //thread 1
HANDLE thread2 = (HANDLE)_beginthreadex(0,0,&thread_fun1,0,0,0); //thread 2
HANDLE thread3 = (HANDLE)_beginthreadex(0,0,&thread_fun2,0,0,0); //thread 3
WaitForSingleObject(thread1,INFINITE);
WaitForSingleObject(thread2,INFINITE);
WaitForSingleObject(thread3,INFINITE);
return 0;
}
1.局部变量局部用是安全?br />Z?因ؓ每个thread 都有自己的运行堆栈，而局部变量是生存在堆栈中,大家不干扰?br />所以代?
int local1;
++local1;
是安全的
2.全局原生变量多线E读写是不安全的
全局变量是在?heap)?br />long global1 = 0;
++global2;
++q个操作其实分ؓ两部Q一个是读，另外一个是?br /> mov ecx,global
add ecx,1
mov global,ecx
所以代?处是不安全的
3.函数静态变量多U程d也是不安全的
道理?
所以代?处也是不安全?br />
4.volatile能保证全局整Ş变量是多U程安全的么
不能?br />volatile仅仅是告诫compiler不要对这个变量作优化Q每ơ都要从memory取数|而不是从register
所以代?也不是安?br />
5.InterlockedIncrement保证整型变量自增的原子?/strong>
所以代?是安全的
6.function static object的初始化是多U程安全的么
不是?br />著名的Meyer Singleton其实不是U程安全?br />Object & getInstance()
{
static Object o;
return o;
}
可能会造成多次初始化对?br />所以代?处是不安全的
7.?2机器上，4字节整Ş一ơassign是原子的
比如
i =10; //thread1
i=4; //thread2
不会Di的值处于未知状?要么?0要么?
写好多线E安全的法宝是装Q数据有保护的被访问到
安全性：
局部变?gt;成员变量>全局变量
]]>
我们q是先来看一D늮单的E序Q?br />
E序一
1 #include <iostream>
2 using namespace std;
3
4 struct X1
5 {
6 int i;//4个字?/span>
7 char c1;//1个字?/span>
8 char c2;//1个字?/span>
9 };
10
11 struct X2
12 {
13 char c1;//1个字?/span>
14 int i;//4个字?/span>
15 char c2;//1个字?/span>
16 };
17
18 struct X3
19 {
20 char c1;//1个字?/span>
21 char c2;//1个字?/span>
22 int i;//4个字?/span>
23 };
24 int main()
25 {
26 cout<<"long "<<sizeof(long)<<"\n";
27 cout<<"float "<<sizeof(float)<<"\n";
28 cout<<"int "<<sizeof(int)<<"\n";
29 cout<<"char "<<sizeof(char)<<"\n";
30
31 X1 x1;
32 X2 x2;
33 X3 x3;
34 cout<<"x1 的大?/span>"<<sizeof(x1)<<"\n";
35 cout<<"x2 的大?/span>"<<sizeof(x2)<<"\n";
36 cout<<"x3 的大?/span>"<<sizeof(x3)<<"\n";
37 return 0;
38 }
2 using namespace std;
3
4 struct X1
5 {
6 int i;//4个字?/span>
7 char c1;//1个字?/span>
8 char c2;//1个字?/span>
9 };
10
11 struct X2
12 {
13 char c1;//1个字?/span>
14 int i;//4个字?/span>
15 char c2;//1个字?/span>
16 };
17
18 struct X3
19 {
20 char c1;//1个字?/span>
21 char c2;//1个字?/span>
22 int i;//4个字?/span>
23 };
24 int main()
25 {
26 cout<<"long "<<sizeof(long)<<"\n";
27 cout<<"float "<<sizeof(float)<<"\n";
28 cout<<"int "<<sizeof(int)<<"\n";
29 cout<<"char "<<sizeof(char)<<"\n";
30
31 X1 x1;
32 X2 x2;
33 X3 x3;
34 cout<<"x1 的大?/span>"<<sizeof(x1)<<"\n";
35 cout<<"x2 的大?/span>"<<sizeof(x2)<<"\n";
36 cout<<"x3 的大?/span>"<<sizeof(x3)<<"\n";
37 return 0;
38 }
q段E序的功能很单，是定义了三个结构X1,X2,X3,q三个结构的主要区别是内存数据摆放的顺序，其他都是一LQ另外程序输入了几种基本cd所占用的字节数Q以及我们这里的三个l构所占用的字节数?br />
q段E序的运行结果ؓQ?br />
1 long 4
2 float 4
3 int 4
4 char 1
5 x1 的大?/span>8
6 x2 的大?/span>12
7 x3 的大?/span>8
2 float 4
3 int 4
4 char 1
5 x1 的大?/span>8
6 x2 的大?/span>12
7 x3 的大?/span>8
l果的前面四行没有什么问题，但是我们在最后三行就可以看到三个l构占用的空间大不一P造成q个原因是内部数据的摆N序，怎么会这样呢Q?br />
下面是我们需要讲的内存对齐了?br />
内存是一个连l的块，我们可以用下面的图来表示, 它是?个字节对一个对齐单位的Q?br />
图一
让我们看看三个结构在内存中的布局Q?br />
首先?X1Q如下图所C?br />
X1 中第一个是 IntcdQ它占有4字节Q所以前?格就是满了，然后W二个是charcdQ这中类型只占一个字节，所以它占有了第二个4字节l块中的W一|W三个也是charcdQ所以它也占用一个字节，它就排在了第二个l块的第二格Q因为它们加在一起大也不超q一个块Q所以他们三个变量在内存中的l构是q样的，因ؓ有内存分块对齐，所以最后出来的l果?Q而不?Q因为后面两个格子其实也是被用了?br />
再次看看X2Q如图所C?br />
X2中第一个类型是CharcdQ它占用一个字节，所以它首先排在W一l块的第一个格子里面，W二个是IntcdQ它占用4个字节，W一l块已经用掉一|q剩3|肯定是无法放下第二Intcd的，因ؓ要考虑到对齐，所以不得不把它攑ֈW二个组块，W三个类型是CharcdQ跟W一个类伹{所因ؓ有内存分块对齐，我们的内存就不是8个格子了Q而是12个了?br />
再看看X3Q如下图所C：
关于X3的说明其实跟X1是类似的Q只不过它把两个1个字节的攑ֈ了前面，怿看了前面两种情况的说明这里也是很Ҏ理解的?br />
]]>