【C/C++面经_基础语法_(1)】

1、在main执行之前和之后执行的代码可能是什么？

main函数执行之前，主要就是初始化系统相关资源：

• 设置栈指针
• 初始化静态static变量和global全局变量，即 .data段内容
• 将未初始化部分的全局变量赋初值：数值型short，int，long等为0，bool为FALSE，指针为NULL等等，即==.bss==段的内容
• 全局对象初始化，在main之前调用构造函数，这是可能会执行前的一些代码
• 将main函数的参数argc，argv等传递给main函数，然后才真正运行main函数
• —attribute—((constructor))
  main函数执行之后：
• 全局对象的析构函数会在main函数之后执行;
• 可以用atexit注册一个函数，他会在main之后执行；
• —attribute—((destructor))

2、结构体内存对齐问题？

• 结构体内成员按照声明顺序存储，第一个成员地址和整个结构体地址相同；
• 未经特殊说明时，按结构体中size最大的成员对齐（若有double成员，按8字节对齐。）
  c++11以后引入两个关键字alignas与alignof。其中alignof可以计算出类型的的对齐方式，alignas可以指定结构体的对齐方式。
  但是alignas在某些情况下是不能使用的的，具体如下：

// alignas 生效的情况
srtuct Info{
	uint8_t a;
	uint16_t b;
	uint8_t c;
};
std::cout << sizeof(Info) << std::endl;   // 6  2 + 2 + 2
std::cout << alignof(Info) << std::endl;  // 2

struct alignas(4) Info2 {
  uint8_t a;
  uint16_t b;
  uint8_t c;
};

std::cout << sizeof(Info2) << std::endl;   // 8  4 + 4
std::cout << alignof(Info2) << std::endl;  // 4

alignas 将内存对齐调整为 4 个字节。所以 sizeof(Info2) 的值变为了 8。

// alignas 失效的情况

struct Info {
  uint8_t a;
  uint32_t b;
  uint8_t c;
};

std::cout << sizeof(Info) << std::endl;   // 12  4 + 4 + 4
std::cout << alignof(Info) << std::endl;  // 4

struct alignas(2) Info2 {
  uint8_t a;
  uint32_t b;
  uint8_t c;
};

std::cout << sizeof(Info2) << std::endl;   // 12  4 + 4 + 4
std::cout << alignof(Info2) << std::endl;  // 4

若 alignas 小于自然对齐的最小单位，则被忽略。

• 如果想使用 单字节对齐 的方式，使用 alignas 是无效的。应该使用 #pragma pack(push,1) 或者使用 —attribute—((packed)) 。

#if defined(__GNUC__) || defined(__GNUG__)
  #define ONEBYTE_ALIGN __attribute__((packed))
#elif defined(_MSC_VER)
  #define ONEBYTE_ALIGN
  #pragma pack(push,1)
#endif

struct Info {
  uint8_t a;
  uint32_t b;
  uint8_t c;
} ONEBYTE_ALIGN;

#if defined(__GNUC__) || defined(__GNUG__)
  #undef ONEBYTE_ALIGN
#elif defined(_MSC_VER)
  #pragma pack(pop)
  #undef ONEBYTE_ALIGN
#endif

std::cout << sizeof(Info) << std::endl;   // 6 1 + 4 + 1
std::cout << alignof(Info) << std::endl;  // 6

• 确定结构体中每个元素大小可以通过下面这种方法:

#if defined(__GNUC__) || defined(__GNUG__)
  #define ONEBYTE_ALIGN __attribute__((packed))
#elif defined(_MSC_VER)
  #define ONEBYTE_ALIGN
  #pragma pack(push,1)
#endif

/**
* 0 1   3     6   8 9            15
* +-+---+-----+---+-+-------------+
* | |   |     |   | |             |
* |a| b |  c  | d |e|     pad     |
* | |   |     |   | |             |
* +-+---+-----+---+-+-------------+
*/
struct Info {
  uint16_t a : 1;
  uint16_t b : 2;
  uint16_t c : 3;
  uint16_t d : 2;
  uint16_t e : 1;
  uint16_t pad : 7;
} ONEBYTE_ALIGN;

#if defined(__GNUC__) || defined(__GNUG__)
  #undef ONEBYTE_ALIGN
#elif defined(_MSC_VER)
  #pragma pack(pop)
  #undef ONEBYTE_ALIGN
#endif

std::cout << sizeof(Info) << std::endl;   // 2
std::cout << alignof(Info) << std::endl;  // 1

这种处理方式是 alignas 处理不了的。

3、指针和引用的区别

• 指针是一个变量，存储的是一个地址，引用跟原来的变量实质上是同一个东西，是原变量的别名
• 指针可以有多级，引用只有一级
• 指针可以为空，引用不能为NULL且定义是必须初始化
• 指针在初始化后可以改变指向，而引用在初始化之后不可在改变
• sizeof指针得到的是本指针的大小，sizeof引用得到的是引用所指向变量的大小
• 当把指针作为参数进行传递时，也是将实参的一个地址拷贝传递给形参，两者指向的地址相同，但不是同一个变量，在函数中改变这个变量的指向不影响实参，而引用却可以
• 引用的本质是一个指针，同样会占4字节内存；指针是具体变量，需要占用存储空间（具体情况还要具体分析）
• 引用在声明时候必须初始化为另一个变量，一旦出现必须为 typename refname &varname 形式；指针声明和定义可以分开，可以先只声明指针变量而不初始化，等用到时再指向具体变量。
• 引用一旦初始化之后就不可以再改变（变量可以被引用为多次，但引用只能作为一个变量引用）；指针变量可以重新指向别的变量。
• 不存在指向空值的引用，必须有具体实体；但是存在指向空值的指针。

参考代码：

void test(int *p)
{
　　int a=1;
　　p=&a;
　　cout<<p<<" "<<*p<<endl;
}

int main(void)
{
    int *p=NULL;
    test(p);
    if(p==NULL)
    cout<<"指针p为NULL"<<endl;
    return 0;
}
//运行结果为：
//0x22ff44 1
//指针p为NULL


void testPTR(int* p) {
    int a = 12;
    p = &a;

}

void testREFF(int& p) {
    int a = 12;
    p = a;

}
void main()
{
    int a = 10;
    int* b = &a;
    testPTR(b);//改变指针指向，但是没改变指针的所指的内容
    cout << a << endl;// 10
    cout << *b << endl;// 10

    a = 10;
    testREFF(a);
    cout << a << endl;//12
}

在编译器看来, int a = 10; int &b = a; 等价于 int * const b = &a; 而 b = 20; 等价于 *b = 20; 自动转换为指针和自动解引用.

4、在传递函数参数时，什么时候使用指针，什么时候该使用引用呢？

• 需要返回函数内局部变量的内存的时候用指针。使用指针传参需要开辟内存，用完要记得释放指针，不然会内存泄漏。而返回局部变量的引用是没有意义的
• 对栈空间大小比较敏感（比如递归）的时候使用引用。使用引用传递不需要创建临时变量，开销要更小
• 类对象作为参数传递的时候使用引用，这是C++类对象传递的标准方式

5、堆和栈的区别

• 申请方式不同：
  • 栈由系统自动分配
  • 堆是自己申请和释放的
• 申请大小限制不同：
  • 栈顶和栈底是之前预设好的，栈是向栈底扩展，大小固定，可以通过 ulimit -a 查看，由 ulimit -s 修改。
  • 堆向高地址扩展，是不连续的内存区域，大小可以灵活调整。
• 申请效率不同：
  • 栈由系统分配，速度快，不会有碎片。
  • 堆由程序员分配，速度慢，且会有碎片。
• 栈空间默认是4M, 堆区一般是 1G - 4G

	堆	栈
管理方式	堆中资源由程序员控制（容易产生memory leak）	栈资源由编译器自动管理，无需手工控制
内存管理机制	系统有一个记录空闲内存地址的链表，当系统收到程序申请时，遍历该链表，寻找第一个空间大于申请空间的堆结点，删 除空闲结点链表中的该结点，并将该结点空间分配给程序（大多数系统会在这块内存空间首地址记录本次分配的大小，这样delete才能正确释放本内存空间，另外系统会将多余的部分重新放入空闲链表中）	只要栈的剩余空间大于所申请空间，系统为程序提供内存，否则报异常提示栈溢出。（这一块理解一下链表和队列的区别，不连续空间和连续空间的区别，应该就比较好理解这两种机制的区别了）
空间大小	堆是不连续的内存区域（因为系统是用链表来存储空闲内存地址，自然不是连续的），堆大小受限于计算机系统中有效的虚拟内存（32bit 系统理论上是4G），所以堆的空间比较灵活，比较大	栈是一块连续的内存区域，大小是操作系统预定好的，windows下栈大小是2M（也有是1M，在 编译时确定，VC中可设置）
碎片问题	对于堆，频繁的new/delete会造成大量碎片，使程序效率降低	对于栈，它是有点类似于数据结构上的一个先进后出的栈，进出一一对应，不会产生碎片。（看到这里我突然明白了为什么面试官在问我堆和栈的区别之前先问了我栈和队列的区别）
生长方向	堆向上，向高地址方向增长。	栈向下，向低地址方向增长。
分配方式	堆都是动态分配（没有静态分配的堆）	栈有静态分配和动态分配，静态分配由编译器完成（如局部变量分配），动态分配由 alloca 函数分配，但栈的动态分配的资源由编译器进行释放，无需程序员实现。
分配效率	堆由C/C++函数库提供，机制很复杂。所以堆的效率比栈低很多。	栈是其系统提供的数据结构，计算机在底层对栈提供支持，分配专门 寄存器存放栈地址，栈操作有专门指令。

形象的比喻:

栈就像我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。

堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

6、你觉得堆快一点还是栈快一点？

毫无疑问是栈快一点。

因为操作系统会在底层对栈提供支持，会分配专门的寄存器存放栈的地址，栈的入栈出栈操作也十分简单，并且有专门的指令执行，所以栈的效率比较高也比较快。

而堆的操作是由C/C++函数库提供的，在分配堆内存的时候需要一定的算法寻找合适大小的内存。并且获取堆的内容需要两次访问，第一次访问指针，第二次根据指针保存的地址访问内存，因此堆比较慢。

7、区别一下指针类型？

int *p[10]
int (*p)[10]
int *p(int)
int (*p)(int)

• int *p[10]表示指针数组，强调数组概念，是一个数组变量，数组大小为10，数组内每个元素都是指向int类型的指针变量。
• int (*p)[10]表示数组指针，强调是指针，只有一个变量，是指针类型，不过指向的是一个int类型的数组，这个数组大小是10。
• int *p(int)是函数声明，函数名是p，参数是int类型的，返回值是int *类型的。
• int (*p)(int)是函数指针，强调是指针，该指针指向的函数具有int类型参数，并且返回值是int类型的。

8、new / delete 与 malloc / free 的异同

相同点：

• 都可用于内存的动态申请和释放

不同点：

• 前者是C++运算符，后者是C/C++语言标准库函数
• new自动计算要分配的空间大小，malloc需要手工计算
• new是类型安全的，malloc不是。例如：

int *p = new float[2]; //编译错误
int *p = (int*)malloc(2 * sizeof(double));//编译无错误

• new调用名为operator new的标准库函数分配足够空间并调用相关对象的构造函数，delete对指针所指对象运行适当的析构函数；然后通过调用名为operator delete的标准库函数释放该对象所用内存。后者均没有相关调用
• 后者需要库文件支持，前者不用
• new是封装了malloc，直接free不会报错，但是这只是释放内存，而不会析构对象

9、new 和 delete 是如何实现的

• new的实现过程是： 首先调用名为operator new的标准库函数，分配足够大的原始为类型化的内存，以保存指定类型的一个对象；接下来运行该类型的一个构造函数，用指定初始化构造对象；最后返回指向新分配并构造后的的对象的指针
• delete的实现过程： 对指针指向的对象运行适当的析构函数；然后通过调用名为operator delete的标准库函数释放该对象所用内存

10、malloc 和 new 的区别

• malloc和free是标准库函数，支持覆盖；new和delete是运算符，不重载。
• malloc仅仅分配内存空间，free仅仅回收空间，不具备调用构造函数和析构函数功能，用malloc分配空间存储类的对象存在风险；new和delete除了分配回收功能外，还会调用构造函数和析构函数。
• malloc和free返回的是void类型指针（必须进行类型转换），new和delete返回的是具体类型指针。

本文主要是个人总结，为防止文章冗长，分为多篇博客发布（如有问题欢迎大家指出~）