大神洗礼第三讲——接上一讲

Author：bakari                 Date:2012.10.26

这一讲的主要内容和上一讲相同，是上一讲的深入分析。内存对齐涉及内存实现的细节，复杂声明是对指针的深入理解，这些内容平时用到很少，学习之益于开拓思维，达到宏观调控自己的知识结构。

1、对于内存对齐上一讲没有提到计算的方法，其实上一讲的内容足以解决如何计算的问题，但有个规律或许会更容易计算。下面是概况出来的规律：

< 1 >、编译器默认对齐的字节：8字节，对齐字节数只能选2^n（一般不超过16字节）
           在程序中用#pragma back( X ) ……. #pragma pop()来转换。

< 2 >、单个成员变量的自身对齐位：min（默认对齐位，本身所占字节数）

< 3 >、结构体的有效对齐位：该结构体（或union或class）的成员变量中，
           min（最大所占位数，默认对齐位）
           其中< 2 >可以不考虑，< 3 >是考虑的关键

< 4 >、除以上3点外，还要考虑一个关键特性：圆整。          

           何为圆整？每个变量所占字节数之和与 < 3 >中的有效对齐位求模，如若为0，则不作改变，否则，系统自动以 CC 作为填充，以保证对齐。

E.g：具体看下面的几个例子：

struct Test {
      char   szA[5];
      double dB;
      int    iC;
      char   cD;
};

编译器的默认对齐位是:8 即#pragma back (8)，结构体最大的成员变量是dB，占8个字节，所以结构体的有效对齐位是 8.
通过上面三条规则，可以得出：sizeof（Test）= 5 + 3cc + 8 + 4 + 1 + 3cc = 24;
内存布局：

< 2 >、将double dB 改为int iB；

    struct Test {
      char   szA[5];
      int    iB;
      int    iC;
      char   cD;
};

同理，sizeof（Test） = 5 + 3cc + 4 + 4 + 1 + 3 cc = 20;
内存布局：

< 3 >较为复杂，道理一样，分开看

struct AX {                               
    void *pC;
    char cA;
    char szBuf[3];
    int  iB;
    void *p;
};

union BX {
    double dA;
    int    iB
};

struct xTest {
    int    iA;
    int    iB;
    char   cC;
    void   *pD;
    char   *pVoid;
    AX     objAX;
    BX     objBX;
    char   cE;
    double dF;
};

直接看内存布局：（sizeof（xTest） = 64）

2、复杂声明我就不多讲了，想了解的朋友可以去看我的另一篇文章：http://www.cnblogs.com/bakari/archive/2012/08/28/2659889.html

这里我们来点刺激的，将复杂声明的语句用机器打印出来，换句话说不是你来说，而是交给机器来显示：（关于这一点The C programming language一书有讲）

我们直接看代码：（只显示三个主要的函数）

int gettoken(void)
{
    char c;
    char *p = token;

    while ((c = getch()) == ' ' || c == '\t');
    if (c == '(') {
        if ((c = getch()) == ')') {
            strcpy(token, "()");
            return tokentype = PARENS;
        }
        else {
            ungetch(c);
            return tokentype = '(';
        }
    }
    else if (c == '[') {
        for (*p ++ = c; (*p ++ = getch()) != ']'; );
        *p = '\0';
        return tokentype = BRACKETS;
    }
    else if (isalpha(c)) {
        for (*p ++ =  c; isalnum(c = getch()); )
            *p ++ = c;
        *p = '\0';
        ungetch(c);
        return tokentype = NAME;
    }
    else
        return tokentype = c;
}

void dcl (void)
{
    int ns;
    for( ns = 0; gettoken() == '*'; )
        ns ++;
    dirdcl();
    while (ns -- > 0)
        strcat(out, " pointer to");
}

void dirdcl(void)
{
    int type;

    //void parmdcl(void);
    if (tokentype == '(') {
        dcl();
        if (tokentype != ')')
            errmsg("ERROR!:missing ) \n");
            //printf("ERROR!:missing ) \n");
    }
    else if (tokentype == NAME) {
        //if (name[0] == '\0')
            strcpy(name, token);
    }
    else
        //errmsg("ERROR: expected name or (dcl) \n");
        prevtoken = YES;
    while ((type = gettoken()) == PARENS || type  == BRACKETS || type == '(') {
        if (type == PARENS)
            strcat (out, " function returning");
        else if (type == '(') {
            strcat(out , "function expecting");
            parmdcl();
            strcat(out, " and returning");
        }
        else {
            strcat(out, " array");
            strcat(out, token);
            strcat(out, " of");
        }
    }
}

---

更多干货请移步我的公众号「aCloudDeveloper」，专注技术干货分享，期待与你相遇。