目录
C++介绍
“C++”是一种多功能的编程语言，它起源于1980年代初，由Bjarne Stroustrup在C语言的基础上发展而来。C++最初被设计为支持面向对象编程的C语言变体，后来经过多次迭代和标准化，发展成为一种广泛应用于系统软件、游戏开发、嵌入式系统等领域的语言。C++的发展经历了多个重要阶段，包括C++98、C++03、C++11、C++14、C++17、C++20和即将到来的C++23标准.
参考文档
特点：通俗易懂
https://zh.cppreference.com/w/cpp
特点：完整中文版
https://en.cppreference.com/w/
特点：完整英文版
C++第一个程序
// test.cpp
#include<iostream>
using namespace std;
int main()
{
cout << "hello world\n" << endl;
return 0;
}#include<iostream>是什么头文件
using namespace std;又是什么东西
打印“hello world”怎么变成了cout << "hello world\n" << endl;
命名空间namespace
namespace的价值
在C/C++中，变量、函数和后面要学到的类都是⼤量存在的，这些变量、函数和类的名称将都存在于全 局作用域中，可能会导致很多冲突。使⽤命名空间的⽬的是对标识符的名称进行本地化，以避免命名 冲突或名字污染，namespace关键字的出现就是针对这种问题的。
c语言项目类似下面程序这样的命名冲突是普遍存在的问题，C++引入namespace就是为了更好的解决 这样的问题。
#include <stdio.h>
#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
// 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
printf("%d\n", rand);
return 0;
}
当头文件只有stdio.h的时候是没有问题的，但是我们加上另一个头文件stdlib.h就会出现报错的现象，在stdlib这个库里面定义了一个rand 的函数，那么我们现在又在外面定义一个rand的变量，那么就会出现冲突。
namespace的定义
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中 即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
namespace wuguo
{
// 命名空间中可以定义变量/函数/类型
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
struct Node
{
struct Node* next;
int val;
};
}namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand不在冲突了。
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
int rind = 10;
namespace wuguo
{
int rind = 30;
}
int main()
{
printf("%d\n", rind); //打印的是全局的10
printf("%d\n", wuguo::rind); //打印的是wuguo域里的30
return 0;
}C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/ 类型出处(声明或定义)的逻辑，所有有了域隔离，名字冲突就解决了。局部域和全局域除了会影响 编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
int x = 0;//全局域
namespace bit
{
int x = 10;//命名空间域
}
void func()
{
int x = 20;//局部域
}
int main()
{
int x = 30;//局部域
printf("%d\n", x); //这里默认访问的是局部的这个x，因为搜索是先局部再全局搜索。
printf("%d\n", bit::x); //这里就是访问命名空间域
printf("%d\n", ::x); //这里就是访问全局变量。
return 0;
}
namespace只能定义在全局，当然他还可以嵌套定义。
// 命名空间可以嵌套
namespace wuguo
{
// 小王
namespace xw
{
int rand = 10;
int Add(int left, int right)
{
return left + right;
}
}
// 大王
namespace dw
{
int rand = 20;
int Add(int left, int right)
{
return (left + right) * 10;
}
}
}
int main()
{
printf("%d\n", wuguo::pg::rand);
printf("%d\n", wuguo::hg::rand);
printf("%d\n", wuguo::pg::Add(10, 20));
printf("%d\n", wuguo::hg::Add(10, 20));
return 0;
}• 项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。
• C++标准库都放在⼀个叫std(standard)的命名空间中。
namespace使用
指定命名空间访问
namespace wuguo
{
int a = 0;
int b = 1;
}
int main()
{
printf("%d\n", wuguo::a);
return 0;
}项目中推荐这种方式。
using将命名空间中某个成员展开
namespace wuguo
{
int a = 0;
int b = 1;
}
//把wuguo域里的a展开了
using wuguo::a;
int main()
{
printf("%d\n", a);
return 0;
}项目中经常访问的不存在冲突的成员推荐这种方式。
展开命名空间中全部成员
namespace wuguo
{
int a = 0;
int b = 1;
}
using namespace wuguo;
int main()
{
printf("%d\n", a);
printf("%d\n", b);
return 0;
}
项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。
输入和输出
<iostream>是 Input Output Stream 的缩写，是标准的输⼊、输出流库，定义了标准的输⼊、输
出对象,就是他们的库函数。
std::cin 是istream类的对象，它主要面向窄字符（narrowcharacters(oftypechar)）的标准输入流，就是输入。
std::cout 是ostream类的对象，它主要面向窄字符的标准输出流，就是输出。
std::endl 是⼀个函数，流插⼊输出时，相当于插入⼀个换行字符加刷新缓冲区，就是换行。
<<是流插入运算符，>>是流提取运算符。
#include<iostream>
using namespace std;
int main()
{
// <<输出
cout << "hello world\n";
int i = 10;
double d = 1.1;
//>>输入
cin >> i >> d;
cout << i<<":"<<d << std::endl;
return 0;
}输入一个“整数” “空格” “小数”
输出“整数” “：” “小数”
缺省参数
缺省参数是一种便捷的机制，允许在函数声明时为参数指定默认值。如果在调用函数时省略了这些参数，编译器会自动使用它们的缺省值。使用缺省参数可以简化函数调用，减少冗余代码，并提高代码的可读性和灵活性。
全缺省参数：函数的所有参数都可以有缺省值，调用时可以不传递任何参数。
半缺省参数：只有部分参数有缺省值，这些缺省值必须从右向左依次指定，不能间断。
声明与定义分离：如果函数声明和定义分开，缺省参数只能在声明中指定，定义中不应再次指定。
缺省值的限制：缺省值必须是常量表达式或全局变量，不能是局部变量或动态分配的内存。
调用顺序：实参的传递顺序是从左向右，而形参的缺省值赋值顺序是从右向左。
#include <iostream>
#include <assert.h>
using namespace std;
void Func(int a = 0)
{
cout << a << endl;
}
// 全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
// 半缺省
void Func2(int a, int b = 10, int c = 20)
{
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl << endl;
}
int main()
{
Func(); // 没有传参时，使用参数的默认值
Func(10); // 传参时，使用指定的实参
Func1(); //a=10 b=20 c=30
Func1(1); //a=1 b=20 c=30
Func1(1, 2); //a=1 b=2 c=30
Func1(1, 2, 3); //a=1 b=2 c=3
// 不支持
// Func1(,2,3);
Func2(100); //a=100 b=10 c=20
Func2(100, 200); //a=100 b=200 c=20
Func2(100, 200, 300); //a=100 b=200 c=300
return 0;
}函数重载
C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同⼀作用域中出现同名函数的。
函数名称必须相同。
参数列表必须不同，这包括参数的个数、类型或顺序的不同。
返回类型不影响函数重载，即使两个函数的返回类型不同，它们也可以构成重载，因为重载决策是基于函数的参数列表进行的。
void ADD(int a, int b)
{
cout << a + b << endl;
}
void ADD(double a, int b)
{
cout << a + b << endl;
}
void ADD(int a, double b)
{
cout << a + b << endl;
}
int main()
{
ADD(1, 1);
ADD(1, 1.1);
ADD(1.1, 1);
return 0;
}
引用
引用的概念
在C++中，引用是一种特殊的变量类型，它提供了对另一个变量的别名。
引用在语法层面是不开辟空间的
在底层引用类似于指针变量是开辟空间
void Test()
{
int a = 10;
//定义引用类型ra就是a的别名，地址也是一样的
int& ra = a;
printf("%p\n", &a);
printf("%p\n", &ra);
}
应用
作为函数参数
//作为函数参数
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
int main()
{
int x = 0, y = 1;
cout << x << " " << y << endl;
Swap(x, y);
cout << x << " " << y << endl;
return 0;
}
//传返回值
int& STTop(ST& rs)
{
assert(rs.top > 0);
return rs.a[rs.top];
}
STTop(st1)++;
易错示例
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;
return 0;
}
这个代码将C的值返回，返回值是别名，当调用函数的时候，函数会建立栈帧，当调用结束的时候，这空间的随之就会返回给操作系统，C变量也就不会存在。输出是随机值。
const引用
可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访 问权限在引用过程中可以缩小，但是不能放大。
int main()
{
//a不能进行修改,所以不能取别名，取别名的话是会对a造成修改的风险的
const int a = 10;
//在引用的过程中权限不能放大
//int& ra = a;
//那么这里的ra就是const对象
const int& ra = a;
//cnost引用普通的对象
//权限可以缩小
int b = 1;
//rb不能进行修改,b能被修改
const int& rb = b;
//rb++;
b++;
//x不能修改
const int x = 0;
//这里是拷贝赋值,所以可以修改y对x没有影响
int y = x;
return 0;
}指针问题
int main()
{
//a是不能进行修改的
const int a = 10;
//√p1固定指a不能被修改
const int* p1 = &a;
//×权限的放大
int* p2 = p1;
int b = 20;
//√p3存的是b的地址
int* p3 = &b;
//√p4也是b的地址，只读不改
const int* p4 = p3;
return 0;
}指针和引用的关系
C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。
• 语法概念上引用是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间。
• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
• 引用在初始化时引用⼀个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
• 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全⼀些。
inline
用inline修饰的函数叫做内联函数，编译时C++编译器会在调⽤的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，就可以提高效率。
宏定义的问题
//实现⼀个ADD宏函数的常⻅问题
#define ADD(int a, int b) return a + b;
#define ADD(a, b) a + b;
#define ADD(a, b) (a + b)
//正确的宏实现
#define ADD(a, b) ((a) + (b))为什么不能加分号?宏是替换机制的 ，在宏定义后面加分号的话就有问题了
为什么要加外面的括号? 不加外面的括号这个优先级就有问题了
为什么要加里面的括号? 同样是为了保持优先级
int main()
{
int ret = ADD(1, 2);//宏是替换机制的
cout << ret << endl;
;
cout << ADD(1, 2) << endl; //第一个问题
cout << ADD(1, 2) * 5 << endl; //第二个问题
int x = 1, y = 2;
ADD(x & y, x | y); // -> (x&y+x|y) 第三个问题
return 0;
}
inline对于编译器而言只是⼀个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。
inline适用于频繁调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
debug是默认不展开的，release是展开的
debug展开方式
展开了就没有栈帧的消耗，不展开就有，如果函数较长的话，就不展开了。
nullptr
NULL实际是⼀个宏，在传统的C头⽂件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endifC++中NULL可能被定义为字面常量0，或者C中被定义为无类型指针(void)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到⼀些麻烦，本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调用会报错。
C++11中引入nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字面量，它可以转换成任意其他类型的指针类型。使用nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，而不能被转换为整数类型。
在c++中使用nullptr来定义空指针可以避免类型转换的问题
void f(int x)
{
cout << "f(int x)" << endl;
}
void f(int* ptr)
{
cout << "f(int* ptr)" << endl;
}
int main()
{
f(0); //调用第一个
//f(NULL); //调用第二个
//f((void*)0);
f(nullptr); //在c++中使用nullptr来定义空指针可以避免类型转换的问题
return 0;
}