[C++ 面试基础知识总结]表达式和语句

参考书籍：《C++ Primer》

目录

• C 面试基础知识总结表达式和语句
  • 目录
  • 运算符优先级
  • 算数运算符
    • 运算对象转换
    • 商和余数
  • 逻辑运算符
  • 强制转换类型
  • 数组形参和返回
  • 不能返回局部函数的指针和引用
  • 重载函数
  • 预处理器变量
  • 函数指针

运算符优先级

算数运算符

运算对象转换

小整数类型（bool，char，short）进行运算时通常会提升成较大的整数类型int。

bool b = true;
bool b2 = -b;

最终得到b2值为true，原因在于bool值不能直接进行算数运算，需要转化成int，-b的结果是-1，不等于0，所以b2的值为真。

商和余数

C++11新标准则规定商一律向0取整，所以-(m)/n和m/(-n)都等于-(m/n),m%(-n)等于m%n,(-m)%n等价于-(m%n)。

-21/ -8 // 根据商向0取整的原则，结果为2
-21% -8 // 由于商为2，余数为（-21-（-8）*2）=-5

21/ -5 // 根据商向0取整的原则，结果为-4
21% -5 // 由于商为-4，余数为（21-（-5）*（-4））=1

逻辑运算符

&&和||都是短路求值，仅当左侧运算对象无法确定表示结果时才会计算右侧运算对象。

#include <iostream>

int _tmain(int argc, _TCHAR* argv[])
{
    auto i = 0;
    if (++i == 1 || ++i == 0)
    {
        cout << i << endl;
    }
    return 0;
}

输出结果为1，因为执行++i == 1后，已经可以判定整个表达式为真了，不用再去计算右侧运算对象了，++i == 0没有执行，所以只对i进行了一次递增操作。

强制转换类型

static_cast可以进行不包含底层const的类型转换，const_cast 只能改变运算对象的底层const。

const char *p;
static_cast<char*p>(p); // 错误，不能用static_cast转换掉const
const_cast<char*p>(p); // 正确，const_cast去掉了const属性
static_cast<string>(p); // 正确，字符串字面值转换成string类型
const_cast<string>(p); // 错误，const_cast只能改变常量属性

数组形参和返回

数组是无法拷贝的，所以我们为函数传递一个数组时，实际上传递的是指向数组首元素的指针。函数也不能返回数组，只能返回数组的指针或引用。

//以下两个函数是等价的
void print(const int*);
void print(const int[]);
//以下两个函数是等价的
void print(int (*a)[]);
void print(int a[][]);

// 返回一个有10个元素的整型数组的指针，函数有一个int类型的形参i
int (*func(int i))[10];
// C++11的尾置返回类型写法，与上述声明等价
auto func(int i) -> int(*)[10];
// C++11中可用decltype，需要注意decltype并不负责把数组转化成指针,需要在声明函数的时候加一个*
int a[10];
decltype(a) *func(int i);

不能返回局部函数的指针和引用

局部对象在函数完成后，它所占的的存储空间也随之被释放掉，因此，函数终止意味着局部变量的指针或引用将指向不再有效的内存区域。

const string &func(){
    string ret;
        if (!ret.empty())
        {
            return ret;
        }
        else
        {
            return "Empty";
        }
}

两个返回都是错误的，试图返回局部变量或局部临时值的引用。

重载函数

重载函数名字和返回类型相同，但形参列表不同。顶层const不影响传入函数的对象，而底层const会。

int func(int*);
int func(double*); //正确重载函数，用于double型指针
void func(int*); //错误，只有返回类型不同
int func(const int*); //底层const，正确重载函数，用于常量整型指针
int func(int* const); //顶层const，重复声明

如果在内层作用域中声明名字，将会隐藏外层作用域的同名实体。在不同的作用域无法重载函数名。

string read();
void func(const string&);
void func(double):
int _tmain(int argc, _TCHAR* argv[])
{
    bool read = false;
    //错误，声明变量也会隐藏同名函数
    string s = read();
    void func(int);
    //错误，内层作用域中的的func函数隐藏了外层的func函数，现在的func只能接收int型参数。
    func("value");
    //不会报错，但是调用的是void func(int)
    func(3.14);
    return 0;
}

确定某次调用该选用哪个重载函数时会进行函数匹配，如果有且仅有一个函数匹配情况优于其它所有函数，则匹配成功，否则会因调用二义性而失败。
匹配优先级：
1.精确匹配：类型相同，数组类型或函数类型转化成对应的指针，顶层const
2.转换const
3.类型提升
4.算数类型转换或指针转换
5.类类型转换

void f();
void f(int);
void f(int,int);
void f(double,double);

//匹配到 f(double,double)
f(3.14);
//二义性，关于前一个参数f(int,int)更优，而后一个f(double,double)更优。
f(2,3.14);

void ff(int);
void ff(short);
void ff(float);

//匹配到ff(int)，小整数型会直接提升到int
ff('a');
//二义性，字面值3.14的类型是double，存在多种可能的算数型转换
ff(3.14);

预处理器变量

预处理定义的5个用于程序调试很有用的名字。

__FILE__  文件名
__func__  存放当前函数的名字
__LINE__  存放当前行号
__TIME__  存放文件编译时间
__DATE__  存放文件编译日期

函数指针

函数指针指向的是函数，它的类型由返回类型和形参共同决定。

bool func(int,int);
// p指向一个函数，该函数参数是两个int型整数，返回值是bool
bool (*p)(int,int);

//把函数名当作值使用会自动转化为指针，以下两个赋值等价
p = func;
p = &func;

//可以直接用指向函数的指针调用该函数，以下3个调用也等价
bool b1 = func(0,0);
bool b2 = p(0,0);
bool b3 = (*p)(0,0);

// f的形参为1个int型整数，返回值是一个指针，指向一个int*（int*,int）函数
int (*f(int))(int*,int);
// 等价写法
auto f(int) -> int*（int*,int）