C++ 必须会的笔试题

短小的函数在C语言中定义宏，C++中用内联函数。

计算一个类的大小

例如class A ,A OBJ; sizeof(A) == sizeof(OBJ), 一个类的大小怎么算？

静态的数据不算，虚函数包括纯虚函数在内，一个或者多个都只算一个，一个什么。一个指针指向一个虚函数表。所以这些加起来只有sizeof(*) = 4; 然后再加上其他非静态的数据，成员函数（包括静态与非静态）为0；

综上有人就说那么空类大小就是0？不是为1；那么是为什么？这就是我们刚才所说的实例化的原因（空类同样可以被实例化），每个实例在内存中都有一个独一无二的地址，为了达到这个目的，编译器往往会给一个空类隐含的加一个字节，这样空类在实例化后在内存得到了独一无二的地址

整形的范围 是：  -2147483648 ~2147483647；

短整型 是 ：-32768~32767

字符型 是： -128~127

#include <iostream>

using namespace std;

int main()

{

int a[5] ={1,2,3,4,5};

int *PA = (int *)(&a+1);

int *PB = (int *)(a+1);

cout<<*(PA-1)<<endl;    -> 5

cout<<*(PB-1)<<endl;    ->1;

return 0;

}

虚析构函数 ：

class A

{

public:

A()

{

cout<<"A()"<<endl;

}

( Virtual )  ~A()

{

cout<<" ~A()"<<endl;

}

protected:

private:

};

class B:public A

{

public:

B()

{

cout<<" B()"<<endl;

}

~B()

{

cout<<" ~B()"<<endl;

}

protected:

private:

};

int main()

{

  A *aobj;

  aobj = new B();

  delete aobj;

   return 0;

}

输出 A() B() ~A(),  

如果在A类的析构函数中加上Virtual 关键字，那么结果为 A() B() ~B() ~A()

如果是下面这样

int main()

{

  B *bobj;

  bobj = new B();

  delete bobj;

   return 0;

}

那么不管A的析构函数是否是虚函数，结果都是 A（）B() ~B() ~A()

Sizeof 用法：

 Sizeof 的一些常规的用法 ：

Int a[20 ] ; sizeof(a) = 20*4 = 80;

Char a[20]; sizeof(a) = 20*1 =20;

计算长度 ： sizeof(a)/ sizeof(int ) = 长度 = 20；

Int *a;  sizeof(a) = 4; 指针永远都是4

结构体中的sizeof 例如：

Struct s1

{

  Char c;

  Int i;

}

Sizeof(s1) =5 ? 错误 ，VC中为了cpu更快的处理 使用了默认的字节对齐方式：结果为8. 

char a1[] = "abc"; 

int a2[3]; 

sizeof( a1 ); // 结果为4，字符 末尾还存在一个NULL终止符 

sizeof( a2 ); // 结果为3*4=12（依赖于int）

函数的参数：

void foo3(char a3[3]) 

{ 

int c3 = sizeof( a3 ); // c3 == 4不是3传递的是指针函数指针也一样

} 

void foo4(char a4[]) 

{ 

int c4 = sizeof( a4 ); // c4 == 4；

}

联合体的sizeof：

结构体在内存上是顺序的，联合体是重叠式的，共享一块内存，所以整个联合体的sizeof 是其中最大的成员的sizeof 的值。

含位域结构体的sizeof

有几个规则：

1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止； 

2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍； 

struct BF1 

　　{ 

　　char f1 : 3; 

　　char f2 : 4; 

　　char f3 : 5; 

　　};

  sizeof(BF1)的结果为2。

3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式，Dev-C++采取压缩方式； 

struct BF2 

　　{ 

　　char f1 : 3; 

　　short f2 : 4; 

　　char f3 : 5; 

　　}; 

　　由于相邻位域类型不同，在VC6中其sizeof为6，在Dev-C++中为2。

4) 如果位域字段之间穿插着非位域字段，则不进行压缩； 

struct BF3 

　　{ 

　　char f1 : 3; 

　　char f2; 

　　char f3 : 5; 

　　}; 

非位域字段穿插其中，不会产生压缩，VC6和Dev-C++中得到的大小均为3。

5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。

Strlen 和 Sizeof 区别：

strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'\0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'\0'停止。

char aa[10];cout<<strlen(aa)<<endl; //结果是不定的 

char aa[10]={'\0'}; cout<<strlen(aa)<<endl; //结果为0 

char aa[10]="jun"; cout<<strlen(aa)<<endl; //结果为3 

而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度。

sizeof(aa) 返回10 

int a[10]; sizeof(a) 返回40

sizeof是算符，strlen是函数

数组做sizeof的参数不退化，传递给strlen就退化为指针了。

char str[20]="0123456789"; 

int a=strlen(str); //a=10; 

int b=sizeof(str); //而b=20;

char* ss = "0123456789";

sizeof(ss) 结果 4

sizeof(*ss) 结果 1

strlen(ss)= 10

char ss[100] = "0123456789";

sizeof(ss) 结果是100 

strlen(ss) 结果是10

int ss[100] = "0123456789";

sizeof(ss) 结果 400

strlen(ss) 错误===》strlen的参数只能是char* 且必须是以'\0'结尾的

char const * static_string = "Hello"; 

sizeof(static_string) 是 sizeof 一个指针，所以在 32bit system 是 4 

char stack_string[] = "Hello"; 

sizeof(stack_string) 是 sizeof 一个数组，所以是 6 * sizeof(char)