3.2      Quoted printable 编码

         QP 编码用于表示含有大量对应可打印字符的数组，这种编码方式使字符单元在传输过程中被更改的可能性很小。如果正在编码的数据大部分是ASCII文本，那么编码后的形式具有很高的可读性。一个完全是ASCII值的正文数据由QP编码后可以保证数据在字符翻译或经由网关时数据的完整性。

       编码规则如下：

       规则1：(一般8位组的表示方式), 任何的八位组，都可以用”=”后加该八位组的16进制值来表示，除了那些根据数据编码规范中新行的惯例来指定短行的表示单位。必须用大写字母。比如值是12 ，则表示为”=0C”。

       规则2：(文字表示)值在33-60 ，以及62-126的八位组(包含头尾值)，可以表示成那些八位组对应的ASCII字符。

       规则3：(空格) 值是9和32的八位组可以分别表示为ASCII 的TAB和SPACE值，但是不可以出现在编码行的末尾。任何在编码行的TAB或SPACE字符必须后面有可打印字符出现。特殊情况下，编码行的末尾出现的”=”，表示断行，其前面可能是一个或多个TAB或SPACE。 实行这条规则的原因是一些METs(Message Transport Agents-消息传输单元)会在文本末尾补上SPACE，因此，解码时，任何跟在行后的空格必须删除。

       规则4：(断行)在原文中的断行必须表示成协议中的断行符-CRLF序列（"=0D=0A” ）。由于非文本类型的规范表示一般不包括断行，所以这种类型的qp编码没有硬换行。通常，base64编码在二进制编码上更占优势。

       规则5：(软换行)QP编码要求编码后每行不能超过76个字符。当超过这个限制时，将适用软换行，用”=”表示编码行的断行，后接CRLF。（76的限制包括”=”）。

    return *this;
}

再来看看如何对CLargeObject里面的数据进行真正的修改。这样就一定需要对当前的object独立操作了，否则就影响到了其它指向同一块数据的CLargeObject。这样CData类需要一个新的函数，生成只用于当前CLargetObject的数据。如果当前的引用数目是1，那么当然这个CData就是只用于这个CLargeObject的了。否则就重新new一个CData返回。
        Data* CLargeObject::CData::get_own_copy()    // clone if necessary
        {
            if (m_nReferenceCount==1)
                return this;
            m_nReferenceCount--;
            return new Data(m_nVal);
        }
CLargeObject修改前用这个函数得到唯一的object，然后对它赋值。
void CLargeObject::SetVal(int nNewVal)
{
    m_pData = m_pData->get_own_copy();
    m_pData->m_nVal = nNewVal;
}
对于所有可能改变CData值的操作，都需要用这种方法。

下面是只读函数，简单。直接返回值，什么特殊的都不用作。
int CLargeObject::GetVal() const
{
    return m_pData->m_nVal;
}


这样copy-to-write技术就实现了。下面把完整的程序写一下：
class CLargeObject
{
public:
    CLargeObject(int nVal);
    CLargeObject(const CLargeObject &ob);
    ~CLargeObject();

    CLargeObject& operator = (const CLargeObject& ob);
    void SetVal(int nNewVal);
    int GetVal() const;
private:
    struct Data
    {
    public:
        Data(int nVal) : m_nVal(nVal), m_nReferenceCount(1) {}
    private:
        friend class CLargeObject;
        Data* get_own_copy()    // clone if necessary
        {
            if (m_nReferenceCount==1)
                return this;
            m_nReferenceCount--;
            return new Data(m_nVal);
        }

        // control variables.
        int m_nReferenceCount;
    
        // actual data portion
        int m_nVal;
    };

    Data *m_pData;
};

CLargeObject::CLargeObject(int nVal)
{
    m_pData = new Data(nVal);
}

CLargeObject::CLargeObject(const CLargeObject &ob) // copy constructor
{
    ob.m_pData->m_nReferenceCount++;
    m_pData = ob.m_pData;
}

CLargeObject::~CLargeObject()
{
    if (--m_pData->m_nReferenceCount == 0)
        delete m_pData;
}

CLargeObject& CLargeObject::operator = (const CLargeObject& ob)    // copy assignment
{
    ob.m_pData->m_nReferenceCount++;
    if (--m_pData->m_nReferenceCount == 0)
        delete m_pData;
    m_pData = ob.m_pData;

    return *this;
}

void CLargeObject::SetVal(int nNewVal)
{
    m_pData = m_pData->get_own_copy();
    m_pData->m_nVal = nNewVal;
}

int CLargeObject::GetVal() const
{
    return m_pData->m_nVal;
}


很多存储数据的系统class，如string，CString等都有这种设计。所以记住这个应用是很有必要的。

QueryInterface函数

主要用于COM接口的查询。它是COM接口定义IUnknown的成员函数，客户可以调用QueryInterface来决定组件是否支持某个特定的接口。

       组件COM接口都是从IUnkonwn接口继承而来，任何一个接口都可以用IUnknown的成员QueryInterface来获取它所支持的其它接口。

1）定义：

       HRESULT _stdcall QueryInterface(const IID& iid,void ** ppv);

第一个参数十所需接口的标识，是一个接口标识符IID结构。 第二个参数存放所请求接口指针的地址。

      2）使用过程：

       假定已有一个指向IUnknown的指针pI，为知道相应的组件是否支持某个特定的接口，调用QueryInterface，传给它一个接口标识符。若成功返回，那就是可以使用它返回的指针。

Void foo(IUnknown * pI)

{

       IX *pIX=NULL;

HRESULT hr=pI->QueryInterface(IID_IX,(void **)&pIX);

If(SUCCEEDED(hr))

pIX->Fx();

}

该函数用于查询pI是否支持由IID_IX所标识的接口。

IUnknown的继承不是虚拟基类。COM接口不能按照虚拟方式继承它。

3）实现：

Interface IX：IUnknown{/**/}；

Interface IY：IUnknown{/**/}；

Class CA：public IX,public IY{/**/};

主要通过判断标识符是否为CA的支持类型，来判断是否为存在在CA中的COM

HRESULT _stdcall CA:;QueryInterface(const IID &iid,void **ppv)

{

       If(iid==IID_IUnknown)

{

       *ppv=static_cast<IX *>(this);

}

Else if(iid==IID_IX)

{

       *ppv=static_cast<IX*>(this);

}

Else if (iid==IID_IY)

{

       *ppv=static_cast<IY*>(this);

}

Else

{

       *ppv=NULL;

Return E_NOINTERFACE;

}

Static_cast<IUnknown*>(*ppv)->AddRef();

Return S_OK;

}

4）关于其中的类型转换

   程序中若将this指针直接转换成IUnknown*是不明确的。因为存在两个基类接口，需要指明是转换向哪一个接口的IUnknown。

Static_cast<IUnknown*> (static_cast<IX *>(this))

在类型转换时，CA按照顺序存放它的基类接口及其实现，其this指针可以用IX代替（地址值相同）。

而IY则需要CA的基址加上偏移址。

void GetMemory(char *p)

{

p = (char *)malloc(100);

}

void Test(void)

{

char *str = NULL;

GetMemory(str);

strcpy(str, "hello world");

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：程序崩溃。

因为GetMemory 并不能传递动态内存，

Test 函数中的 str 一直都是 NULL。

strcpy(str, "hello world");将使程序崩

溃。

char *GetMemory(void)

{

char p[] = "hello world";

return p;

}

void Test(void)

{

char *str = NULL;

str = GetMemory();

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：可能是乱码。

因为GetMemory 返回的是指向“栈内存”

的指针，该指针的地址不是 NULL，但其原

现的内容已经被清除，新内容不可知。

void GetMemory2(char **p, int num)

{

*p = (char *)malloc(num);

}

void Test(void)

{

char *str = NULL;

GetMemory(&str, 100);

strcpy(str, "hello");

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：

（1）能够输出hello

（2）内存泄漏

void Test(void)

{

char *str = (char *) malloc(100);

strcpy(str, “hello”);

free(str);

if(str != NULL)

{

strcpy(str, “world”);

printf(str);

}

}

请问运行Test 函数会有什么样的结果？

答：篡改动态内存区的内容，后果难以预

料，非常危险。

因为free(str);之后，str 成为野指针，

if(str != NULL)语句不起作用。

2.关于内存泄露

  在计算机科学中，内存泄漏指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的消失，而是应用程序分配某段内存后， 由于设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏与许多其他问题有着相似的症状，并且通常情况下只能由那些可以获得程序源代码的程 序员才可以分析出来。然而，有不少人习惯于把任何不需要的内存使用的增加描述为内存泄漏，即使严格意义上来说这是不准确的。
       一般我们常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的（内存块的大小可以在程序运行期决定），使用完后必须显示释放的内存。 应用程序一般使用malloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存 块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。

a/=k+m*k+m/k+m*k+m
=>a /= 2+1*2+1/2+1*2+1
=>a = a/7;
=>a = 1;

--------------------------------------------------------------------------
5.
const 符号常量；
(1)const char *p
(2)char const *p
(3)char * const p
说明上面三种描述的区别；


如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。

(1)const char *p

一个指向char类型的const对象指针，p不是常量,我们可以修改p的值，使其指向不同的char，但是不能改变它指向非char对象，如：
const char *p;
char c1='a';
char c2='b';
p=&c1;//ok
p=&c2;//ok
*p=c1;//error

(2)char const *p
(3)char * const p

这两个好象是一样的，此时*p可以修改，而p不能修改。

(4)const char * const p
这种是地址及指向对象都不能修改。

--------------------------------------------------------------------------
6.下面是C语言中两种if语句判断方式。请问哪种写法更好？为什么？
 int n;
 if (n == 10) // 第一种判断方式
 if (10 == n) // 第二种判断方式

如果少了个=号,编译时就会报错,减少了出错的可能行,可以检测出是否少了=

--------------------------------------------------------------------------
7.下面的代码有什么问题？
void DoSomeThing(...)
{
 char* p;
 ...
 p = malloc(1024);  // 分配1K的空间
 if (NULL == p)
  return;
 ...
 p = realloc(p, 2048); // 空间不够，重新分配到2K
 if (NULL == p)
  return;
 ...
}

A:
p = malloc(1024);     应该写成： p = (char *) malloc(1024); 
        没有释放p的空间，造成内存泄漏。


--------------------------------------------------------------------------
8.下面的代码有什么问题？并请给出正确的写法。
void DoSomeThing(char* p)
{
 char str[16];
 int n;
 assert(NULL != p);
 sscanf(p, "%s%d", str, n);
 if (0 == strcmp(str, "something"))
 {
  ...
 }
}

A:
sscanf(p, "%s%d", str, n);   这句该写成： sscanf(p, "%s%d", str, &n);

--------------------------------------------------------------------------
9.下面代码有什么错误?
Void test1() 
{ 
 char string[10]; 
 char *str1="0123456789";
 strcpy(string, str1); 
} 

数组越界

--------------------------------------------------------------------------
10.下面代码有什么问题?
Void test2() 
{ 
  char string[10], str1[10]; 
  for(i=0; i<10;i++) 
  { 
     str1[i] ='a'; 
  } 
  strcpy(string, str1); 
} 

数组越界

--------------------------------------------------------------------------
11.下面代码有什么问题?
Void test3(char* str1) 
{ 
  char string[10]; 
  if(strlen(str1)<=10) 
  { 
    strcpy(string, str1); 
  } 
} 

==数组越界
==strcpy拷贝的结束标志是查找字符串中的\0 因此如果字符串中没有遇到\0的话 会一直复制，直到遇到\0,上面的123都因此产生越界的情况
 
建议使用 strncpy 和 memcpy

--------------------------------------------------------------------------
12.下面代码有什么问题?

#define MAX_SRM 256 

DSN get_SRM_no() 
{ 
  static int SRM_no; //是不是这里没赋初值？
  int I; 
  for(I=0;I<MAX_SRM;I++,SRM_no++) 
  { 
    SRM_no %= MAX_SRM; 
    if(MY_SRM.state==IDLE) 
    { 
      break; 
    } 
  } 
  if(I>=MAX_SRM) 
    return (NULL_SRM); 
  else 
    return SRM_no; 
} 

系统会初始化static int变量为0,但该值会一直保存,所谓的不可重入...

--------------------------------------------------------------------------
13.写出运行结果:
{// test1
    char str[] = "world"; cout << sizeof(str) << ": ";
    char *p    = str;     cout << sizeof(p) << ": ";
    char i     = 10;      cout << sizeof(i) << ": ";
    void *pp   = malloc(10);  cout << sizeof(p) << endl;
}

6：4：1：4

--------------------------------------------------------------------------
14.写出运行结果:
{// test2
    union V {
 struct X {
  unsigned char s1:2;
  unsigned char s2:3;
  unsigned char s3:3;
 } x;

 unsigned char c;
    } v;

    v.c = 100;
    printf("%d", v.x.s3); 

}

3

--------------------------------------------------------------------------
15.用C++写个程序，如何判断一个操作系统是16位还是32位的？不能用sizeof()函数

A1:
16位的系统下，
int i = 65536;
cout << i; // 输出0；
int i = 65535;
cout << i; // 输出-1；

32位的系统下，
int i = 65536;
cout << i; // 输出65536；
int i = 65535;
cout << i; // 输出65535；

A2:

int a = ~0;
if( a>65536 ) 
{
    cout<<"32 bit"<<endl;
}
else
{
    cout<<"16 bit"<<endl;
}


--------------------------------------------------------------------------
16.C和C++有什么不同?

从机制上：c是面向过程的（但c也可以编写面向对象的程序）；c++是面向对象的，提供了类。但是，
c++编写面向对象的程序比c容易

从适用的方向：c适合要求代码体积小的，效率高的场合，如嵌入式；c++适合更上层的，复杂的；  llinux核心大部分是c写的，因为它是系统软件，效率要求极高。

从名称上也可以看出，c++比c多了+，说明c++是c的超集；那为什么不叫c+而叫c++呢，是因为c++比
c来说扩充的东西太多了，所以就在c后面放上两个+；于是就成了c++

C语言是结构化编程语言，C++是面向对象编程语言。
C++侧重于对象而不是过程，侧重于类的设计而不是逻辑的设计。

--------------------------------------------------------------------------
17.在不用第三方参数的情况下，交换两个参数的值
#include <stdio.h>

void main()
{
        int i=60;
        int j=50;
        i=i+j;
        j=i-j;
        i=i-j;
        printf("i=%d\n",i);
        printf("j=%d\n",j);
}

方法二：
i^=j;
j^=i;
i^=j;

方法三：
// 用加减实现，而且不会溢出
a = a+b-(b=a)

--------------------------------------------------------------------------
18.有关位域的面试题（为什么输出的是一个奇怪的字符）

a.t = 'b';效果相当于 a.t= 'b' & 0xf;

'b' --> 01100010
'b' & 0xf -->>00000010
所以输出Ascii码为2的特殊字符


char t:4;就是4bit的字符变量，同样
unsigned short i:8;就是8bit的无符号短整形变量

--------------------------------------------------------------------------
19.int i=10, j=10, k=3; k*=i+j; k最后的值是?

60

--------------------------------------------------------------------------
20.进程间通信的方式有?

进程间通信的方式有 共享内存， 管道 ，Socket ，消息队列 , DDE等

--------------------------------------------------------------------------
21.
struct A 
{ 
char t:4; 
char k:4; 
unsigned short i:8; 
unsigned long m; 
} 
sizeof(A)=?（不考虑边界对齐）

7

struct CELL             // Declare CELL bit field
{
   unsigned character  : 8;  // 00000000 ????????
   unsigned foreground : 3;  // 00000??? 00000000
   unsigned intensity  : 1;  // 0000?000 00000000
   unsigned background : 3;  // 0???0000 00000000
   unsigned blink      : 1;  // ?0000000 00000000
} screen[25][80];       // Array of bit fields
二、位结构 
    位结构是一种特殊的结构, 在需按位访问一个字节或字的多个位时, 位结构 
比按位运算符更加方便。 
    位结构定义的一般形式为: 
     struct位结构名{ 
          数据类型 变量名: 整型常数; 
          数据类型 变量名: 整型常数; 
     } 位结构变量; 
    其中: 数据类型必须是int(unsigned或signed)。 整型常数必须是非负的整 
数, 范围是0~15, 表示二进制位的个数, 即表示有多少位。 
    变量名是选择项, 可以不命名, 这样规定是为了排列需要。 
    例如: 下面定义了一个位结构。 
     struct{ 
          unsigned incon: 8;  /*incon占用低字节的0~7共8位*/ 
          unsigned txcolor: 4;/*txcolor占用高字节的0~3位共4位*/ 
          unsigned bgcolor: 3;/*bgcolor占用高字节的4~6位共3位*/ 
          unsigned blink: 1;  /*blink占用高字节的第7位*/ 
     }ch; 
    位结构成员的访问与结构成员的访问相同。 
    例如: 访问上例位结构中的bgcolor成员可写成: 
      ch.bgcolor 
  
    注意: 
    1. 位结构中的成员可以定义为unsigned, 也可定义为signed,  但当成员长 
度为1时, 会被认为是unsigned类型。因为单个位不可能具有符号。 
    2. 位结构中的成员不能使用数组和指针, 但位结构变量可以是数组和指针, 
如果是指针, 其成员访问方式同结构指针。 
    3. 位结构总长度(位数), 是各个位成员定义的位数之和,  可以超过两个字 
节。 
    4. 位结构成员可以与其它结构成员一起使用。 
    例如: 
     struct info{ 
          char name[8]; 
          int age; 
          struct addr address; 
          float pay; 
          unsigned state: 1; 
          unsigned pay: 1; 
          }workers;
    上例的结构定义了关于一个工人的信息。其中有两个位结构成员, 每个位结 
构成员只有一位, 因此只占一个字节但保存了两个信息, 该字节中第一位表示工 
人的状态, 第二位表示工资是否已发放。由此可见使用位结构可以节省存贮空间。


--------------------------------------------------------------------------
22.下面的函数实现在一个固定的数上加上一个数，有什么错误，改正 
int add_n(int n) 
{ 
  static int i=100; 
  i+=n; 
  return i; 
} 

答:
因为static使得i的值会保留上次的值。
去掉static就可了

--------------------------------------------------------------------------
23.下面的代码有什么问题?
class A 
{ 
public: 
  A() { p=this; } 
  ~A() { if(p!=NULL) { delete p; p=NULL; } } 

  A* p; 
};

答:
会引起无限递归

--------------------------------------------------------------------------
24.
union a {
 int a_int1;
 double a_double;
 int a_int2;
};

typedef struct
{
 a a1;
 char y;
} b;

class c
{
 double c_double;
 b b1;
 a a2;

};

输出cout<<sizeof(c)<<endl;的结果?

答:
VC6环境下得出的结果是32

另:
我(sun)在VC6.0+win2k下做过试验:
short - 2
int-4
float-4
double-8
指针-4

sizeof(union)，以结构里面size最大的为union的size

解析C语言中的sizeof

一、sizeof的概念　 
　　sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。　 

二、sizeof的使用方法　 
　　1、用于数据类型　 

　　sizeof使用形式：sizeof（type）　 

　　数据类型必须用括号括住。如sizeof（int）。　 

　　2、用于变量　 

　　sizeof使用形式：sizeof（var_name）或sizeof　var_name　 

　　变量名可以不用括号括住。如sizeof　(var_name)，sizeof　var_name等都是正确形式。带括号的用法更普遍，大多数程序员采用这种形式。　 

　　注意：sizeof操作符不能用于函数类型，不完全类型或位字段。不完全类型指具有未知存储大小的数据类型，如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。　 

　　如sizeof(max)若此时变量max定义为int　max(),sizeof(char_v)　若此时char_v定义为char　char_v　[MAX]且MAX未知，sizeof(void)都不是正确形式。　 

三、sizeof的结果　 
　　sizeof操作符的结果类型是size_t，它在头文件

中typedef为unsigned　int类型。该类型保证能容纳实现所建立的最大对象的字节大小。　 

　　1、若操作数具有类型char、unsigned　char或signed　char，其结果等于1。　 

　　ANSI　C正式规定字符类型为1字节。　 

　　2、int、unsigned　int　、short　int、unsigned　short　、long　int　、unsigned　long　、 float、double、long　double类型的sizeof　在ANSI　C中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、 4、4、4、8、10。　 

　　3、当操作数是指针时，sizeof依赖于编译器。例如Microsoft　C/C++7.0中，near类指针字节数为2，far、huge类指针字节数为4。一般Unix的指针字节数为4。　 

　　4、当操作数具有数组类型时，其结果是数组的总字节数。　 

　　5、联合类型操作数的sizeof是其最大字节成员的字节数。结构类型操作数的sizeof是这种类型对象的总字节数，包括任何垫补在内。　 

　　让我们看如下结构：　 

　　struct　{char　b;　double　x;}　a;　 

　　在某些机器上sizeof（a）=12，而一般sizeof（char）+　sizeof（double）=9。　 

　　这是因为编译器在考虑对齐问题时，在结构中插入空位以控制各成员对象的地址对齐。如double类型的结构成员x要放在被4整除的地址。　 

　　6、如果操作数是函数中的数组形参或函数类型的形参，sizeof给出其指针的大小。　 

四、sizeof与其他操作符的关系　 
　　sizeof的优先级为2级，比/、%等3级运算符优先级高。它可以与其他操作符一起组成表达式。如i*sizeof（int）；其中i为int类型变量。　 

五、sizeof的主要用途　 
　　1、sizeof操作符的一个主要用途是与存储分配和I/O系统那样的例程进行通信。例如：　 

　　void　*malloc（size_t　size）,　 

　　size_t　fread(void　*　ptr,size_t　size,size_t　nmemb,FILE　*　stream)。　 

　　2、sizeof的另一个的主要用途是计算数组中元素的个数。例如：　 

　　void　*　memset（void　*　s,int　c,sizeof(s)）。　 

六、建议　 
　　由于操作数的字节数在实现时可能出现变化，建议在涉及到操作数字节大小时用sizeof来代替常量计算。


=============================================================
本文主要包括二个部分，第一部分重点介绍在VC中，怎么样采用sizeof来求结构的大小，以及容易出现的问题，并给出解决问题的方法，第二部分总结出VC中sizeof的主要用法。 

1、 sizeof应用在结构上的情况 

请看下面的结构： 

struct MyStruct 

{ 

double dda1; 

char dda; 

int type 

}; 

对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求： 

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 

但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗？ 

其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了"对齐"处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)。 

类型 
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） 

Char 
偏移量必须为sizeof(char)即1的倍数 

int 
偏移量必须为sizeof(int)即4的倍数 

float 
偏移量必须为sizeof(float)即4的倍数 

double 
偏移量必须为sizeof(double)即8的倍数 

Short 
偏移量必须为sizeof(short)即2的倍数 


各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。 

下面用前面的例子来说明VC到底怎么样来存放结构的。 

struct MyStruct 

{ 

double dda1; 

char dda; 

int type 

}； 

为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用 sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof (int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以整个结构的大小为：sizeof(MyStruct)=8+1+ 3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。 

下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况： 

struct MyStruct 

{ 

char dda; 

double dda1;   

int type 

}； 

这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruc)为24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明） 

struct MyStruct 

{ 

  char dda;//偏移量为0，满足对齐方式，dda占用1个字节； 

double dda1;//下一个可用的地址的偏移量为1，不是sizeof(double)=8 

             //的倍数，需要补足7个字节才能使偏移量变为8（满足对齐 

             //方式），因此VC自动填充7个字节，dda1存放在偏移量为8 

             //的地址上，它占用8个字节。 

int type；//下一个可用的地址的偏移量为16，是sizeof(int)=4的倍 

           //数，满足int的对齐方式，所以不需要VC自动填充，type存 

           //放在偏移量为16的地址上，它占用4个字节。 

}；//所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构 

   //的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof 

   //(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为 

   //sizeof(double)=8的倍数。 


所以该结构总的大小为：sizeof(MyStruc)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。 


VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。 

VC 中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；  

否则必须为n的倍数。下面举例说明其用法。 

#pragma pack(push) //保存对齐状态 

#pragma pack(4)//设定为4字节对齐 

struct test 

{ 

  char m1; 

  double m4; 

  int  m3; 

}; 

#pragma pack(pop)//恢复对齐状态 

以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为 m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。（请读者自己分析） 

2、 sizeof用法总结 

在VC中，sizeof有着许多的用法，而且很容易引起一些错误。下面根据sizeof后面的参数对sizeof的用法做个总结。 

A．  参数为数据类型或者为一般变量。例如sizeof(int),sizeof(long)等等。这种情况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。例如int类型在16位系统中占2个字节，在32位系统中占4个字节。 

B．  参数为数组或指针。下面举例说明. 

int a[50];  //sizeof(a)=4*50=200; 求数组所占的空间大小 

int *a=new int[50];// sizeof(a)=4; a为一个指针，sizeof(a)是求指针 

                   //的大小,在32位系统中，当然是占4个字节。 

C．  参数为结构或类。Sizeof应用在类和结构的处理情况是相同的。但有两点需要注意，第一、结构或者类中的静态成员不对结构或者类的大小产生影响，因为静态变量的存储位置与结构或者类的实例地址无关。 

第二、没有成员变量的结构或类的大小为1，因为必须保证结构或类的每一 

个实例在内存中都有唯一的地址。 

下面举例说明， 

Class Test{int a;static double c};//sizeof(Test)=4. 

Test *s;//sizeof(s)=4,s为一个指针。 

Class test1{ };//sizeof(test1)=1; 

D．  参数为其他。下面举例说明。 

   int func(char s[5]); 

   { 

     cout<<sizeof(s);//这里将输出4，本来s为一个数组，但由于做为函 

                     //数的参数在传递的时候系统处理为一个指针，所 

                     //以sizeof(s)实际上为求指针的大小。 

     return 1; 

} 

sizeof(func("1234"))=4//因为func的返回类型为int，所以相当于 

                     //求sizeof(int). 


以上为sizeof的基本用法，在实际的使用中要注意分析VC的分配变量的分配策略，这样的话可以避免一些错误。 


--------------------------------------------------------------------------
25.i最后等于多少?
int i = 1;
int j = i++;
if((i>j++) && (i++ == j)) i+=j;

答:
i = 5

--------------------------------------------------------------------------
26.
unsigned short array[]={1,2,3,4,5,6,7};
int i = 3;
*(array + i) = ?

答:
4

--------------------------------------------------------------------------
27.
class A
{
  virtual void func1()；
  void func2();
}
Class B: class A
{
  void func1(){cout << "fun1 in class B" << endl;}
  virtual void func2(){cout << "fun2 in class B" << endl;}
} 
A, A中的func1和B中的func2都是虚函数.
B, A中的func1和B中的func2都不是虚函数.
C, A中的func2是虚函数.，B中的func1不是虚函数.
D, A中的func2不是虚函数，B中的func1是虚函数.

答:
A

--------------------------------------------------------------------------
28.
数据库：抽出部门，平均工资，要求按部门的字符串顺序排序，不能含有"human resource"部门，

employee结构如下：employee_id, employee_name, depart_id,depart_name,wage

答:
select depart_name, avg(wage)
from employee
where depart_name <> 'human resource'
group by depart_name
order by depart_name

--------------------------------------------------------------------------
29.
给定如下SQL数据库：Test(num INT(4)) 请用一条SQL语句返回num的最小值，但不许使用统计功能，如MIN，MAX等

答:
select top 1 num
from Test
order by num desc

--------------------------------------------------------------------------
30.
输出下面程序结果。 

#include <iostream.h> 

class A 
{ 
public:
 virtual void print(void) 
 { 
    cout<<"A::print()"<<endl; 
 } 
};
class B:public A 
{ 
public:
 virtual void print(void) 
 { 
   cout<<"B::print()"<<endl;
 }; 
}; 
class C:public B
{
public:
 virtual void print(void)
 {
  cout<<"C::print()"<<endl;
 }
};
void print(A a) 
{ 
   a.print(); 
} 
void main(void) 
{ 
   A a, *pa,*pb,*pc; 
   B b; 
   C c; 
   
   pa=&a; 
   pb=&b; 
   pc=&c; 
   
   a.print(); 
   b.print(); 
   c.print(); 
   
   pa->print(); 
   pb->print(); 
   pc->print(); 
   
   print(a); 
   print(b); 
   print(c); 
}

A:
A::print()
B::print()
C::print()
A::print()
B::print()
C::print()
A::print()
A::print()
A::print()

--------------------------------------------------------------------------
31.
试编写函数判断计算机的字节存储顺序是开序(little endian)还是降序(bigendian)

答:
bool IsBigendian()
{
 unsigned short usData = 0x1122;
 unsigned char  *pucData = (unsigned char*)&usData;

 return (*pucData == 0x22);
}

--------------------------------------------------------------------------
32.简述Critical Section和Mutex的不同点

答:
对几种同步对象的总结
1.Critical Section
A.速度快
B.不能用于不同进程
C.不能进行资源统计(每次只可以有一个线程对共享资源进行存取)

2.Mutex
A.速度慢
B.可用于不同进程
C.不能进行资源统计

3.Semaphore
A.速度慢
B.可用于不同进程
C.可进行资源统计(可以让一个或超过一个线程对共享资源进行存取)

4.Event
A.速度慢
B.可用于不同进程
C.可进行资源统计


--------------------------------------------------------------------------
33.一个数据库中有两个表:
一张表为Customer，含字段ID,Name;
一张表为Order，含字段ID,CustomerID（连向Customer中ID的外键）,Revenue；
写出求每个Customer的Revenue总和的SQL语句。

建表
create table customer
(
ID int primary key,Name char(10)
)

go

create table [order]
(
ID int primary key,CustomerID  int foreign key references customer(id) , Revenue float
)

go

--查询
select Customer.ID, sum( isnull([Order].Revenue,0) )
from customer full join [order] 
on( [order].customerid=customer.id )
group by customer.id

--------------------------------------------------------------------------
34.请指出下列程序中的错误并且修改
void GetMemory(char *p){
  p=(char *)malloc(100);
}
void Test(void){
  char *str=NULL;
  GetMemory=(str);
  strcpy(str,"hello world");
  printf(str);
}

A:错误--参数的值改变后，不会传回
GetMemory并不能传递动态内存，Test函数中的 str一直都是 NULL。
strcpy(str, "hello world");将使程序崩溃。

修改如下:
char *GetMemory(){
  char *p=(char *)malloc(100);
  return p;
}
void Test(void){
  char *str=NULL;
  str=GetMemory(){
  strcpy(str,"hello world");
  printf(str);
}

方法二:void GetMemory2(char **p)变为二级指针.
void GetMemory2(char **p, int num)
{
 *p = (char *)malloc(sizeof(char) * num);
}

--------------------------------------------------------------------------
35.程序改错
class mml
{
  private:
    static unsigned int x;
  public:
    mml(){ x++; }
    mml(static unsigned int &) {x++;}
    ~mml{x--;}
  pulic:
    virtual mon() {} = 0;
    static unsigned int mmc(){return x;}
    ......                      
 
};
class nnl:public mml
{
  private:
    static unsigned int y;
  public:
    nnl(){ x++; }
    nnl(static unsigned int &) {x++;}
    ~nnl{x--;}
  public:
    virtual mon() {};
     static unsigned int nnc(){return y;}
    ......                   
};

代码片断:
mml* pp = new nnl;
..........
delete pp;


A:
基类的析构函数应该为虚函数
virtual ~mml{x--;}

--------------------------------------------------------------------------
36.101个硬币100真、1假，真假区别在于重量。请用无砝码天平称两次给出真币重还是假币重的结论。

答:
101个先取出2堆,
33,33
第一次称,如果不相等,说明有一堆重或轻
那么把重的那堆拿下来,再放另外35个中的33
如果相等,说明假的重,如果不相等,新放上去的还是重的话,说明假的轻(不可能新放上去的轻)

第一次称,如果相等的话，这66个肯定都是真的,从这66个中取出35个来,与剩下的没称过的35个比
下面就不用说了

方法二:
第3题也可以拿A(50),B(50)比一下，一样的话拿剩下的一个和真的比一下。
如果不一样，就拿其中的一堆。比如A(50)再分成两堆25比一下，一样的话就在
B(50)中，不一样就在A(50)中，结合第一次的结果就知道了。

--------------------------------------------------------------------------
37.static变量和static 函数各有什么特点？

答:
static变量：在程序运行期内一直有效，如果定义在函数外，则在编译单元内可见，如果在函数内，在在定义的block内可见；
static函数：在编译单元内可见；

--------------------------------------------------------------------------
38.用C 写一个输入的整数,倒着输出整数的函数,要求用递归方法 ;

答:
void fun( int a )
{
 printf( "%d", a%10 );
 a /= 10;
 if( a <=0 )return;

 fun( a );
}

--------------------------------------------------------------------------
39.写出程序结果:
void Func(char str[100])
{
  printf("%d\n", sizeof(str));
}

答:
4
分析:
指针长度

--------------------------------------------------------------------------
40.int id[sizeof(unsigned long)];
    这个对吗？为什么??

答:
对
这个 sizeof是编译时运算符，编译时就确定了
可以看成和机器有关的常量。


本文主要包括二个部分，第一部分重点介绍在VC中，怎么样采用sizeof来求结构的大小，以及容易出现的问题，并给出解决问题的方法，第二部分总结出VC中sizeof的主要用法。 

1、 sizeof应用在结构上的情况 

请看下面的结构： 

struct MyStruct 

{ 

double dda1; 

char dda; 

int type 

}; 

对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求： 

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 

但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗？ 

其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了"对齐"处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)。 

类型 
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量） 

Char 
偏移量必须为sizeof(char)即1的倍数 

int 
偏移量必须为sizeof(int)即4的倍数 

float 
偏移量必须为sizeof(float)即4的倍数 

double 
偏移量必须为sizeof(double)即8的倍数 

Short 
偏移量必须为sizeof(short)即2的倍数 


各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍?/textarea>