C++初阶--C++入门（1）

C语言与C++

很多初学者都会把这两门语言进行混淆，但其实这是两种不同的语言，C++相对与C语言，高级了一些；

语法差异：
C语言是一种面向过程的编程语言，它主要注重函数的调用和流程控制。语法比较简洁，代码结构更加直观。
C++语言是一种混合型的编程语言，即支持面向过程的编程方式，还支持面向对象的编程方式。相对于C语言，C++主要引入了类、对象、继承、多态等概念。

标准库：
C语言的标准库提供了基本的操作函数和常用的数据结构、如数组、字符串的处理、文件操作等。
C++语言是C语言标准库的拓展，提供丰富的容器（vector、list等）和算法（排序、查找等），以及输入输出流等功能。

内存管理：
C语言中，需要手动管理内存分配和释放，使用malloc、free等函数进行动态内存的管理。
C++语言引入了析构函数和构造函数，通过new和delete关键字自动管理内存分配和释放，减少了内存泄漏和错误释放的风险。

在C++中，可以完全兼容C语言，可以直接调用C语言编写的库函数和代码。

命名空间

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的，

在C语言中，

#include
int printf = 5;
int main()
{
	
	printf("%d", printf);
	return 0;
}

这种做法是错误的，printf是一个打印到屏幕的函数，由于你对变量的命名与函数名一致，就会导致编辑器认为printf就是创建的临时变量，printf函数也就无法使用。

命名空间的定义和使用

命名空间关键字为namespace，它是将全局作用域进行划分，规定出自己的区域，这样同名者就不会进行冲突了。就像你们村有个叫张三的，隔壁村也有个叫张三的，只要你说我们村的张三的，那么就知道你要找哪个张三了。

定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。

namespace sea
{
	int printf = 10;
	int Add(int left, int right)
	{
	return left + right;
	}

 struct Node
 {
	struct Node* next;
	int val;
 };
}

这样就规定了上面使用的结构体，printf，Add就在sea命名空间内了。

命名空间也是可以嵌套使用的，就像一个大的村子里面，还有很多个小村；

namespace sea1
{
	int a;
	int b;
	int Add(int left, int right)
	 {
	     return left + right;
	 }
	namespace sea2//嵌套
	 {
	     int c;
	     int d;
	     int Sub(int left, int right)
	     {
	         return left - right;
	     }
	 }
}

对于同样的命名，编辑器会自动规划在同一片区域：

namespace sea1
{
	int a;
	int b;
	int Add(int left, int right)
	{
		return left + right;
	}
	namespace N2//嵌套
	{
		int c;
		int d;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
namespace sea1
{
	int a = 10;
	int c;
}

将命名空间进行调用，发现两个创建的变量和函数都放到一起，所以可以看出同样的命名空间会自动划分为同样一块区域；
而像a这样的，会报错，出现重定义：

对于命名空间的使用，有三种方式，
第一种就是上面的方式：

int main()
{
	//::表示作用域限定符::，对作用域内的函数、变量等进行调用
	printf("%d\n",sea1::a);
}

第二种：使用using将命名空间中某个成员引入

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

第三种：使用using namespace 命名空间名称 引入

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

C++的输入输出

对于C++来说，输入输出不只是可以用printf和scanf，

#include 
using namespace std;
int main()
{
	//直接输出
	cout<<"hello"<<endl;
	//类型不同
	int a = 10;
	cout << a << endl;
	float b = 3.33;
	cout << b << endl;
	//输入
	cin >> a;
	cout << a << endl;
	return 0;
}

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件
   以及按命名空间使用方法使用std。
   2.== cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出==，他们都包含在包含<
   iostream >头文件中。
   3.== <<是流插入运算符，>>是流提取运算符==。
2. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。
   C++的输入输出可以自动识别变量类型。
   具体介绍后面章节会说，这里我们只要记住，cout类似于printf一样
   cin类似于scanf

缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

void f(int a=10, int b=15, int c=20)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;

}
int main()
{
	//缺省参数
	f();
}

输出：10 15 20
像这种形参中都用成缺省参数，称之为全缺省参数；

	f(1, 2, 3);//全缺省参数，可以全部传参
	f(1, 2);
	f(1);

以上这种都可以进行实现；

1 2 3
1 2 20
1 15 20
对于引用缺省参数的函数来说，在进行函数调用传参时，默认从左到右进行传参，像上面f(1)一样，默认就是第一个传参了，其他的都用了缺省参数的调用值；

如果函数成这样：

void f(int a, int b, int c=20)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;

}

称之为半缺省参数

会发现，下面两个函数调用都是错误的，因为那些没有使用缺省参数的，你不传参表示没有值传参；

这里要注意，半缺省参数必须从右往左给，因为函数传参时默认是从左到右依次传参。

缺省参数不能在函数声明和定义中同时出现，否则，将会报错：

真要选其中一个进行定义，应该在声明中进行缺省参数。

缺省值必须是常量或者全局变量

函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

int f(int a,float b)
{
	cout << a << endl;
	cout << b << endl;

	return 0;
}
void f(float a)
{
	cout << a << endl;
	//cout << b << endl;
}

int main()
{
	f(1,2.2);
	f(2.2);
}
	

这种为函数参数个数不同；

int f(int a,float b)
{
	cout << a << endl;
	cout << b << endl;

	return 0;
}
void f(float a ,int b)
{
	cout << a << endl;
	cout << b << endl;
}

int main()
{
	f(1,2.2);
	f(2.2,1);
}

这种是函数参数位置不同

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

	
}
void f(double a ,double b)
{
	cout << a << endl;
	cout << b << endl;

}

int main()
{
	f(1,2);
	f(2.2,1.1);
}

这种为参数类型不同

而这里如果把double改为float的话，会进行报错，这是因为在VS2022中，1.1和2.2默认为double类型的常数，而double可以隐式转化为float或int，编译器就会报错；
解决方法是f(1.1f,2.2f);

引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

赋值与引用

int main()
{
	int a = 10;
	int& b = a;
	a = 11;
	cout << b << endl;
	//引用相当于别名，别人怎么改，它就怎么改
	return 0;
}

如果是赋值的话：

int main()
{
	int a = 10;
	int b = a;
	a = 11;
	cout << b << endl;
	//如果是赋值，一开始指向都是同个数，是相同的地址，一旦其中一个改变，
	//由于同个数有两个变量，所以另一个只能在别的地址开辟存储别的数；
	return 0;
}

引用在参数上的使用以及注意事项

引用可以应用在函数传参上，，这样函数调用的参数不会额外产生空间，可提高时间效率

int add(int* a, int* b)
{
	return *a + *b;
}
int add(int& a, int& b)
{
	return a + b;
}
int main()
{
	//int a = 10;
	//int b = a;
	//
	int& a1;//注意：引用须初始化变量
	// int& a2=10;//不可引用常量，引用的权限被放大
	//int& c = a;
	//int& d = a;

	int a = 10;
	int b = 20;
	int c=add(&a, &b);//运用到了重载
	cout << c << endl;
	int d=add(a, b);
	cout << d << endl;

	return 0;
}

函数返回值的引用

int& Count()
{
	int n = 90;
	
	return n;
}
int main()
{
	int ret = Count();
	int& ret1 = Count();
	
	cout<<ret<<endl;
	cout << ret1 << endl;//局部变量空间被销毁了，但还是输出正确的答案
	cout <<"l" << ret << endl//虽然空间被销毁了，但值还在那个位置上，ret是一个变量，可以使用
	cout <<"l" << ret1 << endl;//临时拷贝被‘l'所占领，ret1输出随机值
	//是因为返回的值是随机值或者临时拷贝
	//该编译器会保留住一个临时拷贝
}

以上这种使用方法是错误的，而是在调用函数的变量前加上static或者调用的变量是全局变量，使变量不会随着函数栈帧销毁而销毁，保留变量所属空间去引用才是正确的。

引用与值的时间效率比较

#include 
struct A { int a[10000]; };

void TestFunc1(A aa) {}

void TestFunc2(A& aa) {}

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;
	//8:0,传值还需要不断创建参数栈帧和销毁，而引用不用
	
}

常引用

	int a = 10;
	//int& b = a;//引用时权限平等
	const int& b = a;//引用时可权限放小

	cout << b << endl;//10
	a = 20;
	cout << b << endl;//20
	//a修改时，b有相当于只读，所读值也会改变
	b = 20;//错误，引用的b虽然同样是a的别名，但是权限只限制于读，即b是无法修改的
	const int c = a;//可以，赋值时c是另一个变量，const把他变为常变量

所以，引用的权限可以平等和放小，但不能放大；就像一个常量不能用int&来进行引用；