C++程序员面试宝典——预处理、counst与sizeof

-------------------------------------------------基本原理----------------------------------------------------

C++程序设计三大难点:预处理、counst与sizeof

1. 预处理

C++从C语言那里把C语言预处理器继承过来(C语言预处理器,被Bjarne博士简称为Cpp)。

主要作用就是:    把通过预处理的内建功能对一个资源进行等价替换.

最常见的预处理有: 文件包含,条件编译、布局控制和宏替换4种。 

文件包含:    #include 是一种最为常见的预处理,主要是做为文件的引用组合源程序正文。 
条件编译:    #if,#ifndef,#ifdef,#endif,#undef等也是比较常见的预处理,主要是进行编译时进行有选择的挑选,注释掉一些指定的代码,以达到版本控制、防止对文件重复包含的功能。 
布局控制:    #progma,这也是我们应用预处理的一个重要方面,主要功能是为编译程序提供非常规的控制流信息。 
宏替换:    #define,这是最常见的用法,它可以定义符号常量、函数功能、重新命名、字符串的拼接等各种功能。

 (1)简单的宏定义

#define <宏名>  <字符串>

例: #define PI 3.1415926

(2) 带参数的宏定义

#define <宏名> (<参数表>) <宏体>

例: #define A(x) x

常见的预处理指令: 

     #define         宏定义 
     #undef          取消宏 
     #include        文本包含 
     #ifdef            如果宏被定义就进行编译 
     #ifndef          如果宏未被定义就进行编译 
     #endif           结束编译块的控制 
     #if                表达式非零就对代码进行编译 
     #else            作为其他预处理的剩余选项进行编译 
     #elif              这是一种#else和#if的组合选项 
     #line             改变当前的行数和文件名称 
     #error            输出一个错误信息 
     #pragma        为编译程序提供非常规的控制流信息 

2. const

Const 是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型,常类型的变量或对象的值是不能被更新的。

关于C++ const 的全面总结

Const主要有几点优势:

保护功能:便于进行类型检查;可以保护被修饰的东西;为函数重载提供了一个参考

时空效率:相比宏常量的反复分配内存空间,const常量只分配一次内存空间;编译器将它们保存在符号表中,成为编译常量,没有了存储与读取的操作。

指针使用CONST

(1)指针本身是常量不可变

     (char*) const pContent; 

     const (char*) pContent; 

(2)指针所指向的内容是常量不可变

     const (char) *pContent; 

     (char) const *pContent; 

(3)两者都不可变

      const char* const pContent; 

(4)还有其中区别方法,沿着*号划一条线

如果const位于*的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;(const在左—>内容常量)

如果const位于*的右侧,const就是修饰指针本身,即指针本身是常量。(const在右—>指针常量)

函数中使用CONST

任何不修改数据成员的函数都应该被定义为const成员函数。

常量函数结尾使用const,表明该函数不会修改调用的实参。

像一般的输出函数display(),print(),show()等都可定义为常量函数。

如:int size()  const;

如果const放在函数开头,一般用来表示返回一个常量。

a.传递过来的参数在函数内不可以改变(无意义,因为Var本身就是形参)

void function(const int Var);

b.参数指针所指内容为常量不可变

void function(const char* Var);

c.参数指针本身为常量不可变(也无意义,因为char* Var也是形参)

void function(char* const Var);

d.参数为引用,为了增加效率同时防止修改。修饰引用参数时:

void function(const Class& Var); //引用参数在函数内不可以改变

将Const类型转化为非Const类型的方法

采用const_cast 进行转换。  

用法:const_cast <type_id>  (expression) 

类里面的成员变量加mutable修饰const成员函数,就可以修改它了。

对比学习内容:volatile

与const一样,volatile是一个类型修饰符。如果不加入volatile:要么无法编写多线程程序,要么编译器失去大量优化的机会。

volatile的作用是: 作为指令关键字,确保本条指令不会因编译器的优化而省略,且要求每次直接读值

使用该关键字的例子如下:

volatile int vint;

当要求使用volatile 声明的变量的值的时候,系统总是重新从它所在的内存读取数据,即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。volatile 指出 i是随时可能发生变化的,每次使用它的时候必须从i的地址中读取,因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。

而优化做法是,由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作,它会自动把上次读的数据放在b中。如果i是一个寄存器变量或者表示一个端口数据就容易出错,所以说volatile可以保证对特殊地址的稳定访问

假设被面试者正确地回答了这是问题(嗯,怀疑是否会是这样),我将稍微深究一下,看一下这家伙是不是真正懂得volatile完全的重要性。

1). 一个参数既可以是const还可以是volatile吗?解释为什么。

2). 一个指针可以是volatile 吗?解释为什么。

3). 下面的函数被用来计算某个整数的平方,它能实现预期设计目标吗?如果不能,试回答存在什么问题:

int square(volatile int *ptr)
{
    return ((*ptr) * (*ptr));
}

下面是答案:

1). 是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2). 是的。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。

3). 这段代码是个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方,但是,由于*ptr指向一个volatile型参数,编译器将产生类似下面的代码:

int square(volatile int* &ptr)//这里参数应该申明为引用,不然函数体里只会使用副本,外部没法更改
{
    int a,b;
    a = *ptr;
    b = *ptr;
    return a*b;
}

由于*ptr的值可能在两次取值语句之间发生改变,因此a和b可能是不同的。结果,这段代码可能返回的不是你所期望的平方值!正确的代码如下:

long square(volatile int*ptr)

{
    int a;
    a = *ptr;
    return a*a;
}

3. sizeof

C++ sizeof用法 .

sizeof不是函数,更像一个特殊的宏,它是在编译阶段求值的。

cout<<sizeof(int)<<endl; // 32位机上int长度为4
cout<<sizeof(1==2)<<endl; // == 操作符返回bool类型,相当于 cout<<sizeof(bool)<<endl;
在编译阶段已经被翻译为:

cout<<4<<endl;
cout<<1<<endl;

这里有个陷阱,看下面的程序:

int a = 0;
cout<<sizeof(a=3)<<endl;
cout<<a<<endl;
  输出为什么是4,0而不是期望中的4,3???就在于sizeof在编译阶段处理的特性。由于sizeof不能被编译成机器码,所以sizeof作用范围内,也就是()里面的内容也不能被编译,而是被替换成类型。=操作符返回左操作数的类型,所以a=3相当于int,而代码也被替换为:
int a = 0;
cout<<4<<endl;
cout<<a<<endl;

sizeof有两种用法:

(1)sizeof(object)

也就是对对象使用sizeof,也可以写成sizeof object 的形式。

(2)sizeof(typename)

也就是对类型使用sizeof,注意这种情况下写成sizeof typename是非法的。

任何时候,加括号总是对的。

sizeof的指针问题 

考虑下面问题:

cout<<sizeof(string*)<<endl; // 4
cout<<sizeof(int*)<<endl; // 4
cout<<sizof(char****)<<endl; // 4
可以看到,不管是什么类型的指针,大小都是4的,因为指针就是32位的物理地址。

结论:只要是指针,大小就是4(64位机变成8字节)。 但是其指向的变量占用不同大小的存储空间。

C++ STL vector:sizeof(vector)

向函数传递数组的问题

#include <iostream>
using namespace std; 

int Sum(int i[])
{
 int sumofi = 0;
 for (int j = 0; j < sizeof(i)/sizeof(int); j++) //实际上,sizeof(i) = 4
 {
  sumofi += i[j];
 }
 return sumofi;
} 

int main()
{
 int allAges[6] = {21, 22, 22, 19, 34, 12};
 cout<<Sum(allAges)<<endl;
 system("pause");
 return 0;
}
Sum的本意是用sizeof得到数组的大小,然后求和。但是实际上,传入自函数Sum的,只是一个int 类型的指针,所以sizeof(i)=4,而不是24,所以会产生错误的结果。解决这个问题的方法使是用指针或者引用。

int Sum(int (*i)[6])
{
 int sumofi = 0;
 for (int j = 0; j < sizeof(*i)/sizeof(int); j++) //sizeof(*i) = 24
 {
  sumofi += (*i)[j];
 }
 return sumofi;
} 

int main()
{
 int allAges[] = {21, 22, 22, 19, 34, 12};
 cout<<Sum(&allAges)<<endl;
 system("pause");
 return 0;
}
在这个Sum里,i是一个指向i[6]类型的指针,注意,这里不能用int Sum(int (*i)[])声明函数,而是必须指明要传入的数组的大小,不然sizeof(*i)无法计算。但是在这种情况下,再通过sizeof来计算数组大小已经没有意义了,因为此时大小是指定为6的。

此外,对函数使用sizeof,在编译阶段会被函数的返回值类型取代。

struct的sizeof问题 

例如,下面的结构各成员空间分配情况:

struct test  
{  
     char x1;  
     short x2;  
     float x3;  
     char x4;  
};  
结构的第一个成员x1,其偏移地址为0,占据了第1个字节。

第二个成员x2为short类型,其起始地址必须2字节对界,因此,编译器在x2和x1之间填充了一个空字节。

结构的第三个成员x3和第四个成员x4恰好落在其自然对界地址上,在它们前面不需要额外的填充字节。

在test结构中,成员x3要求4字节对界,是该结构所有成员中要求的最大对界单元,因而test结构的自然对界条件为4字节,编译器在成员x4后面填充了3个空字节。整个结构所占据空间为12字节。

因为对齐问题使结构体的sizeof变得比较复杂,看下面的例子:(默认对齐方式下) 

struct s1
{
 char a;
 double b;
 int c;
 char d; 
}; 

struct s2
{
 char a;
 char b;
 int c;
 double d;
}; 

cout<<sizeof(s1)<<endl; // 24
cout<<sizeof(s2)<<endl; // 16
对于s1,首先把a放到8的对界,假定是0,此时下一个空闲的地址是1,但是下一个元素d是double类型,要放到8的对界上,离1最接近的地址是8了,所以d被放在了8,此时下一个空闲地址变成了16,下一个元素c的对界是4,16可以满足,所以c放在了16,此时下一个空闲地址变成了20,下一个元素d需要对界1,也正好落在对界上,所以d放在了20,结构体在地址21处结束。由于s1的大小需要是8的倍数,所以21-23的空间被保留,s1的大小变成了24。

对于s2,首先把a放到8的对界,假定是0,此时下一个空闲地址是1,下一个元素的对界也是1,所以b摆放在1,下一个空闲地址变成了2;下一个元素c的对界是4,所以取离2最近的地址4摆放c,下一个空闲地址变成了8,下一个元素d的对界是8,所以d摆放在8,所有元素摆放完毕,结构体在15处结束,占用总空间为16,正好是8的倍数。

这里有个陷阱,对于结构体中的结构体成员,不要认为它的对齐方式就是他的大小,看下面的例子: 

struct s1
{
 char a[8];
}; 

struct s2
{
 double d;
}; 

struct s3
{
 s1 s;
 char a;
}; 

struct s4
{
 s2 s;
 char a; 
}; 

cout<<sizeof(s1)<<endl; // 8
cout<<sizeof(s2)<<endl; // 8
cout<<sizeof(s3)<<endl; // 9
cout<<sizeof(s4)<<endl; // 16;
s1和s2大小虽然都是8,但是s1的对齐方式是1,s2是8(double),所以在s3和s4中才有这样的差异。

所以,在自己定义结构体的时候,如果空间紧张的话,最好考虑对齐因素来排列结构体里的元素。 

-------------------------------------------- 易错题 ----------------------------------------------

1. 用预处理指令#define声明一个常数,用以表明一年中有多少秒。

这是一个简单宏定义,考察三点:

(1)#define不能以分号结尾,括号使用。

(2)预处理器将为你计算常数表达式的值,因此写入计算式子比计算结果重要。

(3)意识到16位机将有一个整形数溢出,因此使用长整形,因此用到长整形符号UL。

答案:#define SECORES_PRE_YEAR (60*60*24*365) UL

2. 写一个标准宏,返回两个数较小那个。

这是一个带参数的宏,需要用到三元运算符。

答案:#define MIN(a,b) (a<=b ? a : b)

3. Const与define的区别?

二者都可以定义常量,区别在两点:

const常量有数据类型,宏常量没有数据类型。前者可进行安全检查,后者只进行字符替换,可能产生边际效应。

Const节省内存空间,存在编译器中,省去多余存取时间。

C++程序中Const常量完全取代宏常量。

C中默认const是外部连接,C迫使程序员使用#define。C++中默认const是内部连接,如果要定义外部连接,需要用extern const bufsize; //只声称

例如:const buffsize=100; char buf[bufsize];  看起来是对的,但实际上buffsize占用了一部分内存,C编译器并不知道它在编译时候的值。可以选择这样写:

const buffsize;

内部连接和外部连接

4. sizeof与strlen的区别

sizeof度量内存空间大小,strlen度量char*指向的字符串长度而且必须以‘\0’结尾;

sizeof是运算符,strlen是函数;

当使用结构类型或者变量时,sizeof返回实际大小,使用静态空间时,返回全部数组的尺寸(计算结构变量大小必须考虑对齐问题);

sizeof不能用于函数类型、不完全类型(未知存储大小、void、未知内容)、或位字段。

例1: char ss[100]=“0123456789”;

sizeof(ss)结果为400;strlen(ss)结果为11。

例2:int ss[100]="0123456789";

sizeof(ss)结果为400;strlen(ss)错误,参数不是char类型。

例3:char* ss[100]=“0123456789”;//ss是指针

sizeof(ss)结果为4,ss是指针,指针在32位系统大小固定为4B。

sizeof(*ss)结果为1,ss指针指向的第一个字符。

例4:char ss[ ]=“0123456789”;//ss是数组

sizeof(ss)结果为11,ss是数组,计算到“\0”位置。

sizeof(*ss)结果为1,*ss是第一个字符。

5.sizeof用途:

与存储分配和I/O系统类似例程进行通信;

查看某种类型的对象在内存中所占的单元字节;

给出动态分配内存的大小;

便于类型扩充。

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

(1)内联函数可以加快程序运行。因为不需要中断调用,而宏只是一个简单的替换。

(2)内联函数要做参数类型检查。

内联函数适用于:一个函数不断地被调用;函数只有简单的几行。

发布了392 篇原创文章 · 获赞 492 · 访问量 241万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览