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

时间：2024-08-31 14:34:50
  • 首先来一个关于const的全面的解释，先看一波代码，之后再进行详细的分情况解释 
    int b=;
    
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 = "";
    
    char ss2[] = "";
    
    char ss3[] = "";
    
    int ss4[];
    
    char q1[] = "abc";
    
    char q2[] = "a\n";
    
    char* q3 = "a\n";
    
    char *str1 = (char *)malloc();
    
    void *str2 = (void *)malloc();
    
    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 ;
    
}

    解析：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字节。
    结果：：
    C++面试笔记--const、sizeof

    这里补充一下在不同位数的系统中，各种数据类型所占用的字节数：（一般都是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[]
    
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 ;
    
}

    以上答案分别是1，1，4，1。这说明空类所占空间为 1，单一继承的空类空间也是 1，多重继承的空类空间还是 1，但是虚继承涉及虚表（虚指针），所以大小为 4。

    答案：

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

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

      • 内联函数一般用于以下情况：
        ①：一个函数不断被重复的调用
        ②：函数只有简单的几行，且函数内包含for，while，switch语句。当我们进行一个工程项目的时候，如果有一小段代码频繁的出现，我们可以定义为内联函数。

相关文章