C++入门

废话不多说，开始记笔记：（C++简单入门）

1.C++关键词

C++总计63个关键字，C语言32个关键字：（现在只需要过个眼熟便可）

2.命名空间

1.关键字：namespace

所需C++关键字：namespace { }

C/C++规定：在同一个域中，不可以定义同名的东西。

域的种类大概可以分为四种：

1.函数局部域

2.全局域

3.命名空间域

4.类域

我们可以通过namespace来创造一个全新的域，也就是命名空间域

使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染

举个例子：
已知（stdlib.h）头文件中展开有 “ rand ” 函数

此例中，会报错：

error C2365: “rand”: 重定义；以前的定义是“函数”

原因是：

在(stdlib.h)的头文件中，其头文件在全局域中展开，其中带有rand函数，会报错：rand到底是函数，还是一个int rand=10 ?，rand重定义了，机器不会知道的，这可不能怪机器笨~~~~~

这就是一山不容二虎，一个域中不可以定义两个一摸一样的函数，变量，类型等，这也就是命名空间域的作用。

总之：

1. namespace本质上是定义出一个域，这个域跟全局域互相独立，互不影响，不同的域可以定义同名变量，帮助同名变量不冲突；

2. 命名空间中可以定义变量，函数，类型等；

3.局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不会影响变量的生命周期；

4.命名空间可以将想定义的变量，函数，类型等一起放进来，还可以嵌套使用，并且同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中；

5.namespace只能定义在全局，当然不与4冲突，它可以嵌套使用；

6：C++标准库都放在一个叫std（standard）的命名空间中。

2.域作用限定符 ' : : '

既然我们虽需要的变量通过域作用起来了，我们也应该有方法取找出所需变量

因此：

我们可以借助域作用限定符 ' : : ' 来查找

模板：

命名空间的名字 : : 所需变量

以上面例子：（解决问题）（图中注释也是知识点的）

但是，如果我们要一直用到域中的变量，那不得一直敲“ : : ”

所以：想要用到域中的变量，其实有三种方法可以实现：
1 . 加命名空间名称及作用域限定符（指定命名空间访问）（项目推荐）

int main()
{
    printf("%d\n", N::a);
    return 0;    
}
//对于结构体（注意格式）
int main()
{
    printf("%d\n", struct N::node p1);//应该在struct后
    return 0;    
}

2.使用using将命名空间中某个成员引入（using将某个命名空间展开）（项目中经常访问的，不存在冲突的成员，推荐这种方式）

using N::b;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;    
}

3.使用using namespace 命名空间名称引入（展开命名空间中全部成员）（项目不推荐，冲突风险大）（日常小练习为了方便还是推荐使用滴）

using namespce N;
int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

可以简单理解，从1~3，域越来越开放（把域的墙越凿越大）（同为展开，要与头文件的展开做区分（头文件的展开是在编译链接中的预处理时把头文件的容量拷贝过来，在实际编译时是没有头文件的，只编译''.c\.cpp''文件）），不过，应该注意的是：风险会越来越大。

3.C++的输入&输出

1.io流 --->库：iostream

• <iostream> 是 Input Output Stream 的缩写，是标准的输⼊、输出流库，定义了标准的输⼊、输出对象。
• std::cin 是 istream 类的对象，它主要⾯向窄字符（narrow characters (of type char)）的标准输⼊流。
• std::cout 是 ostream 类的对象，它主要⾯向窄字符的标准输出流。（wout是宽字符）
• std::endl 是⼀个函数，流插⼊输出时，相当于插⼊⼀个换⾏字符加刷新缓冲区。
• <<是流插⼊运算符，>>是流提取运算符。（C语⾔还⽤这两个运算符做位运算左移/右移）
• 使⽤C++输⼊输出更⽅便，不需要像printf/scanf输⼊输出时那样，需要⼿动指定格式，C++的输⼊输出可以⾃动识别变量类型(本质是通过函数重载实现的)，其实最重要的是C++的流能更好的⽀持⾃定义类型对象的输⼊输出；
• IO流涉及类和对象，运算符重载、继承等很多⾯向对象的知识；
• cout/cin/endl等都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使⽤⽅式去⽤他们。
• ⼀般⽇常练习中我们可以using namespace std，实际项⽬开发中不建议using namespace std。
• 这⾥我们没有包含<stdio.h>，也可以使⽤printf和scanf，在包含<iostream>间接包含了。vs系列编译器是这样的，其他编译器可能会报错。

2.cout<<???<<endl的使用

cout<<???<<endl比较方便，他可以对？？？进行类型的自动识别。

EG:

#include<iostream>//注意：这里不需要".h"
//io流
using namespace std;
//打开标准库

int main()
{
	int i = 10;
	//在内存中整数有原码，反码，补码；浮点数在内存中也有自己的一套存储规则，等等类似这样的存储规则，
	//但到了其他文件中都转化成了字符
	//不管是printf还是cout，i这个整型都是转化成字符后输出到console（控制台）去
	cout << i << endl;
}

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	double b = 0.9;
	char c = 'f';
	cout << a << " " << b << " " << c << endl;
	cout << a << " " << b << " " << c;//其实endl就是为了换行
	//输出：
	//10 0.9 f
	//10 0.9 f
	//D : \2024C语言
	return 0;
}

注：endl的作用可以当成是换行，但是endl本质上是一个极其复杂的函数。

3.cin>>???的使用

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	double b = 0.9;
	char c = 'c';
	cin >> a;//流插入
	cin >> b >> c;
	//cin >> a >> b >> c;
	//s输入：
	//123
	//1.23
	//o
	cout << a << " " << b << " " << c << endl;
	//输出
	//123 1.23 o
	return 0;
}

4.小 Pay attention to the point

在浮点数中的cout<<???<<<endl，输出的浮点数小数点数默认最多为5位，C++可以通过自己的方式更改小数点位数，但是何妨不使用C语言那套（更简单）

#include<iostream>
using namespace std;
int main()
{
	double a = 2.222222222;
	printf("%.2lf\n", a);//2.22
	cout << a << endl;//2.22222
	return 0;
}

在io需求比较高的地方，如部分大量输入的竞赛题中，加上一下三行代码，可以提高C++的io效率

#include<iostream>
using namespace std;
int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(nullptr);
	cout.tie(nullptr);
	return 0;
}

4.缺省参数

• 缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调⽤该函数时，如果没有指定实参则采⽤该形参的缺省值，否则使⽤指定的实参，缺省参数分为全缺省和半缺省参数。（有些地⽅把缺省参数也叫默认参数）
• 全缺省就是全部形参给缺省值，半缺省就是部分形参给缺省值。C++规定半缺省参数必须从右左
依次连续缺省，不能间隔跳跃给缺省值。
• 带缺省参数的函数调⽤，C++规定必须从左到右依次给实参，不能跳跃给实参。
• 函数声明和定义分离时，缺省参数不能在函数声明和定义中同时出现，规定必须函数声明给缺省
值。

#include<iostream>
using namespace std;
void Func(int a = 0)//在这里给a这个形参的值只能是全局变量或常量值
{
	cout << a << endl;
}
//全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
//半缺省(C++规定半缺省参数必须从右向左依次连续缺省，不能间隔跳跃给缺省值)
void Func2(int a, int b = 10, int c = 20)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
int main()
{
	Func();//没有传参是，使用参数的默认值
	//0
	Func(10);//传参时，使用指定的实参
	//10
	//Func1(, 2, );//错：C++规定必须从左到右依次给实参，不能跳跃给实参。
	//Func2();//因为是半缺省，不可以一个都不传
	return 0;
}

意义：可以应用到扩容方面，避免浪费

5.函数重载

C++⽀持在同⼀作⽤域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调⽤就表现出了多态⾏为，使⽤更灵活。C语⾔是不⽀持同⼀作⽤域中出现同名函数的。

主要有3种类型：

1.参数类型不同

int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}

2.参数个数不同

void f()
{
	cout << "f()" << endl;
}
void f(int a)
{
	cout << "f(int a)" << endl;
}

但是在缺省参数的影响下，单独调用 f ( )会报错；（存在歧义，编译器不知道是哪个）

3.参数类型顺序不同

void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}

注意：返回值不同不能作为重载条件，因为调⽤时也⽆法区分

void fxx()
{

}

int fxx()
{
 return 0;
}

6.引用

引⽤不是新定义⼀个变量，⽽是给已存在变量取了⼀个别名，编译器不会为引⽤变量开辟内存空间，和它引⽤的变量共⽤同⼀块内存空间。⽐如：⽔壶传中李逵，宋江叫"铁⽜"，江湖上⼈称"⿊旋
⻛"；林冲，外号豹⼦头。

类型"&" 引⽤别名 = 引⽤对象;

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	// 引⽤：b和c是a的别名
	int& b = a;
	int& c = a;
	// 也可以给别名b取别名，d相当于还是a的别名
	int& d = b;
	++d;
	// 这⾥取地址我们看到是⼀样的
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
	return 0;
}

注意：

• 引⽤在定义时必须初始化
• ⼀个变量可以有多个引⽤
• 引⽤⼀旦引⽤⼀个实体，再不能引⽤其他实体

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	// 编译报错：“ra”: 必须初始化引⽤
	//int& ra;
	int& b = a;
	int c = 20;
	// 这⾥并⾮让b引⽤c，因为C++引⽤不能改变指向，
	// 这⾥是⼀个赋值
	b = c;
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	return 0;
}

• 引⽤在实践中主要是于引⽤传参和引⽤做返回值中减少拷⻉提⾼效率和改变引⽤对象时同时改变被引⽤对象；

• 引⽤传参跟指针传参功能是类似的，引⽤传参相对更⽅便⼀些。

• 引⽤返回值的场景相对⽐较复杂（但是效果很好）

• 引⽤和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引⽤跟其他语⾔的引⽤(如Java)是有很⼤的区别的，除了⽤法，最⼤的点，C++引⽤定义后不能改变指向，
Java的引⽤可以改变指向。

//传值返回
void Fun(int& a)
{

}
//传引用返回
int& Fun()
{

}

其实引用就是可以在实参和形参上的关系的理解上更通俗易懂化

EG：

#include<iostream>
using namespace std;
void Swap(int& rx, int& ry)
{
	int tmp = rx;
	rx = ry;
	ry = tmp;
}
int main()
{
	int x = 0, y = 1;
	cout << x << " " << y << endl;
	Swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}

补充点：引用作返回值是很方便的

注意：局部对象不可以（类似野指针）（栈的销毁导致的）（简单认识）

补：const引用（虽然是补充，但是很重要）

• 可以引⽤⼀个const对象，但是必须⽤const引⽤。const引⽤也可以引⽤普通对象，因为对象的访 问权限在引⽤过程中可以缩⼩，但是不能放⼤。

• 不需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样⼀些场 景下a*3的和结果保存在⼀个临时对象中，int& rd = d 也是类似，在类型转换中会产⽣临时对 象存储中间值，也就是，rb和rd引⽤的都是临时对象，⽽C++规定临时对象具有常性，所以这⾥ 就触发了权限放⼤，必须要⽤常引⽤才可以;

• 所谓临时对象就是编译器需要⼀个空间暂存表达式的求值结果时临时创建的⼀个未命名的对象，

C++中把这个未命名对象叫做临时对象.

权限放大经典案例：

int main()
{
	const int a = 10;
	// 编译报错：error C2440: “初始化”: ⽆法从“const int”转换为“int &”
	// 这⾥的引⽤是对a访问权限的放⼤
	int& ra = a;
}

ra：a小友，要不你取个别名就叫我呗。

a：我自己的修改权限因为被const修饰了，现在只能读不能写，ra你变成我的别名，用int的方式引用我，我自己都只能读不能写，你告诉我你来引用我，变成我的别名后，你要可以读可以写，合适吗？老弟

正确示范：

int main()
{
	const int a = 10;
	const int& ra = a;//要用const引用
}

ra：好吧，那我也加个const，变成你爱的摸样，只能读不能写吧~

a：好吧，这样我就勉勉强强接受你吧。

权限缩小经典案例：

int main()
{
	int a = 10;
	const int& ra = a;//要用const引用
}

过了n年

a：其实嘛，我还是不要const修饰了，那我就可读可写了。

ra：那你还接受现在的我吗，只能读不能写.？

a：当然了。

所以：权限可以缩小，但是不可以放大（你抓的是周树人，关我鲁迅什么事？）

所以，通过const引用，可以对30取别名；

又因为临时变量（简单理解：就是通过运算产生的）具有常性，同理；

int main()
{
	const int& ra = 30;
	int a = -1;
	int b = 1;
	const int& rl = (a + b);
	return 0;
}

int main()
{
	double d = 12.34;
	int i = d;//这里不是赋值，是隐式类型转换（中间会产生临时变量取存储）
	//int& ri = d;//ri是不可以引用d的
	const int& i = d;
	return 0;
}

这里临时对象的生命周期会随着别名走，只有别名销毁，临时对象才会走到生命的尽头