今天写VOB Demux的时候，demux产生的音视频文件播放不了。经过调试发现解析过程全都能正确鸡西，但是将结果写入之后就出错。最后发现是fwrite在搞鬼，如果文件以文本模式打开，它会将buf中所有“回车”转换为“回车+换行”。顺便学习一下文本模式和二进制模式打开文件的区别。

 

 

 

在學習C語言文件操作後，我們都會知道打開文件的函數是fopen，也知道它的第二個參數是標誌字符串。其中，如果字符串中出現'b'，則表明是以打開二進制(binary)文件，否則是打開文本文件。

　　那麼甚麼是文本文件，甚麼是二進制文件呢? 可能大多數人都沒有仔細考慮過。

　　在Windows和DOS系統中，狹義的文本文件是指擴展名為txt的文件。實際上，那些沒有規定格式的，由可理解的的ASCII以及其他編碼文字組成的文件都是文本文件，如C源程序文件，HTML超文本，XML。除此之外的其他文件都是二進制文件，如Word文件DOC，圖像格式文件JPG。

　　但是，所謂使用fopen標誌打開文本文件與二進制文件的說法並不準確。正確的說法應該是－－以文本方式和二進制方式打開文件。因為我們用兩種方式都可以任意的文件。

　　即使這樣，為甚麼還要區分這兩種方式呢?

　　這是因為這兩種方式在讀寫文件時的操作是不一樣的。

　　二進制方式很簡單，讀文件時，會原封不動的讀出文件的全部內容，寫的時候，也是把內存緩衝區的內容原封不動的寫到文件中。

　　而文本方式就不一樣了，在讀文件時，會將換行符號CRLF(0x0D 0x0A)全部轉換成單個的0x0A，並且當遇到結束符CTRLZ(0x1A)時，就認為文件已經結束。相應的，寫文件時，會將所有的0x0A換成0x0D0x0A。

　　所以，若使用文本方式打開二進制文件時，就很容易出現文件讀不完整，或內容不對的錯誤。即使是用文本方式打開文本文件，也要謹慎使用，比如複製文件，就不應該使用文本方式。

　　要特別注意的是，上面這樣的說法僅適用于DOS和Windows系統。在Unix和其他一些系統中，沒有文本方式和二進制方式的區分，使不使用'b'標誌都是一樣的。這是由于不同操作系統對文本文件換行符的定義，和C語言中換行符的定義有所不同而造成的。

　　如上文已提到，DOS和Windows系統使用CRLF(0x0D 0x0A)雙字節作為文本文件換行符，而Unix文本文件的換行符只有一個字節LF(0x0A)為。在C語言中，也是以LF即'\n'為換行符。

　　由於DOS/Windows定義的換行符和C語言的不一致，C語言的標準輸入輸出函數進行讀寫文本文件時，就進行了CRLF->LF的轉換。而Unix的定義和C語言的是一樣的，就不必轉換了。

　　那麼，為甚麼會有定義不一致的情況呢，這純屬歷史原因。當初C是在Unix上發展的，對換行的定義自然就一樣了。其後C被引入到DOS系統，為了使原有的C程序能不加修改的讀寫DOS的文本文件，所以就在文件讀寫上做了修改。隨著DOS/Windows成為主流平台，這個當初為了兼容而做的修改給眾多的C語言開發者添了這樣一個小小的麻煩。

Where Are We Heading 我们将走向何方

(2005-04-26 09:24:57)

 

 

 

 

 

The paradox of our time in history is that we have taller buildings, but shorter tempers; wider freeways, but narrower viewpoints; we s pend more, but have less; we buy more but enjoy less.

　　我们这个时代在历史上的说法就是我们拥有更高的建筑，但是有更暴的脾气；我们拥有更宽阔的高速公路，却有更狭隘的观点；我们花费得更多，拥有得却更少；我们购买得更多却享受得更少。

　　We have bigger houses and smaller families; more conveniences, but less time; we have more degrees, but less sense; more knowledge, but less judgment; more experts, but more problems; more medicine, but less wellness.

　　我们的房子越来越大，家庭却越来越小；便利越来越多，时间却越来越少；学位越来越多，感觉却越来越少；知识越来越多，观点却越来越少；专家越来越多，问题也越来越多；药物越来越多，福利却越来越少。

　　We drink too much, spend too recklessly, laugh too little, drive too fast, get too angry too quickly, stay up too late, get up too tired, read too little, watch TV too much, and pray too seldom.

　　我们喝得太多，花钱大手大脚，笑得太少，开车太快，易怒，熬夜，赖床，书读得越来越少，电视看得越来越多，却很少向上帝祈祷。

　　We talk too much, love too seldom, and hate too often. We've learned how to make a living, but not a life; we've added years to life, not life to years.

　　我们常常夸夸其谈，却很少付出爱心，且常常心中充满了仇恨。我们学会了如何谋生，而不知如何生活。我们延长了生命的期限，而不是生活的期限。

　　We've been all the way to the moon and back, but have trouble crossing the street to meet the new neighbor. We've conquered outer space, but not inner space; we've done larger things, but not better things.

　　我们登上了月球，并成功返回，却不能穿过街道去拜访新邻居。我们已经征服了太空，却征服不了自己的内心；我们的事业越做越大，但质量却没有提高。

　　We've cleaned up the air, but polluted the soul; we've split the atom, but not our prejudice. We write more, but learn less; we plan more, but accomplish less.

　　我们清洁了空气，却污染了灵魂；我们分离了原子，却无法驱除我们的偏见；我们写得更多，学到的却更少；我们的计划更多，完成的却更少。

　　We've learned to rush, but not to wait; we have higher incomes, but, lower morals.

　　我们学会了奔跑，却忘记了如何等待；我们的收入越来越高，道德水平却越来越低。

　　We build more computers to hold more information to produce more copies than ever, but have less communication; we've become long on quantity, but short on quality.

　　我们制造了更多的计算机来存储更多的信息，制造了最多的副本，却减少了交流；我们开始渴望数量，但忽视了质量。

　　These are the days of two incomes, but more divorce; of fancier houses, but more broken homes.

　　这个时代有双收入，但也有了更高的离婚率；有更华丽的房屋，却有更多破碎的家庭。

　　These are the days of quick trips, disposable diapers, throw away morality, one night stands, overweight bodies, and pills that do everything from cheer, to quiet, to kill. Where are we heading...?

　　这个时代有了快速旅游，免洗尿布，却抛弃了道德、一夜情、超重的身体，以及可以从快乐中走向静止和自杀的药物。我们将走向何方……？

　　If we die tomorrow, the company that we are working for could easily replace us in a matter of days. But the family we left behind will feel the loss for the rest of their lives.

　　如果我们明天就死掉，我们为之工作的公司可能会在一天内很轻易地找人代替我们的位置。但是当我们离开家人后，他们的余生将会在失落中度过。

　　And come to think of it, we pour ourselves more into work than to our family an unwise investment indeed.

　　考虑一下吧，我们将自己的时间更多地投入到工作中，而放弃与家人在一起的时光，实在并非明智之举。

　　So what is the morale of the story???

　　那么这则故事的主旨是什么呢???

　　Don't work too hard... and you know what's the full word of family?

　　不要工作得太辛苦，你知道家的全称吗？

　　FAMILY = (F)ATHER (A)ND (M)OTHER, (I) (L)OVE (Y)OU.

　　家＝爸爸妈妈，我爱你们。 

每天上下班要登陆公司内部系统打卡，很麻烦。

准备用python做个开关机自动打卡的小工具。

周末总是很快，还没眨眼就完了:)

周六买了个浮力森林的8寸蛋糕，再买了螃蟹、虾若干，跟女朋友和她表妹一起庆祝俺25小寿。偶发现原来浮力森林蛋糕也就那样，不过她两个一边喊着减肥、一边说真好吃。接着他表妹说了句经典的话：“女人的嘴巴有两个用处!一是吃东西,二是说别人的闲话!”，想想还真是非常有道理啊。

　记得那是来公司的第二个星期四的早上，那天坐在座位上突然感觉右下腹隐隐的疼了两下。那个疼跟去年在西安诊断出来是阑尾炎时的疼一样，感觉很不好。果然没过一会疼痛加剧，突然之间两眼一黑什么都看不见了。过了一下能看清东西的时候，感觉自己失意了一样，不知道自己在哪里、在干吗。就这种状态持续了将近半分钟，才回复意识，于是马上告诉旁边的同事。之后导师和哪位同事一起送我到最近的医院。
    在医院检查的时候我先告诉医生可能是阑尾炎复发，结果医生检查之后告诉我绝对不是阑尾炎。于是很庆兴当时武警医院叫我做阑尾手术时，在自己的坚持下没做。同时也对武警医院的不负责任感到愤慨和无奈。不过不幸的是那天在医院之后腹部就不是那么疼了，以至于花了３００检查之后没有任何结果，医生只好告知“你没问题，可以回去了”。后来自己怀疑可能是急性肠胃炎，或是肠抽筋。反正到现在也不知到是什么原因：（

　经过这事之后，现在开始非常注意身体。一个好的身体真的是需要自己好好努力保养才行。

　说一下我现在的一些行动：睡觉不敢睡太晚，晚饭不敢吃太多，晚上也不敢吃东西，冰的东西基本不吃，不抽烟，少喝酒。准备办个游泳卡，加强身体锻炼。

 

 

 

原文地址：http://blog.csdn.net/nicholasmaxwell/archive/2006/04/20/670120.aspx

c/c++支持可变参数的函数，即函数的参数是不确定的。

一、为什么要使用可变参数的函数？

一般我们编程的时候，函数中形式参数的数目通常是确定的，在调用时要依次给出与形式参数对应的所有实际参数。但在某些情况下希望函数的参数个数可以根据需要确定，因此c语言引入可变参数函数。这也是c功能强大的一个方面，其它某些语言，比如fortran就没有这个功能。

典型的可变参数函数的例子有大家熟悉的printf()、scanf()等。

二、c/c++如何实现可变参数的函数？

为了支持可变参数函数，C语言引入新的调用协议， 即C语言调用约定 __cdecl 。 采用C/C++语言编程的时候，默认使用这个调用约定。如果要采用其它调用约定，必须添加其它关键字声明，例如WIN32 API使用PASCAL调用约定，函数名字之前必须加__stdcall关键字。

采用C调用约定时，函数的参数是从右到左入栈，个数可变。由于函数体不能预先知道传进来的参数个数，因此采用本约定时必须由函数调用者负责堆栈清理。举个例子：

//C调用约定函数
int __cdecl Add(int a, int b)
{
return (a + b);
}

函数调用：
Add(1, 2);
//汇编代码是：
push 2 ;参数b入栈
push 1 ;参数a入栈
call @Add ;调用函数。其实还有编译器用于定位函数的表达式这里把它省略了
add esp,8 ;调用者负责清栈

如果调用函数的时候使用的调用协议和函数原型中声明的不一致，就会导致栈错误，这是另外一个话题，这里不再细说。

另外c/c++编译器采用宏的形式支持可变参数函数。这些宏包括va_start、va_arg和va_end等。之所以这么做，是为了增加程序的可移植性。屏蔽不同的硬件平台造成的差异。

支持可变参数函数的所有宏都定义在stdarg.h 和 varargs.h中。例如标准ANSI形式下，这些宏的定义是：

typedef char * va_list; //字符串指针

#define _INTSIZEOF(n) ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define va_end(ap) ( ap = (va_list)0 )

使用宏_INTSIZEOF是为了按照整数字节对齐指针，因为c调用协议下面，参数入栈都是整数字节（指针或者值）。

三、如何定义这类的函数。

可变参数函数在不同的系统下，采用不同的形式定义。

1、用ANSI标准形式时，参数个数可变的函数的原型声明是：

type funcname(type para1, type para2, …);

关于这个定义，有三点需要说明：

一般来说，这种形式至少需要一个普通的形式参数，可变参数就是通过三个’.'来定义的。所以”…”不表示省略，而是函数原型的一部分。type是函数返回值和形式参数的类型。
例如：

int MyPrintf(char const* fmt, …);

但是，我们也可以这样定义函数：

void MyFunc(…);

但是，这样的话，我们就无法使用函数的参数了，因为无法通过上面所讲的宏来提取每个参数。所以除非你的函数代码中的确没有用到参数表中的任何参数，否则必须在参数表中使用至少一个普通参数。

注意，可变参数只能位于函数参数表的最后。不能这样：

void MyFunc(…, int i);

2、采用与UNIX 兼容系统下的声明方式时，参数个数可变的函数原型是：

type funcname(va_alist);

但是要求函数实现的时候，函数名字后面必须加上va_dcl。例如：

#include
int average( va_list );

void main( void )
{
。。。//代码
}

/* UNIX兼容形式*/
int average( va_alist )
va_dcl
{
。。。//代码
}

这种形式不需要提供任何普通的形式参数。type是函数返回值的类型。va_dcl是对函数原型声明中参数va_alist的详细声明，实际是一个宏定义。根据平台的不同，va_dcl的定义稍有不同。

在varargs.h中，va_dcl的定义后面已经包括了一个分号。因此函数实现的时候，va_dcl后不再需要加上分号了。

3、采用头文件stdarg.h编写的程序是符合ANSI标准的，可以在各种操作系统和硬件上运行；而采用头文件varargs.h的方式仅仅是为了与以前的程序兼容，两种方式的基本原理是一致的，只是在语法形式上有一些细微的区别。 所以一般编程的时候使用stdarg.h。下面的所有例子代码都采用ANSI标准格式。

四、可变参数函数的基本使用方法

下面通过若干例子，说明如何实现可变参数函数的定义和调用。

//================================ 例子程序1 ===============
#include < stdio.h >
#include < string.h >
#include < stdarg.h >

/* 函数原型声明，至少需要一个确定的参数，注意括号内的省略号 */
int demo( char *, … );

void main( void )
{
demo(”DEMO”, “This”, “is”, “a”, “demo!”, “\0″);
}

int demo( char *msg, … )
{
va_list argp; /* 定义保存函数参数的结构 */
int argno = 0; /* 纪录参数个数 */
char *para; /* 存放取出的字符串参数 */

// 使用宏va_start, 使argp指向传入的第一个可选参数，
// 注意 msg是参数表中最后一个确定的参数，并非参数表中第一个参数
va_start( argp, msg );

while (1)
{
//取出当前的参数，类型为char *
//如果不给出正确的类型，将得到错误的参数
para = va_arg( argp, char *);

if ( strcmp( para, “\0″) == 0 ) /* 采用空串指示参数输入结束 */
break;
printf(”参数 #%d 是: %s\n”, argno, para);
argno++;
}
va_end( argp ); /* 将argp置为NULL */
return 0;
}

//输出结果
参数 #0 是: This
参数 #1 是: is
参数 #2 是: a
参数 #3 是: demo!

注意到上面的例子没有使用第一个参数，下面的例子将使用所有参数

//================================ 例子程序2 ===============

#include
#include
int average( int first, … ); //输入若干整数，求它们的平均值

void main( void )
{
/* 调用3个整数(-1表示结尾) */
printf( “Average is: %d\n”, average(2,3,4, -1));

/*调用4个整数*/
printf( “Average is: %d\n”, average(5,7,9, 11,-1));

/*只有结束符的调用*/
printf( “Average is: %d\n”, average(-1) );
}

/* 返回若干整数平均值的函数 */
int average( int first, … )
{
int count = 0, sum = 0, i = first;
va_list marker;

va_start( marker, first ); //初始化
while( i != -1 )
{
sum += i; //先加第一个参数
count++;
i = va_arg( marker, int);//取下一个参数
}
va_end( marker );
return( sum ? (sum / count) : 0 );
}

//输出结果
Average is: 3
Average is: 8
Average is: 0

五、关于可变参数的传递问题

有人问到这个问题，假如我定义了一个可变参数函数，在这个函数内部又要调用其它可变参数函数，那么如何传递参数呢？上面的例子都是使用宏va_arg逐个把参数提取出来使用，能否不提取，直接把它们传递给另外的函数呢？

我们先看printf的实现：

int __cdecl printf (const char *format, …)
{
va_list arglist;
int buffing;
int retval;

va_start(arglist, format); //arglist指向format后面的第一个参数

。。。//不关心其它代码
retval = _output(stdout,format,arglist); //把format格式和参数传递给output函数

。。。//不关心其它代码
return(retval);
}

我们先模仿这个函数写一个：

#include
#include

int mywrite(char *fmt, …)
{
va_list arglist;
va_start(arglist, fmt);
return printf(fmt,arglist);
}

void main()
{
int i=10, j=20;
char buf[] = “This is a test”;
double f= 12.345;
mywrite(”String: %s\nInt: %d, %d\nFloat :%4.2f\n”, buf, i, j, f);
}

运行一下看看，哈，错误百出。仔细分析原因，根据宏的定义我们知道 arglist是一个指针，它指向第一个可变的参数，但是所有的参数都位于栈中，所以arglist指向栈中某个位置，通过arglist的值，我们可以直接查看栈里面的内容：

arglist -> 指向栈里面，内容包括

0067FD78 E0 FD 67 00 //指向字符串”This is a test”
0067FD7C 0A 00 00 00 //整数 i 的值
0067FD80 14 00 00 00 //整数 j 的值
0067FD84 71 3D 0A D7 //double 变量 f, 占用8个字节
0067FD88 A3 B0 28 40
0067FD8C 00 00 00 00

如果直接调用 printf(fmt, arglist); 仅仅是把arglist指针的值0067FD78入栈，然后把格式字符串入栈，相当于调用：

printf(fmt, 0067FD78);

自然这样的调用肯定会出现错误。

我们能不能逐个把参数提取出来，再传递给其它函数呢？先考虑一次性把所有参数传递进去的问题。

如果调用的是系统库函数，这种情况下是不可能的。因为提取参数是在运行态，而参数入栈是在编译的时候确定的。无法让编译器预知运行态的事情给出正确的参数入栈代码。而我们在运行态虽然可以提取每个参数，但是无法将参数一次性全部压栈，即使使用汇编代码实现起来也是很困难的，因为不单是一个简单的push代码就可以做到。

如果接受参数的函数也是我们自己写的，自然我们可以把arglist指针入栈，然后在函数中自己解析arglist指针里面的参数，逐个提取出来处理。但是这样做似乎没有什么意义，一方面，这个函数没有必要也做成可变参数函数，另一方面直接在第一个函数中解析参数，然后处理不是更简单么？

我们唯一可以做到的是，逐个解析参数，然后循环中调用其它可变参数函数，每次传递一个参数。这里又有一个问题，就是参数表中的不可变参数的传递问题，有些情况下不能简单的传递，以上面的例子为例， 通常我们解析参数的同时，还需要解析格式字符串：

#include
#include
#include

//测试一下这个，开个玩笑
void t(…)
{
printf(”\n”);
}

int mywrite(char *fmt, …)
{
va_list arglist;
va_start(arglist, fmt);

char temp[255];
strcpy(temp, fmt); //Copy the Format string
char Format[255];

char *p = strchr(temp,’%');
int i=0;
int iParam;
double fParam;
while(p != NULL)
{
while((*p< 'a' || *p>‘z’) && (*p!=0) ) p++;
if(*p == 0)break;
p++;

//格式字符串
int nChar = p - temp;
strncpy(Format,temp, nChar);
Format[nChar] = 0;
//参数
if(Format[nChar-1] != ‘f’)
{
iParam = va_arg( arglist, int);
printf(Format, iParam);
}
else
{
fParam = va_arg( arglist, double);
printf(Format, fParam);
}

i++;
if(*p == 0) break;
strcpy(temp, p);
p = strchr(temp, ‘%’);
}
if(temp[0] != 0)
printf(temp);

return i;

}

void main()
{
int i=10, j=20;
char buf[] = “This is a test”;
double f= 123.456;
mywrite(”String: %s\nInt: %d, %d\nFloat :%4.2f\nEnd”, buf, i, j, f, 0);
t(”aaa”, i);
}

//输出：
String: This is a test
Int: 10, 20
Float :123.46
End

当然这里的解析是不完善的。

关键词： 字节对齐    #pragma    pack    sizeof    padding

关于字节对齐,这可能是我找到的解释最为准确的一篇文章了,尤其对于 #pragma pack 的解释.之前看了好几篇文章,都解释为是设置默认对齐字节数.唯有该篇指出是设置字节对齐时所允许的最大值.经linux 下验证,符合事实. 似乎网上的文章以讹传讹的情况越来越多了.以至于关于集线器在osi体系中所处的层次居然有3中说法.

朋友帖了如下一段代码：
　　#pragma pack(4)
　　class TestB
　　{
　　public:
　　　　int aa;
　　　　char a;
　　　　short b;
　　　　char c;
　　};
　　int nSize = sizeof(TestB);
　　这里nSize结果为12，在预料之中。

　　现在去掉第一个成员变量为如下代码：
　　#pragma pack(4)
　　class TestC
　　{
　　public:
　　　　char a;
　　　　short b;
　　　　char c;
　　};
　　int nSize = sizeof(TestC);
　　按照正常的填充方式nSize的结果应该是8，为什么结果显示nSize为6呢？

事实上，很多人对#pragma pack的理解是错误的。
#pragma pack规定的对齐长度，实际使用的规则是：
结构，联合，或者类的数据成员，第一个放在偏移为0的地方，以后每个数据成员的对齐，按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。
也就是说，当#pragma pack的值等于或超过所有数据成员长度的时候，这个值的大小将不产生任何效果。
而结构整体的对齐，则按照结构体中最大的数据成员 和 #pragma pack指定值 之间，较小的那个进行。

具体解释
#pragma pack(4)
　　class TestB
　　{
　　public:
　　　　int aa; //第一个成员，放在[0,3]偏移的位置，
　　　　char a; //第二个成员，自身长为1，#pragma pack(4),取小值，也就是1，所以这个成员按一字节对齐，放在偏移[4]的位置。
　　　　short b; //第三个成员，自身长2，#pragma pack(4)，取2，按2字节对齐，所以放在偏移[6,7]的位置。
　　　　char c; //第四个，自身长为1，放在[8]的位置。
　　};
这个类实际占据的内存空间是9字节
类之间的对齐，是按照类内部最大的成员的长度，和#pragma pack规定的值之中较小的一个对齐的。
所以这个例子中，类之间对齐的长度是min(sizeof(int),4)，也就是4。
9按照4字节圆整的结果是12，所以sizeof(TestB)是12。


如果
#pragma pack(2)
    class TestB
　　{
　　public:
　　　　int aa; //第一个成员，放在[0,3]偏移的位置，
　　　　char a; //第二个成员，自身长为1，#pragma pack(4),取小值，也就是1，所以这个成员按一字节对齐，放在偏移[4]的位置。
　　　　short b; //第三个成员，自身长2，#pragma pack(4)，取2，按2字节对齐，所以放在偏移[6,7]的位置。
　　　　char c; //第四个，自身长为1，放在[8]的位置。
　　};
//可以看出，上面的位置完全没有变化，只是类之间改为按2字节对齐，9按2圆整的结果是10。
//所以 sizeof(TestB)是10。

最后看原贴：
现在去掉第一个成员变量为如下代码：
　　#pragma pack(4)
　　class TestC
　　{
　　public:
　　　　char a;//第一个成员，放在[0]偏移的位置，
　　　　short b;//第二个成员，自身长2，#pragma pack(4)，取2，按2字节对齐，所以放在偏移[2,3]的位置。
　　　　char c;//第三个，自身长为1，放在[4]的位置。
　　};
//整个类的大小是5字节，按照min(sizeof(short),4)字节对齐，也就是2字节对齐，结果是6
//所以sizeof(TestC)是6。

感谢 Michael 提出疑问，在此补充：

当数据定义中出现__declspec( align() )时，指定类型的对齐长度还要用自身长度和这里指定的数值比较，然后取其中较大的。最终类/结构的对齐长度也需要和这个数值比较，然后取其中较大的。

可以这样理解， __declspec( align() ) 和 #pragma pack是一对兄弟，前者规定了对齐的最小值，后者规定了对齐的最大值，两者同时出现时，前者拥有更高的优先级。
__declspec ( align() )的一个特点是，它仅仅规定了数据对齐的位置，而没有规定数据实际占用的内存长度，当指定的数据被放置在确定的位置之后，其后的数据填充仍然是按照#pragma pack规定的方式填充的，这时候类/结构的实际大小和内存格局的规则是这样的：
在__declspec( align () )之前，数据按照#pragma pack规定的方式填充，如前所述。当遇到 __declspec( align() )的时候，首先寻找距离当前偏移向后最近的对齐点（满足对齐长度为 max(数据自身长度,指定值) )，然后把被指定的数据类型从这个点开始填充，其后的数据类型从它的后面开始，仍然按照#pragma pack填充，直到遇到下一个__declspec ( align() )。
当所有数据填充完毕，把结构的整体对齐数值和__declspec( align() )规定的值做比较，取其中较大的作为整个结构的对齐长度。
特别的，当__declspec( align() )指定的数值比对应类型长度小的时候，这个指定不起作用。