命名空间
在C/C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存
在于全局作用域中,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化,
以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。
命名空间的定义
定义命名空间,需要使用到namespace关键字,后面跟命名空间的名字,然后接一对{}即可,{}
中即为命名空间的成员。
命名空间中可以定义变量/函数/类型
1.正常的命令空间定义
namespace ns1 {
int a;
int b;
struct ListNode {
int _val;
struct ListNode* _next;
};
}
2.命名空间也可以嵌套
namespace N1 {
int a;
int b;
namespace N2 {
int c;
int d;
}
}
3.同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
namespace N1 {
int a;
int b;
namespace N2 {
int c;
int d;
}
}
namespace N1 {
int e;
int Sum(int left, int right) {
return left + right;
}
}
那么命名空间怎么使用呢?
命名空间的使用有三种方式:
- 加命名空间名称及作用域限定符
int main()
{
cout << N1::a << endl;
return 0;
}
- 使用using将命名空间中某个成员引入
using N1::b;
int main()
{
cout << b << endl;
return 0;
}
- 使用using namespace 命名空间名称 引入
using namespace N1;
int main()
{
cout << a << endl;
cout << b << endl;
return 0;
}
td命名空间的使用惯例:
std是C++标准库的命名空间,如何展开std使用更合理呢?
- 在日常练习中,建议直接using namespace std即可,这样就很方便。
- using namespace std展开,标准库就全部暴露出来了,如果我们定义跟库重名的类型/对
象/函数,就存在冲突问题。该问题在日常练习中很少出现,但是项目开发中代码较多、规模
大,就很容易出现。所以建议在项目开发中使用,像std::cout这样使用时指定命名空间 +
using std::cout展开常用的库对象/类型等方式。
c++输入与输出
c++兼用c语言的用法,c语言的printf 和scanf仍然可以用。
c++风格:
#include<iostream>
// std是C++标准库的命名空间名,C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}
- 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时,必须包含< iostream >头文件
以及按命名空间使用方法使用std - cout和cin是全局的流对象,endl是特殊的C++符号,表示换行输出,他们都包含在包含<
iostream >头文件中。 - <<是流插入运算符,>>是流提取运算符。
- 使用C++输入输出更方便,不需要像printf/scanf输入输出时那样,需要手动控制格式。
C++的输入输出可以自动识别变量类型。
缺省参数
概念:缺省参数是指定义函数时,给函数的参数缺省值,调用函数的时候如果没有传入实参,则给形参赋予缺省值,否则传入实参。
void Func(int a = 0)
{
cout<<a<<endl;
}
int main()
{
Func(); // 没有传参时,使用参数的默认值
Func(10); // 传参时,使用指定的实参
return 0;
}
分类:
- 全缺省参数:参数都有缺省值
int Sum(int left = 0, int right = 0) {
return left + right;
}
int main()
{
Sum();
Sum(1,2);
Sum(1); //此时1传给left,只能从左到右传参,不能直接传right
}
- 半缺省参数:部分参数有缺省值
//此时最少传入一个参数
int Sum(int left , int right = 0) {
return left + right;
}
int main()
{
Sum(1,2);
Sum(1);
}
注意
3. 半缺省参数必须从右往左依次来给出,不能间隔着给。
int Sum(int left = 0 , int right) {
return left + right;
}
//若这样从左向右给,传入单个参数时候,是传给left还是right呢?编译器无法识别,所以不行
- 缺省参数不能在函数声明和定义中同时出现,若需要声明和定义同时出现,声明时写出缺省参数即可,定义时不能写出缺省参数。
函数重载
首先我们需要了解程序的形成过程:编译和链接,编译又分为(预编译,编译,汇编)
在C/C++中,一个程序要运行起来,需要经历以下几个阶段:预编译、编译、汇编、链接。
预编译:宏定义,文件包含,条件编译,去注释等。
编译:语法分析 ,词法分析,语义分析,符号汇总。最终形成汇编代码
汇编:把汇编代码转成二进制目标文件
链接:合并段表,符号表的合并和符号表的重定位,最终形成可执行程序
//b.cpp
int Add(int a, int b)
{
return a + b;
}
//a.cpp
extern int Add(int a, int b)
int main()
{
cout << Add(1,2) << endl;
}
- 实际项目通常是由多个头文件和多个源文件构成,,我们可以知道,【当前a.cpp中调用了b.cpp中定义的Add函数时】,编译后链接前,a.o的目标文件中没有Add的函数地址,因为Add是在b.cpp中定义的,所以Add的地址在b.o中。那么怎么办呢?
- 所以链接阶段就是专门处理这种问题,链接器看到a.o调用Add,但是没有Add的地址,就
会到b.o的符号表中找Add的地址,然后链接到一起。 - 那么链接时,面对Add函数,链接接器会使用哪个名字去找呢?这里每个编译器都有自己的
函数名修饰规则。 - 由于Windows下vs的修饰规则过于复杂,而Linux下修饰规则简单易懂,下面我们使
用了gcc和g++演示了这个修饰后的名字。
C语言:gcc
在linux下,采用gcc编译完成后,函数名字的修饰没有发生改变。
c++: g++
在linux下,采用g++编译完成后,函数名字的修饰发生改变,编译器将函数参
数类型信息添加到修改后的名字中。
而且linux下g++函数名字修饰规则:
_Z [函数名字符个数] 函数名 参数简写
如:上图的_Z3Addll 其中_Z是开头,3是函数名ADD字符个数即3,ll代表参数为两个,分别是long 和 long。
因此:c++能函数重载而c语言不支持.
引用
概念:引用就是给已经存在的变量取别名,不会重新开辟空间,它和变量共同用一块空间。
类型& 引用变量名 = 引用实体;
引用特点:
- 引用必须初始化
- 一个变量可以有多个引用
- 一但引用一个实体,就不能引用其他实体。当引用其他实体时,其实是给当前引用的实体赋值
int main(){
int a = 10;
int b = 20;
int& c = a;
int& d = a;
c = b; //其实是把20赋值给a
}
引用权限说明
引用权限只能缩小,不能放大权限
int main(){
const int a = 10;
int b = 20;
//int & c = a;这样是错误的,a只有读权限,但用c引用后变成可以写了,属于权限放大,所以不能这样
const int& c = a;
const int & d = b;//这样是正确的,b可以读可以写,用d引用后只能读取,属于权限缩小,所以可以。
}
我们平常的赋值没有权限约束,怎么赋值都行
原因:赋值只是把变量的值拷贝过来了,又重新开辟空间了,不会对原来空间造成影响。
int main()
{
const int a = 10;
int b = 20;
int c = a;
const int d = b;
}
引用的使用场景
- . 做参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
- . 做返回值
int& Count()
{
static int n = 0;
//static改变n的生命周期,使它和整个程序生命周期一样,
//如果不这样的话,当返回它的别名时候,函数栈帧销毁,它也被系统回收,
//所以当用引用变量接收时候,这块空间已经不属于它了。
n++;
// ...
return n;
}
看一下下面代码会出现什么情况
nt& 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;
return 0;
}
可以看出,当返回局部变量的引用时候,改局部变量已经被系统回收,所以无法控制它了。
总结:如果函数返回时,出了函数作用域,如果返回对象还在(还没还给系统),则可以使用
引用返回,如果已经还给系统了,则必须使用传值返回。
传值、传引用效率比较
传值是实参的一份拷贝,而传引用只是实参的别名,没有出现开辟空间,所以效率比较高
#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;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
值和引用的作为返回值类型的性能比较
返回值为值的时候,其实是返回变量的一份临时变量(临时变量具有常型),因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当返回值类型非常大时,效率就更低。
#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;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
引用和指针的区别
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
在底层实现上实际是有空间的,因为引用是按照指针方式来实现的。
引用和指针的不同点
- 引用概念上定义一个变量的别名,指针存储一个变量地址。
- 引用在定义时必须初始化,指针没有要求。
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何
一个同类型实体 - 没有NULL引用,但有NULL指针
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32
位平台下占4个字节) - 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全
内联函数
以inline修饰的函数叫做内联函数,编译时C++编译器会在调用内联函数的地方展开,没有函数调
用建立栈帧的开销,内联函数提升程序运行的效率。
补充知识:将函数调用转成汇编,变成 call + …
此处没有call所以没有开辟函数栈帧。
inline对于编译器而言只是一个建议,不同编译器关于inline实现机制可能不同,一般建
议:将函数规模较小(即函数不是很长,具体没有准确的说法,取决于编译器内部实现)、不
是递归、且频繁调用的函数采用inline修饰,否则编译器会忽略inline特性。
此处显示了call 说明有函数栈帧的开辟
inline不建议声明和定义分离,分离会导致链接错误。因为inline被展开,就没有函数地址
了,链接就会找不到。
通过以上介绍,你可以发现它和宏很像
宏的优缺点?
优点:
1.增强代码的复用性。
2.提高性能。
缺点:
1.不方便调试宏。(因为预编译阶段进行了替换)
2.导致代码可读性差,可维护性差,容易误用。
3.没有类型安全的检查 。
C++有哪些技术替代宏?
- 常量定义 换用const enum
- 短小函数定义 换用内联函数
auto关键字
auto会根据数据自动赋予数据类型。
使用auto定义变量时必须对其进行初始化,在编译阶段编译器需要根据初始化表达式来推导auto
的实际类型。因此auto并非是一种“类型”的声明,而是一个类型声明时的“占位符”,编译器在编
译期会将auto替换为变量实际的类型。
int main(){
int a = 10;
auto b = 10;//编译器自动赋予int数据类型
}
auto使用细则
- auto与指针和引用结合起来使用用auto声明指针类型时,用auto和auto*没有任何区别,但用auto声明引用类型时则必须加&
int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}
- 在同一行定义多个变量当在同一行声明多个变量时,这些变量必须是相同的类型,否则编译器将会报错,因为编译
器实际只对第一个类型进行推导,然后用推导出来的类型定义其他变量。
auto a = 10, b = 20;
auto c = 20,d = 4.0;//此处会报错,20和4.0类型不同
基于范围for循环
对于一个有范围的集合而言,由程序员来说明循环的范围是多余的,有时候还会容易犯错误。因
此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ :”分为两部分:第一部分是范
围内用于迭代的变量,第二部分则表示被迭代的范围。
void TestFor()
{
int array[] = { 1, 2, 3, 4, 5 };
for(auto& e : array)
e *= 2;
for(auto e : array)
cout << e << " ";
return 0;
}
注意:与普通循环类似,可以用continue来结束本次循环,也可以用break来跳出整个循环。
使用条件:
for循环迭代的范围必须是确定的,对于数组而言,就是数组中第一个元素和最后一个元素的范围;对于类而言,应该提供
begin和end的方法,begin和end就是for循环迭代的范围。
指针空值nullptr(C++11)
在c++中
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
可以看到NULL有可能被赋成0或void*(0),这样的话有的程序是本意是调用空指针,就也有可能会使用0,
为了避免这种情况c++引入了nullptr关键字来表示空指针
注意·:
- 在使用nullptr表示指针空值时,不需要包含头文件,因为nullptr是C++11作为新关键字引入
的。 - 在C++11中,sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
- 为了提高代码的健壮性,在后续表示指针空值时建议最好使用nullptr。