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)所占的字节数相同
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
