C++基础语法
一、引用
1. 概念
-
引用:给已存在的变量取别名。编译器不会为引用变量开辟内存空间,它和它引用的变量共用一块内存空间。
eg:番茄的别名是西红柿,本质都是一个东西。 -
语法:
类型& 引用变量名(对象名) = 引用实体 -
代码引入:
int main()
{
int a = 10;
int& ra = a; //定义引用类型
printf("%p\n", &a);
printf("%p\n", &ra);
}
代码运行结果和注意事项:
2. 引用特性
- 引用在定义时必须初始化
- 一个变量可以有多个引用
- 引用一旦引用实体,就不能在引用其他的实体
eg1:
int main()
{
int a = 10;
// int& ra; //error 这条语句编译时会出错,没有给引用初始化
int& ra = a;
int& rra = a; //一个变量可以有多个引用
printf("%p %p %p\n", &a, &ra, &rra);
return 0;
}
代码运行结果:
eg:
int main()
{
int a = 10;
int& d = a;
int x = 11;
d = x; //这个意思是把x赋值给d,进而也罢a影响了,并且这里并不是d变成x的引用。
printf("%d %d %d\n", a, x, d);
return 0;
}
代码运行结果:
3. 常引用 —— const
- 临时变量
类型转换产生临时变量,临时变量具有常属性。(为下面不同类型的引入铺垫)
- 权限问题
注:引用的过程中权限不能放大,权限可以缩小或者平移
void TestConstRef()
{
const int a = 10;
//int& ra = a; //error
const int& ra = a; //ok 权限平移
//int& b = 10; //error 权限放大 10是常量
const int& b = 10; //ok 权限平移
int x = 0;
int& y = x;
const int& z = x; //ok 权限缩小
++x; //ok const局限的的是z,不是x。当然++x会影响z,但是z就是不能改
//++z //err
double d = 12.34;
//int& rd = d; //error
int i = d; //ok,这里本质使用d的隐式类型转换成int然后对i赋值,i是12
const int& rd = d;
}
对上述代码进行解释:
4. 引用的使用
①做参数
- 输出型参数
eg1:不使用指针,变量交换
//这里参数接收使用的引用
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int main()
{
int a = 10;
int b = 1;
Swap(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}
代码运行结果分析:
eg2:指针交换
//使用指针的引用
void Swap(int*& left, int*& right)
{
int* temp = left;
left = right;
right = temp;
}
int main()
{
int a = 10;
int b = 1;
int* pa = &a;
int* pb = &b;
cout << "pa = " << pa << endl;
cout << "pb = " << pb << endl << endl;
Swap(pa, pb);
cout << "pa = " << pa << endl;
cout << "pb = " << pb << endl;
return 0;
}
运行结果分析:
- 引用提高效率,而传值需要拷贝
eg3:
②做返回值
- 做返回值
eg1:
int fun1()
{
static int n = 0;
n++;
return n;
}
int main()
{
int& ret = fun1();
return 0;
}
代码运行结果分析:
解决eg1错误:在接收时使用const
eg2:
int& Count()
{
static int n = 0;
n++;
//...
return n;
}
int main()
{
int ret = Count();
int& ret1 = Count();
cout << ret << " " << ret1 << endl;
return 0;
}
分析:
eg3:
//在传引用返回时,一定要注意,出了作用域对象不在了,就不能引用返回
//错误样例 n出了作用域就销毁了
int& Count1(int x)
{
int n = x;
n++;
return n;
}
//正确样例
int& Count2(int x)
{
static int n = x;
n++;
return n;
}
注:
- 注意作用域 ,有些对象是不能用引用返回的,只能使用传值。
- 因为函数运行时,系统需要给函数开辟独立的栈空间,用来保存该函数的形参,局部变量以及一些寄存器信息等,函数运行结束该函数对应的栈空间就被系统回收了。所以对象如果出了作用域就销毁了(eg:局部变量),引用就会指向一处被释放的空间。有疑惑可以看一下这篇博客函数栈帧的创建和销毁
- 反之,函数返回时,出了函数的作用域,对象还在(没有被销毁。eg:静态变量、全局变量)则可以继续引用返回
- 提高效率
在返回的时候引用返回不需要创建临时变量,传值返回需要创建。
eg:值和引用作为返回值类型的性能比较
③引用的应用
对C语言实现的单链表进行修改:
④小结
引用做参数:
传值需要拷贝,引用不需要拷贝
- 输出型参数
- 减少拷贝效率 --> 对于大对象/深度拷贝对象来说(后期介绍)
引用做返回值:
返回 别名不需要产生临时变量,而使用值返回需要产生临时变量。
- 减少拷贝效率 + 大对象/深度拷贝对象
- 修改返回值 + 获取返回值
5. 引用和指针的区别
引用在语法上:没有独立空间和其引用实体共用一块空间,就是一个别名
but:底层实现上实际是有空间的。原因:引用是按照指针的方式实现的。
引用和指针的不同点:
引用 | 指针 | |
---|---|---|
概念上 | 定义一个变量别名 | 存储一个变量地址 |
定义时 | 必须初始化 | 没要求 |
实体 | 初始化时引用一个实体,就不能再引用其他实体 | 任何时候指向同类型实体 |
NULL | 没有NULL引用 | 有NULL指针 |
sizeof不同 | 引用类型的大小 | 地址空间所占字节个数(4/8) |
自加 | 实体跟随引用自加 | 指针向后偏移 * 个类型的大小 |
多级 | 没有多级引用 | 有多级指针 |
访问实体方式 | 编译器自己处理 | 显式解引用 |
安全 | 安全 | 相比较不安全 |
二、内联函数
1. 概念
内联函数:使用inline修饰的函数叫做内联函数。在编译时,编译器会在调用内联函数的地方展开,没有建立栈帧的开销,提高程序运行效率。
在调用内联函数成功时,编译期间会用函数体替换函数的调用。如果汇编代码中存在call+函数名,则内联函数不成功
对vs2019编译器进行设置:
- 在release模式下,可以直接查看生成的汇编代码是否存在call+函数名
- 在debug模式下,需要对编译器进行设置,否则不会展开(因为debug模式下,编译器默认不会对代码进行优化)
对编译器这样更改的原因:在编译时优化内联函数时,会导致一些调试信息的缺失,因为内联函数的代码已经被嵌入到调用处,调试器无法准确地将源代码与汇编代码进行映射。所以编译器要生成程序数据库文件、调试信息文件等,将内联函数的源代码信息、变量名、函数名等调试信息保存在该文件中。在调试时,调试器可以通过这些调试信息文件还原出源代码信息
eg:
//内联函数
inline int Add(int left, int right)
{
return left + right;
}
int main()
{
int ret = 0;
ret = Add(1, 2);
return 0;
}
eg:内联建议成功
2. 特性和优缺点
特性:
- inline是一种空间换时间的做法。
- inline对于编译器而言只是一个建议,不同编译器关于inline实现机制可能不同。内联函数只是向编译器发出一个请求,编译器可以忽略这个请求。
- 建议:函数规模较小、不是递归(递归函数的调用比较复杂)、需要频繁调用(减少调用开销),否则编译器会忽略这个请求。
- inline声明和定义不能分离。inline被展开,就没有函数地址了,链接就会找不到。
- 解释:内联函数不会进符号表,内联函数在调用的地方直接展开。声明进符号表,定义不进,就无法链接。所以inline声明和定义不能分离。
- 建议:内联函数完整的写在头文件中,谁用谁包含头文件直接展开,这样就不存在链接问题。
优缺点:
-
优点
提高运行效率 --> 没有函数调用栈帧的开销 -
缺点
可执行程序变大
eg:
注: 避免过度使用内联优化,以避免造成代码膨胀、编译时间增加等问题。
3. 宏
宏函数也不需要建立栈帧,提高运行效率。
①优缺点
优点:
- 增强代码复用性
- 提高性能
缺点:
- 不方便调试 (原因:在编译阶段直接进行替换)
- 影响代码可读性和可维护性,容易误用
- 没有类型安全检查
②C++中替代宏的技术
- 常量定义 ————— 换用const enum
- 短小函数定义 ——— 换用内联函数
三、auto关键字
1. 引入
- 类型长难于拼写
- 有些含义不明确
eg1:对长类型typedef取别名
//这个例子只是为了演示C++有些类型的名字很长
#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;
int main()
{
std::map<std::string, std::string> m{ {"apple", "苹果"},
{"orange", "橙子"},
{"pear", "梨"} };
//通过typedef 之后再定义对象
Map n{{"apple", "苹果"}};
//std::map<std::string, std::string>::iterator这也是一个类型,也很长
std::map<std::string, std::string>::iterator it = m.begin();
while (it != m.end())
{
//....
}
return 0;
}
虽然可以通过typedef的方式,但是有些地方会出现问题。
eg2:这是一串错误的代码
typedef char* pstring;
int main()
{
const pstring p1; //error
const pstring* p2;
return 0;
}
解释:含义不明确导致出现问题
小结:在编程中,要把表达式的值赋值给变量,这要求声明变量的时候清楚地知道表达式的类型。同时也为了简化了声明变量的类型,所以C++11给了auto关键字
2. auto
①认识auto
在C++11中,auto作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译的时候推导而得。为了避免与C++98中的auto发生混淆,C++11只保留了auto作为类型指示符的用法
eg:
#include <iostream>
#include <typeinfo> //使用typeid需要引入该头文件
int TestAuto()
{
return 10;
}
int main()
{
int a = 10;
auto b = a; //根据右边的类型自动推导对象的类型
auto c = 'a';
auto d = 1 + 1.11;
auto e = TestAuto();
std::cout << typeid(b).name() << " "; //typeid可以输出b的类型名
std::cout << typeid(c).name() << " ";
std::cout << typeid(d).name() << " ";
std::cout << typeid(e).name() << std::endl;
return 0;
}
//output:int char double int
注:
- auto定义变量时必须进行初始化,在编译阶段编译器会根据初始化表达式来推导auto的实际类型。
- auto不是一种类型的声明,而是一个类型声明的占位符,在编译阶段会替换变量的实际类型。
②使用事项
- auto与指针和引用结合使用
eg1:
#include <iostream>
using namespace std;
int main()
{
int x = 10;
auto a = &x; //ok
auto* b = &x; //ok
auto& c = x; //ok
//auto* e = x; //error
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
*a = 20;
*b = 30;
c = 40;
return 0;
}
//运行结果
//int* int* int
注意:auto声明指针类型时,用auto和auto*没有区别,但是声明引用类型必须+&
- 同一行定义多个变量
使用auto时,在同一行定义多个变量,这些变量必须都是相同类型,否则编译器报错。因为编译器实际只对第一个类型进行推导,然后用推导的类型定义其他变量。
eg2:
void TestAuto()
{
auto a = 1, b = 2; //ok
auto c = 3, d = 4.0; //error,c和d的初始化表达式是不同的类型
}
- 不能使用auto的场景
-
auto不能作为函数参数
-
auto不能直接用来声明数组
3. 范围for
C++11提供的新式for循环 ------> 基于范围的for循环(C++11)
- 语法: for (类型/auto 用于迭代的变量 : 被迭代的范围)
eg1:C++98遍历一个数组
#include <iostream>
using namespace std;
void TestFor()
{
int array[] = { 1,2,3,4,5 };
for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
array[i] *= 2;
}
根据上面的情况,对于一个有范围的集合,C++11引入了基于范围的for循环。
eg2:使用范围for
#include <iostream>
using namespace std;
void TestFor()
{
int array[] = { 1,2,3,4,5 };
for (auto& e : array)
e *= 2;
for (int& e : array)
e += 1;
for (auto e : array)
cout << e << " ";
cout << endl;
}
int main()
{
TestFor();
return 0;
}
代码运行结果:
注:与普通循环类似,可以用continue或break来结束循环,但是用法更加方便
- 使用条件
for循环的迭代范围必须是确定的
- 数组:数组的第一个元素和最后一个元素的范围
- 类:提供begin和end的方法。begin和end就是for循环迭代范围
eg:错误代码示范
void TestFor(int array[]) //for循环的范围不确定
{
for (auto& e : array)
cout << e << endl;
}
- 迭代的对象要实现++和==的操作(用于迭代和判断结束,以后讲)
四、nullptr(C++11)
1. C++98 — NULL
良好的编程习惯,声明一个变量时最好给该变量一个合适的初值。如果一个指针没有合法的指向,那么我们就给指针制空,避免未初始化的指针,从源头避免错误
eg:
void TestPtr()
{
int* p1 = NULL;
int* p2 = 0;
//
}
NULL在C中的实现:
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
NULL被定义为字面常量0或者被定义为无类型指针(void*)的常量。出现问题
eg:
void func(int)
{
cout << "func(int)" << endl;
}
void func(int*)
{
cout << "func(int*)" << endl;
}
int main()
{
func(0);
func(NULL);
func((int*)NULL);
return 0;
}
代码执行结果:
在C++98中,字面常量0既可以是一个整型数字,也可以是一个无类型的指针(void*)常量,但是编译器在默认情况下将其看成整型常量,如果要将其按照指针的方式使用,必须进行强制类型转换。
2. C++11
C++11nullptr的出现是为了解决C++98的NULL的遗留问题
- 使用nullptr表示指针空值时,不需要包含头文件。因为nullptr是C++11作为新关键字引入
- 在C++11中,sizeof(nullptr)与sizeof((void*)0)所占的字节数相同