程序员面试宝典 6 - 预处理、const 与sizeof

1.宏定义

（1）用预处理指令#define 声明一个常数，泳衣表明1年中有多少米哦啊（忽略闰年问题）

#define SECONDS_PER_YEAR (60*60*24*360)UL    //小心溢出，用long 

（2）.写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。

#define MAX(A,B)  (A)<=(B)?(A):(B)   //宏中最好把参数用括号括起来

2.const

（1）.

#include"stdio.h"
int main()
{
int b=50;
const int * a ;    //可以先不初始化
a = &b;
//*a = 10;    Error: 不能给常量赋值

//const int  e;     Error:必须初始化
extern const int  e;  //或者声明为外部连接

int * const c= &b;   //定义时必须初始化
printf("%d",++(*c));
//printf("%d",++c);  Error: 不能给常量赋值

//通过改变b的值改变a
b =60;
printf("%d",*a);   //60
//通过*a指向别处
int d=60;
a=&d;
printf("%d",*a);	//60
}

(2)const 和 #define区别

    1）   const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误（边际效应）。

    2）   有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

(3)sizeof 

#include<iostream>
#include"stdio.h"
using namespace std;
struct {
short a1;
short a2;
short a3;
}A;
struct {
long a1;
short a2;
}B;

int main()
{
char *ss1 ="0123456789";
char ss2[]="0123456789";
char ss3[100]="0123456789";
int ss4[100];
char q1[]="abc";
char q2[]="a\n";
char *str1=(char *) malloc(100);
void *str2=(void *) malloc(100);

cout<<sizeof(ss1)<<" ";   //4
cout<<sizeof(ss2)<<" ";   //11
cout<<sizeof(ss3)<<" ";   //100
cout<<sizeof(ss4)<<" ";   //400
cout<<sizeof(q1)<<" ";    //4
cout<<sizeof(q2)<<" ";    //3
cout<<sizeof(str1)<<" ";  //4
cout<<sizeof(str2)<<" ";  //4
cout<<sizeof(A)<<" ";      //6
cout<<sizeof(B)<<" ";      //8
}

2)

#include<iostream>
using namespace std;
class B {
private:
bool m_bTemp;                  //   | bool | ---  | ---  | --- |
int m_nTemp;                     //   |  --- -- --int----------|
bool m_bTemp2;				   //   | bool | ---  | ---  | --- |
};
class C {
private:
int m_nTemp;					  //   |  --- -- --int----------|
bool m_bTemp;				  //   | bool | bool | ---| --- |
bool m_bTemp2;
};

int main()
{
cout<<sizeof(B)<<endl;   //12
cout<<sizeof(C)<<endl;   //8
}

   3)sizeof和strlen的区别

1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned
int类型。 
2.sizeof是算符，strlen是函数。 
3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。 
4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。
5.大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因 
char str[20]="0123456789"; 
int a=strlen(str); //a=10; 
int b=sizeof(str); //而b=20; 
6.strlen的结果要在运行的时候才能计算出来，用来计算字符串的长度，不是类型占内存的大小。 
7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
8.当适用了于一个结构类型时或变量， sizeof 返回实际的大小，当适用一静态地空间数组， sizeof 归还全部数组的尺寸。 

   sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸 
9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址， 

           10.计算结构变量的大小必须讨论数据对齐问题

     4）空类和多继承类所占空间？

#include<iostream>
using namespace std;
class A{};
class B
{
private:
int a;
};
class C:public A
{
};
class D:public virtual A
{
};
int main()
{
A * a =new A();
B * b =new B();
cout<<sizeof(A)<<endl;    //1    空类
cout<<sizeof(a)<<endl;    //4

cout<<sizeof(B)<<endl;    //4
cout<<sizeof(b)<<endl;    //4

cout<<sizeof(C)<<endl;    //1
cout<<sizeof(D)<<endl;    //4   虚继承设计虚表（指针）
}

4.内联函数和宏定义的区别

1.内联函数在运行时可调试，而宏定义不可以;

2.编译器会对内联函数的参数类型做安全检查或自动类型转换（同普通函数），而宏定义则不会； 

3.内联函数可以访问类的成员变量，宏定义则不能； 

4.在类中声明同时定义的成员函数，自动转化为内联函数。

相同点：在预处理阶段，对代码块进行替换