C++面试问题总结 1

/* scanf / printf 的返回值是什么？ */

int scanf (const char *restrict format, ...)
scanf函数返回成功读入的数据项数，读到文件末尾出错则返回EOF
int printf(const char *format, [argument], ...);
返回成功打印的字符数，若错误返回一个负值

/* __cdecl关键字是什么？ */

__cdecl 是C语言默认的调用惯例
（栈底为高地址，栈顶为低地址）


参数传递：从右至左的顺序压参数入栈
出栈方：  函数调用方
名字修饰：直接在函数名称前加一个下划线


int fun (int n, float m);


1.将m压入栈    2.将n压入栈    


3.调用_fun，此步分两个步骤 （a.将返回地址压入栈（即调用)_fun之后的下一条指令的地址）  b.跳转到_fun执行）


__cdecl是调用者维护栈平衡，就是参数入栈了多少字节，就要弹出多少字节，还原调用栈之前的状态


/* 函数调度方式有几种？ 分别描述 */

其他几种调用惯例：


      出栈方  参数传递    


  stdcall      函数本身        从右至左顺序入栈    
  
  fastcall     函数本身        头两个DWORD类型     
                      或占更少字节的参数
                      被放入寄存器，其他
                       剩下的参数从右到左
                      顺序入栈


  pascal       函数本身   从左至右顺序入栈


  

  特殊：

        nakedcall    

特点是编译器不产生任何保护寄存器的代码


thiscall
C++特有，专用于类成员函数的调用


/* 为什么参数要从右至左入栈？ */

参数入栈顺序从右至左的好处就是可以动态变化参数个数


可变参数主要通过第一个定参确定参数列表，从右至左入栈后，函数调用时pop出第一个参数就是参数列表的第一个定参
（若从左至右入栈，最前面的参数被压在栈底，除非知道参数个数，否则无法通过栈指针的相对位移求得）


如果支持可变参的函数，参数入栈顺序几乎必然是自右向左入栈；并且参数出栈也不能由函数自己完成，而应该由调用者完成。
（因为函数自身不知道调用者传入了多少参数，需要调用者负责将所有参数出栈）
（自右向左规则下，最左边的定参后入栈，离函数调用点有确定的距离）


/*
------------------------------------------------------------------------------------------
*/

/* 宏定义都有哪些用法？ */

宏定义常用方法


1. 简单文本替换


#define MAX 10


MAX在预编译时会替换成10，将特殊的值定义宏以增加代码的可读性，且方便修改




2.带参数的宏


#define max(a,b) ((a)>(b)? (a),(b))


类似于函数一样接受参数，需要注意对每个参数加上括号，防止替换后出现优先级错误




3.防止多个文件对一个头文件重复引用


#ifndef _STDIO_H_


#define _STDIO_H_


#endif




4.条件编译


可以在编译的同时设置编译环境，在跨平台和系统的开发中常用
#ifdef WINDOWS


...


#endif


#ifdef LINUX


...


#endif




5.define中的三个特殊符号：#，##，#@


 #define Conn(x,y) x##y // 表示x连接y


 int num = Con(123,456);   num = 123456
 char* str = Con("abc","def"); str = "abcdef" 


 #define ToChar(x) #@x // 字符化操作符，返回一个const char
 
 char ch = ToChar(1);  a = '1'
 （参数转换后若超出变量的大小，编译器会报错）


 #define ToString(x) #x // 字符串化操作符


 string str = ToString(123abc);  str = "123abc"

/* inline 关键字是什么？ 它与宏定义有什么区别？ */


inline 是C/C++中的一个关键字，用来定义一个类的内联函数
引入它的原因是为了替代表达式形式的宏定义


C中可定义带参数的宏，这种宏在形式与使用上类似于函数，但用预编译器实现，没有参数压栈、代码生成的过程，
效率很高；但宏定义不具有检查参数的功能，在使用上仅仅是符号的替换，存在一系列隐患


C++中引入了类与类的访问控制，当一个操作涉及到类的private/protected成员，就不能以宏定义实现（无法传入this指针）



inline 消除了宏定义的缺点，同时又继承了宏定义的优点：


1. inline 定义类的内联函数，函数的代码被放入符号表中。在使用时直接替换，没有调用的开销


2. 类的内联函数在调用时，会检查参数类型，消除了隐患


3. inline 作为类的成员函数，可以访问类的private/protected成员



在类中定义不需要inline修饰。编译器自动化为内联函数；在类外定义时需要在前面添加inline关键字


此外，inline 对于编译器来说只是一种可忽略的建议，比如一个长达1000行的函数指定成inline，
编译器就会忽略这个inline ，将这函数还原成普通函数。


一般来说，内联机制适用于体积小只有几行的函数，它节省了一些调用函数的开销，但会造成重复代码增多，函数的体积增大导致整个程序臃肿。一方面增加了内存的负担，另一方面代码的执行是将代码移动至缓存，cpu再执行缓存中的代码，因此代码的臃肿会导致缓存命中几率下降，缓存又会从主存加载指令，严重影响时间效率。

因此，对于短小的函数可以使用inline提高速率，但长了反而会拖慢效率，这时适用于普通函数。


内联函数应该在头文件中定义，因为内联函数的定义对编译器必须是可见的，以便编译器能够在调用点展开该函数的代码。

/* C++ const 定义的常变量与宏定义有什么区别？ */


C++常变量与宏定义的区别


1. 编译器处理方式不同
define是在预处理阶段展开
const是编译运行阶段使用


2.类型和安全检查不同
define 没有类型  纯替换
const有具体的类型，在编译阶段会执行类型检查


3.存储方式不同
define仅仅是展开
const会分配内存


#define 没有作用域，如果没有#undef是一直有效的，可能会污染其他人写的变量；
而const是有作用域的
const 可以节省空间
编译器会对const定义的变量优化：当常变量被引用或取地址时，分配空间，避免访问内存的低效率（全局变量）


const double Pi = 3.14
double i = Pi // 此时为Pi分配内存
double j = Pi // 没有内存分配


/* 以下程序的输出是什么？为什么？ */


#include <iostream>
using namespace std;


void main()
{
    const int a = 10;
    int b = 0;
    int *p = (int*)&a;
    *p = 100;
    b = a;
    cout<<"a = "<<a<<endl;
    cout<<"b = "<<b<<endl;
    cout<<"*p = "<<*p<<endl;
}


输出结果为：
a = 10
b = 10
*p = 100


a是一个常变量，它的值在编译期间已经确定，p指向a的地址，并将a所在地址的值修改成了100，所以p解引用后输出的值为100
而变量b赋值成a的时候，实际相当于 b = 10 ，当出现a这个符号的时候自动识别成10


/*
------------------------------------------------------------------------------------------
*/

/* 为什么C++里声明类要加分号？ */

C++里不加分号，后面可以直接写变量名，就可以在声明类的同时，声明一个这个类的实例。
分号是告诉编译器，这个声明到此为止，没有后面的变量名了；
类是声明而不是定义所以不占空间，类似于函数声明需要加分号，而函数定义不需要。



/*
------------------------------------------------------------------------------------------
*/

/* 什么是函数重载？它是如何实现的？ */


C++中函数重载的实现


1. 编译器解决命名冲突


编译器会将重载的函数根据函数的作用域、参数列表修改函数签名，从而解决命名冲突


class test{
public:
    void print(int i)
    {
        cout<<"int i"<<endl;
    }


    void print(char ch)
    {
        cout<<"char ch"<<endl;
    }
};




void print(int i);   -->  _ZN4test5printEi
void print(char ch); -->  _ZN4test5printEc




2. 重载函数调用匹配


重载函数定义完成后，按照规则判断匹配函数：


精确匹配：参数匹配不需要做转换;
提升匹配：即整数提升bool -> int , char -> int ... 以及float -> double;
标准转换匹配：如 int -> double 、double -> int;


void print(int);
void print(const char*);
void print(double);
void print(long);
void print(char);


void test(char c,int i,short s,float f)
{
    print(c); // 精确匹配，调用print(char)
    print(i); // 精确匹配，调用print(int)
    print(s); // 整数提升，调用print(int)
    print(f); // float提升double，调用print(double)


    print('a'); // 精确匹配，调用print(char)
    print(49); // 精确匹配，调用print(int)
    print(0); // 精确匹配，调用print(int)
    print("a"); // 精确匹配，调用print(const char*)
}


注意：定义太少或太多的重载函数，都会导致歧义性


void fun(char*);
void fun(int*);

fun(0);// 这里两个函数都可以匹配，编译器会报错