C++面试笔记--const、sizeof

首先来一个关于const的全面的解释，先看一波代码，之后再进行详细的分情况解释
```
int b=500;
const int *a=&b;//指向一个int常量的指针
int const *a=&b;//和上面类似
int * const a=&b;//一个常量的指针a指向一个地址
const int * const a=&b;//一个常量指针指向一个常量
```
情况①：第一个和第二个的情况是一样的。他们都是定义了一个指针a指向一个变量b的地址，之后a的指向是可以改变的，但是他指向的东西是一个常量
情况②：第三个表示的是a是一个常量的指针，*a不能够改变，就是它的指向是不能改变的，永远只能指向b的地址。但是它指向的那个东西不是一个常量，*const a在进行定义的时候就必须为它进行初始化，因为之后它是不能改变的了。
情况③：第四个表示的是a是一个常量指针，指向的东西也必须是一个常量。意思差不多就是情况1和情况2的结合。
之后我们再来看一下const的成员函数。
我们一般是在不需要改变对象的成员函数上面加上const，格式：int gety() const;表明这个函数里面的变量的值是不能进行修改的。
注：任何不需要修改成员数据的函数都是应该声明为const函数的。
面试题一：const与#define相比有什么不同？

C++语言可以用const定义常量，也可以用#define定义常量，但是前者比后者有更多的优点：

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

（2）有些集成话的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。在C++程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。
面试题二：const有什么用途？请至少说明两种？
（1）可以定义const常量。（2）const可以修饰函数的参数和返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
面试题三：在const成员函数中，如果想要修改函数中变量，该怎么办？
我们可以在类的成员变量前面加上mutable修饰词修饰，这样就能在const函数中修改成员变量了。
这里介绍sizeof的一些面试题
面试题一：
```
#include<iostream>
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* q3 = "a\n";
    char *str1 = (char *)malloc(100);
    void *str2 = (void *)malloc(100);
    cout<<"sizeof(ss1):"<<sizeof(ss1)<<endl;
   cout<<"sizeof(ss2):"<<sizeof(ss2)<<endl;
    cout<<"sizeof(ss3):"<<sizeof(ss3)<<endl;
    cout<<"sizeof(ss4):"<<sizeof(ss4)<<endl;
    cout<<"sizeof(q1):"<<sizeof(q1)<<endl;
    cout<<"sizeof(q2):"<<sizeof(q2)<<endl;
    cout<<"sizeof(q3):"<<sizeof(q3)<<endl;
    cout<<"sizeof(A):"<<sizeof(A)<<endl;
    cout<<"sizeof(B):"<<sizeof(B)<<endl;
    cout<<"sizeof(str1):"<<sizeof(str1)<<endl;
    cout<<"sizeof(str2):"<<sizeof(str2)<<endl;
    return 0;
}
```
解析：ss1是一个字符指针，指针的大小是一个定值，就是4字节，所以sizeof(ss1)是4字节

ss2是一个字符数组，这个数组最初未定大小，由具体填充值来定。填充值是“0123456789 ”。1个字符所占空间是1字节，10个就是10字节，再加上隐含的“\0”，所以一共是11字节。

ss3也是一个字符数组，这个数组开始预分配100，char类型占用空间（1），所以它的大小一共是100字节。

ss4也是一个整型数组，这个数组开始预分配100，但是每个整型变量（int）所占用空间是4，所以它的大小一共是400字节。

q1与ss2类似，所以是4字节。

q2里面有一个“\n”，“\n”算做一位，所以它的空间大小是3字节。

q3是一个字符指针，指针的大小是一个定值，就是4，所以sizeof(q3)是4字节。

A和B是两个结构体，在默认情况下，为了方便对结构体内元素的访问和管理，当结构体内的元素的长度都小于处理器的位数的时候，便以结构体里面最长的数据元素为对齐单位，也就是说，结构体的长度一定是最长的数据元素的整数倍。如果结构体内存在长度大于处理器位数的元素，那么就以处理器的位数为对齐单位，但是结构体内类型相同的连续元素将在连续的空间内，和数组一样。

结构体A中有3个short类型变量，各自以2个字节对齐，所以sizeof(A)是为6字节。结构体B中a1以4字节对齐，a2以2字节对齐，则结构体大小为6字节，但是结构体的长度一定是最长数据元素的整数倍，显然6不是4的整数倍数，补空字节，增到8字节，符合所以条件。故sizeof(B)为8字节。

str1和str2都是字符指针，都是4字节。
结果：：

这里补充一下在不同位数的系统中，各种数据类型所占用的字节数：（一般都是32位的）
16位编译器

char ：1个字节
char*(即指针变量): 2个字节
short int : 2个字节
int：  2个字节
unsigned int : 2个字节
float:  4个字节
double:   8个字节
long:   4个字节
long long:  8个字节
unsigned long:  4个字节

32位编译器

char ：1个字节
char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
short int : 2个字节
int：  4个字节
unsigned int : 4个字节
float:  4个字节
double:   8个字节
long:   4个字节
long long:  8个字节
unsigned long:  4个字节

除了*与long随操作系统子长变化而变化外，其他的都固定不变(32位和64相比)
面试题二：以下代码为32位机器编译，数据是以4字节为单位，这两个类型的输出结果为什么不同？
```
class B
{
private:
    bool m_bTemp1;
    int m_nTemp;
    bool m_bTemp2;
};
class C
{
private:
    int m_nTemp;
    bool m_bTemp1;
    bool m_bTemp2;
};
cout << sizeof(B) << endl;
cout << sizeof(C) << endl;
```
解析：编译器会对结构体进行对齐处理，根据对齐原则。

类型B情况如下：

| bool |-----|----|----|

|-----------int---------|

| bool |-----|----|----|

类型C情况如下：

|-----------int-----------|

| bool | bool |----|----|
事实表明，对齐原则十分靠谱，就这样计算的话准没错的。
面试题3：以下代码的输出结果是多少？
```
char var[10]
int test (char var[])
{
    return sizeof(var);
}
```
数组作为参数传递，传递的是一个首地址，等价于*var，已退化成一个指针了，所以大小是4。

答案：4.
一个空类占多少空间？多重继承的空类呢？
```
#include<iostream>
using namespace std;
class A1
{
};
class A2
{
};
class B : public A1
{
};
class C : public virtual B
{
};
class D : public A1,public A2
{
}; 
int main ()
{
    cout <<"sizeof(A1):" << sizeof(A1) << endl;
    cout <<"sizeof(B):" << sizeof(B) << endl;
    cout <<"sizeof(C):" << sizeof(C) << endl;
    cout <<"sizeof(D):" << sizeof(D) << endl;
    return 0;
}
```
以上答案分别是1，1，4，1。这说明空类所占空间为 1，单一继承的空类空间也是 1，多重继承的空类空间还是 1，但是虚继承涉及虚表（虚指针），所以大小为 4。

答案：
一个空类占空间为 1 ，多重继承的空类所占空间还是 1，但虚继承的为 4。

内联函数和宏的差别
①：内联函数和普通的函数相比可以加快程序运行的速度，因为不需要中断调用，在编译的时候内联函数可以直接被镶嵌到目标代码中，而宏只是一个简单的替换。
②：内联函数需要做参数类型检查，这个是它的优势。
③：inline通过增加空间消耗换来的是效率的提高，这方面和宏是一样的。但是inline更加安全。

posted @ 2016-05-26 15:47 Kobe10 阅读(995) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Kobe10

C++面试笔记--const、sizeof

公告