目录
面试题1. C语言为什么不支持重载?C++支持?C++底层是如何支持重载的?
1. C++关键字(C++98)
C++总计63个关键字,C语言32个关键字
2. 命名空间
在C/C++中,变量、函数和类都是大量存在的,这些变量、函数和类的名称将都存在于全局作用域中,可能会导致冲突。使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字 污染,namespace关键字的出现就是针对这种问题的。
2.1 命名空间定义
C语言中命名冲突问题:
//namespace 定义的是一个域
//用于解决C语言命名冲突问题
//eg:命名冲突
//C语言的库中,有两个函数用scanf和strlen名称
//假设代码里,想用这两个名称命名变量,就会产生冲突
int main()
{
//定义到局部不会报错,但用的时候会报错(定义到全局不用也会报错)
int scanf = 10;
int strlen = 20;
//以下均会报错,且C语言解决不了冲突的问题
scanf("%d", &scanf);
printf("%d\n", scanf);
printf("%d\n", strlen);
return 0;
}
定义命名空间,需要使用到namespace关键字,后面跟命名空间的名字,然后接一对{}即可,{}中即为命名空间的成员。
//使用C++命名空间,进行名字的隔离
//1. 普通的命名空间
namespace N1 // N1为命名空间的名称
{
//命名空间中的内容,既可以定义变量,也可以定义函数
int scanf = 10;
int strlen = 20;
int Add(int left, int right)
{
return left + right;
}
}
//2. 命名空间可以嵌套
namespace N2
{
int a;
int b;
int Add(int left, int right)
{
return left + right;
}
namespace N3
{
int c;
int d;
int Sub(int left, int right)
{
return left - right;
}
}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
//注意:同一个域里不能定义同名的变量或函数
namespace N1
{
int Mul(int left, int right)
{
return left * right;
}
}
int main()
{
//默认访问局部其次是全局
//由于局部没有,访问全局的头文件,所以此时打印的是库函数的地址
printf("%x\n", scanf); //411433
printf("%x\n", strlen); //4113d4
//指定访问N1命名空间
printf("%x\n", N1::scanf); //a
printf("%x\n", N1::strlen); //14
//指定命名空间后,才能调用N1里的函数
int a = N1::Add(1, 2);
printf("%d\n", a); //3
//访问嵌套命名空间的内容
int b = N2::N3::Sub(5, 3);
printf("%d\n", b); //2
return 0;
}
注:一个命名空间就定义了一个新的作用域,命名空间中的所有内容都局限于该命名空间中
2.2 命名空间的使用
C++库为了防止命名冲突,把自己库里的东西都定义在std的命名空间中,要使用标准库中的东西,有三种方式
① 加命名空间名称及作用域限定符
指定命名空间,缺陷: 麻烦,每个地方要用都要制定,但是这是最规范的使用方式
② 使用using namespace 命名空间名称引入
把std整个展开:using namespace std ,相当于库里的东西都到全局域了 ,缺陷: 如果自己定义的和库的冲突了就无法解决了,所以规范的工程项目中是不推荐这种方式的,日常练习无所谓
③ 使用using将命名空间中成员引入
对部分常用的库里面的东西展开,是针对1和2折中的方案,在项目中经常使用
//C++库为了防止命名冲突,把自己库里的东西都定义在了一个std的命名空间中
//要使用标准库中的东西,有三种方式
//1. 指定命名空间
// -> 缺陷: 麻烦,每个地方要用都要制定,但是这是最规范的使用方式
//2. 把std整个展开:using namespace std ,相当于库里的东西都到全局域了
// ->缺陷: 如果自己定义的和库冲突了就无法解决了
// 所以规范的工程项目中是不推荐这种方式的,日常练习无所谓
//3. 对部分常用的库里面的东西展开,是针对1和2折中的方案,在项目中经常使用
using std::cout;
using std::endl;
//using namespace std;
int main()
{
//1. 指定命名空间
std::cout << "hello world" << std::endl;
// 2.把std整个展开,上面写了using namespace std;下面直接用即可
cout << "hello world" << endl;
// 3.对部分常用的库里面的东西展开
cout << "hello world" << endl;
std::string s; //没展开的就不能直接使用
return 0;
}
3. C++输入&输出
#include<iostream>
//cout 是ostream类型全局对象
//cin 是istream类型全局对象
//endl 是全局的换行符号
int main()
{
std::cout << "hello world!" << std::endl;
//对比C语言printf和scanf区别是:
//可以自动识别类型
int a = 10;
int* p = &a;
//c语言打印
printf("%d,%p\n", a, p);
//c++打印
std::cout << a << "," << p << std::endl;
return 0;
}
说明:
1. 使用cout标准输出(控制台)和cin标准输入(键盘)时,必须包含< iostream >头文件以及std标准命名空间。
注意:早期标准库将所有功能在全局域中实现,声明在.h后缀的头文件中,使用时只需包含对应头文件即可,后来将其实现在std命名空间下,为了和C头文件区分,也为了正确使用命名空间,规定C++头文件不带.h;旧编译器(vc 6.0)中还支持格式,后续编译器已不支持,因此推荐使用 +std的方式。
2. 使用C++输入输出更方便,不需增加数据格式控制,比如:整形--%d,字符--%c
4. 缺省参数
4.1 缺省参数概念
缺省参数是声明或定义函数时为函数的参数指定一个默认值。在调用该函数时,如果没有指定实参则采用该默认值,否则使用指定的实参。缺省参数可以使调用更灵活。
//缺省参数
void TestFunc(int a = 0)
{
cout << a << endl;
}
int main()
{
TestFunc(); // 0,没有传参时,使用参数的默认值
TestFunc(10); // 10,传参时,使用指定的实参
return 0;
}
4.2 缺省参数分类
① 全缺省参数
//全缺省
void TestFunc(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
② 半缺省参数
//半缺省
void TestFunc(int a, int b = 10, int c = 20)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
}
注意:
1. 半缺省参数必须从右往左依次来给出,并且连续,不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持(编译器不支持)
5. 函数重载
5.1 函数重载概念
函数重载 : 是函数的一种特殊情况,C++允许在同一作用域中声明几个功能类似的同名函数,这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同,常用来处理实现功能类似数据类型不同的问题
//C语言不允许定义同名函数
//C++可以 -> 函数重载 -> 参数(类型或个数或顺序)不同
int Add(int left, int right)
{
return left + right;
}
double Add(double left, double right)
{
return left + right;
}
int main()
{
cout << Add(1, 2) << endl; //3
cout << Add(1.1, 2.2) << endl; //3.3
return 0;
}
下面两个函数属于函数重载吗?
short Add(short left, short right)
{
return left + right;
}
int Add(int left, short right)
{
return left + right;
}
答:不算,判断时,不看返回类型,只看函数名是否相同,参数个数或类型是否不同
面试题1. C语言为什么不支持重载?C++支持?C++底层是如何支持重载的?
答:通过函数名修饰规则搞定,待补充
面试题2. extern "C"的作用是什么?
答:待补充
5.2 名字修饰(name Mangling)
6. 引用
6.1 引用概念
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它引用的变量共用同一块内存空间。
int main()
{
int a = 10;
//b是a的引用(别名)
//注意区分引用和取地址,引用是类型后&变量,取地址是直接&变量
int& b = a;
b = 20;
//继续取别名
int& c = b;
c = 30;
return 0;
}
注意:引用类型必须和引用实体是同种类型的
//引用的价值
//用别名就可以不用传地址进行交换
void swap(int& r1, int& r2)
{
int tmp = r1;
r1 = r2;
r2 = tmp;
}
void StackInit(struct Stack& s)
{
//...
}
int main()
{
int a = 1, b = 2;
swap(a, b); //c语言需要传地址
struct Stack st;
StackInit(st);
return 0;
}
6.2 引用特性
1. 引用在定义时必须初始化
2. 一个变量可以有多个别名
3. 一旦引用一个实体,就不能引用其他实体
6.3 常引用
//权限可以缩小,但不能放大
int main()
{
const int a = 10;//用const修饰后,a只能读不能写
//int& ra = a;//报错,ra引用a属于权限放大(可读可写)
const int& ra = a; //正确代码
int b = 10;
int& rb = b;
const int& crb = b;//正确,ceb引用b属于权限的缩小,所以可以
int c = 10;
double d = 1.11;
d = c; //隐式类型转换,将int类型的c放到一个double类型的临时变量中,再赋值给d
//double& rc = c; //报错,报错原因并不是因为类型不同
const double& rc = c; //*正确代码,此时rc是c临时变量的别名,临时变量具有常性,所以加const就可以
return 0;
}
6.4 使用场景
1. 做参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
2. 做返回值(特殊场景)
传值返回 返回的是返回对象c的拷贝
//int Add(int a, int b)
//{
// int c = a + b;
// return c;
//}
//int main()
//{
// //int& ret = Add(1, 2); //报错,因为ret接收的是储存c的值的临时变量(不是c),具有常性,需在前加上const
// const int& ret = Add(1, 2);
//
// return 0;
//}
//传引用返回 返回的是对象c的引用,其实就是c
//实际中,如果出了函数作用域,返回变量就不存在了,不能用引用返回;出了作用域还在:例如用static修饰
int& Add(int a, int b)
{
static int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
cout << ret << endl; //3
return 0;
}
注意:如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已经还给系统了,则必须使用传值返回。
下面代码输出什么结果?为什么?
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :" << ret << endl; //7
return 0;
}
6.5 传值、传引用效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低,相反使用引用传参效率更高。
6.5.1 值和引用的作为传参的性能比较
#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl; //11
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; //1
}
int main()
{
TestRefAndValue();
return 0;
}
6.5.2 值和引用的作为返回值类型的性能比较
#include <time.h>
struct A { int a[10000]; };
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl; //254
cout << "TestFunc2 time:" << end2 - begin2 << endl; //2
}
int main()
{
TestReturnByRefOrValue();
return 0;
}
通过上述代码的比较,发现传值和指针在作为传参以及返回值类型上效率相差很大。只要符合条件,尽量使用引用传参、传返回值。
6.6 引用和指针的区别
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
int main()
{
int a = 10;
int& ra = a;
cout << "&a = " << &a << endl; //00B5FD7C
cout << "&ra = " << &ra << endl; //00B5FD7C
return 0;
}
在底层实现角度,引用的底层也是类似指针存储地址的方式处理的,下面说的是语法角度。
int main()
{
int a = 10;
//在语法上,给a的这块空间取了个别名,没有新开空间
int& ra = a;
ra = 20;
//在语法上,定义了一个pa指针变量,开辟了4个字节,存储a的地址
int* pa = &a;
*pa = 20;
return 0;
}
面试题*:引用和指针的不同点:
1. 在语法上,引用概念上定义一个变量的别名,指针存储一个变量地址
2. 引用在定义时必须初始化,指针没有要求
3. 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体
4. 没有NULL引用,但有NULL指针
5. 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
7. 有多级指针,但是没有多级引用
8. 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
9. 引用比指针使用起来相对更安全
7. 内联函数
7.1 概念
以 inline 修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数压栈的开销, 内联函数提升程序运行的效率。
以交换函数为例:调用Swap函数需要建立栈帧,建立栈帧是有代价的,C语言为了避免小函数建立栈帧,提供了宏函数支持,预处理阶段展开,那么C语言都已经解决了,为什么C++还要提供inline函数呢?(面试题:宏函数的缺点)
7.1.1 面试题:宏的优缺点
优点: 1.增强代码的复用性。 2.提高性能。
缺点: 1.不支持调试。(因为预编译阶段进行了替换) ,导致代码可读性差,可维护性差,容易误用。 2. 宏函数语法复杂,容易出错 3.没有类型安全的检查 。
写一个ADD的宏函数
//ADD的宏函数
//#define ADD(int x, int y) return x+y //典型错误写法
//#define ADD(x, y) (x)+(y); //典型错误写法,加了分号
//标准写法
#define ADD(x, y) ((x) + (y))
C++有哪些技术替代宏?
1. 常量定义 换用const
2. 换用内联函数
//C++推荐将频繁调用的小函数,定义成inline(内联),会在调用的地方展开。没有栈帧的开销
inline int Add(int x, int y)
{
return x + y;
}
int main()
{
int c = Add(1, 2);
cout << c << endl;
return 0;
}
7.2 特性
1. inline是一种以空间换时间的做法,省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议,编译器会自动优化,如果定义为inline的函数体内有循环/递归等等,编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离,分离会导致链接错误。因为inline被展开,就没有函数地址了,链接就会找不到。
// F.h
#include <iostream>
using namespace std;
inline void f(int i);
// F.cpp
#include "F.h"
void f(int i)
{
cout << i << endl;
}
// main.cpp
#include "F.h"
int main()
{
f(10);
return 0;
}
// 链接错误:main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z),该符号在函数 _main 中被引用
假设Sort()函数有100行指令,在10个地方调用,总计110条指令,但如果用inline修饰后,10个地方调用,展开后则变成1000条指令
当指令变多意味着什么?
答案:意味着编译出的可执行程序变大,导致安装软件的人体验变差,执行程序内存消耗变多。(指令的多少与效率高低无关,如果直接调用Sort会建立栈帧,效率反而低于直接执行1000条指令的inline Sort)
结论:频繁调用的小函数,建议定义成内联函数
8. auto关键字(C++11)
#include <map>
#include <string>
//以下语法,当前了解即可
//auto
int main()
{
int a = 10;
//int b = a;
auto b = a; //类型声明成auto,可以根据a的类型自动推导b的类型为int
map<string, string> m;
//map<string, string>::iterator it = m.begin();
//这里可以根据m.begin()自动推导到it的类型是map<string, string>::iterator
//这样写比较简洁
auto it = m.begin();
return 0;
}
8.1 auto的使用细则
1. auto与指针和引用结合起来使用
用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须加&
2. 在同一行定义多个变量
当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量。
void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败,因为c和d的初始化表达式类型不同
}
8.2 auto不能推导的场景
1. auto不能作为函数的参数
2. auto不能直接用来声明数组
3. auto在实际中最常见的优势用法就是与C++11提供的新式for循环,还有lambda表达式等进行配合使用
9. 基于范围的for循环(C++11)
9.1 范围for的语法
int main()
{
int array[] = { 1, 2, 3, 4, 5 };
//以前遍历数组的方式
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
cout << array[i] << " ";
cout << endl;
// 1 2 3 4 5
//范围for,更简单,数组也可以直接遍历
//自动遍历,以此取出array中的元素,赋值给e,直到结束
for (auto e : array)
{
cout << e << " ";
}
cout << endl;
//1 2 3 4 5
//以上是"读"的操作,"写"的操作需要注意加引用符号
for (auto& ee : array) //ee是数组元素的临时拷贝,要想修改数组需要加引用符号
{
ee *= 2;
}
return 0;
}
9.2 范围for的使用条件
1. for循环迭代的范围必须是确定的
对于数组而言,就是数组中第一个元素和最后一个元素的范围;对于类而言,应该提供begin和end的方法,begin和end就是for循环迭代的范围。
注意:以下代码就有问题,因为for的范围不确定
void TestFor(int array[])
{
for (auto& e : array)
cout << e << endl;
}
//因为此处array作为形参是一个指针,而非数组了
2. 迭代的对象要实现++和==的操作(之后再谈)
10. 指针空值nullptr(C++11)
//C++11
int main()
{
//以前使用的
int* p1 = NULL; //等价于 int* p1 = 0;
//C++推荐使用的
int* p2 = nullptr;
return 0;
}
NULL实际是一个宏,NULL可能被定义为字面常量0,或者被定义为无类型指针(void*)的常量。不论采取何种定义,在 使用空值的指针时,都不可避免的会遇到一些麻烦,比如:
void f(int i)
{
cout << "f(int)" << endl;
}
void f(int* p)
{
cout << "f(int*)" << endl;
}
int main()
{
f(0); //期望匹配整形参数的f,结果:f(int)
f(NULL); //期望匹配指针参数的f,结果:f(int),因为NULL被替换成0了
f((int*)NULL);//f(int*)
f(nullptr); //f(int*)
return 0;
}
程序本意是想通过f(NULL)调用指针版本的f(int*)函数,但是由于NULL被定义成0,因此与程序的初衷相悖。 在C++98中,字面常量0既可以是一个整形数字,也可以是无类型的指针(void*)常量,但是编译器默认情况下将其看成是一个整形常量,如果要将其按照指针方式来使用,必须对其进行强转(void *)0。
注意:
1. 在使用nullptr表示指针空值时,不需要包含头文件,因为nullptr是C++11作为新关键字引入的。
2. 在C++11中,sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
3. 为了提高代码的健壮性,在后续表示指针空值时建议最好使用nullptr。