初识C++_c++ forever-CSDN博客

本文链接：https://blog.csdn.net/sun_0228/article/details/126987561

·C++发展史：

C语言是结构化和模块化的语言，适合处理较小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言就显得不那么合适。计算机界随后提出了面向对象的思想，C++应运而生。C++是基于C语言而产生的，它既可以进行C语言的过程化程序设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

C++98：C++标准第一个版本，绝大多数编译器都支持，得到了国际标准化组织(ISO)和美国标准化协会认可，以模板方式重写C++标准库，引入了STL(标准模板库)。

C++11：自C++11以来最大的发行版，引入了许多新的特性，比如：模块(Modules)、协程

(Coroutines) 、范围 (Ranges) 、概念 (Constraints) 等重大特性，还有对已有特性的更新：比如Lambda 支持模板、范围 for 支持初始化等。

·C++的新增与改进：

1.命名空间：

关于rand()函数的定义rand - C++ Referencehttps://legacy.cplusplus.com/reference/cstdlib/rand/?kw=rand

这里可以看到->编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”，在c语言中我们没有解决办法去解决这个重定义问题，C++就提出了命名空间解决此类问题。

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

现在我们就能通过运行啦！！！但我们会面临以下问题，每次调用都得去声明在哪个域内，这不免会显得繁琐。于是出现了命名空间using声明 这样我们就可以直接使用了

特别注意的是我们在用到与库函数声明相同的函数名称时，还是得特别指出。

命名空间还可以进行嵌套，同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中——

#include<iostream>
using namespace std;
namespace N1
{
	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 N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

int main()
{
	N1::a = 1;
	N1::b = 2;
	cout << N1::Add(N1::a, N1::b) << endl;
	cout << N1::Mul(N1::a, N1::b) << endl;
	N1::N2::c = 3;
	N1::N2::d = 4;
	cout << N1::N2::Sub(N1::N2::c, N1::N2::d) << endl;

	return 0;
}

2.缺省参数

就是在声明函数的某个参数的时候为之指定一个默认值，在调用该函数的时候如果采用该默认值，你就无须指定该参数。缺省参数使用主要规则：调用时你只能从最后一个参数开始进行省略，换句话说，如果你要省略一个参数，你必须省略它后面所有的参数，即：带缺省值的参数必须放在参数表的最后面。缺省值必须是常量。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

void Func1(int a, int b, int c) {
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
//半缺省
void Func2(int a, int b = 1, int c = 2){
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}
//全缺省
void Func3(int a = 0, int b = 1, int c = 2) {
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

int main()
{
	Func1(0, 1, 2);		//必须每个值都要传参
	cout << endl;
	Func2(1);	
	Func2(1,3);
	Func2(1,3,5);		//至少要传入第一个参数值,否则用缺省值，
					//也就是不给b，c的值，b=2，c=3
	cout << endl;
	Func3();		//可以都不给，直接用缺省值
	Func3(3);
	Func3(3,4);
	Func3(3,4,5);		
	return 0;
}

3.函数重载

重载函数_百度百科

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

#include<iostream>
using namespace std;

// 1、参数类型不同
void Add(int a, int b) {
	cout << "void Add(int a, int b)" << endl;
}
void Add(double a, double b) {
	cout << "void Add(double a, double b)" << endl;
}
// 2、参数个数不同
void f()
{
	cout << "f()" << endl;
}
void f(int a) {
	cout << "f(int a)" << endl;
}
// 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;
}
int main()
{
	Add(10, 20);
	Add(10.1, 20.2);
	f();
	f(10);
	f(10, 'a');
	f('a', 10);
	return 0;
}

返回值不同不能构成重载！！！

4.复合类型（指针和引用）：

·引用：

引用即为对象起了一个新的名称。我们通常通过声明&d（d为变量名）的形式来定义引用类型。

一般的初始化我们只进行值拷贝，然而定义引用的时候，程序会将引用和初始值联系在一起，两者储存地址相同。一旦初始化完成，那么引用对象和它的初始化对象始终在一起，无法重定义。如果进行修改则初始值对象也会被修改。

生活中我们可以有多个小名，引用也不列外——

这里的refnum，refnum2都是num的别称。

不能对常量直接引用，引用类型的初始值必须是一个对象。引用类型也必须进行匹配。

·引用的适用场景：

比如交换函数，我们不用再去传指针，直接传引用。

在以下函数中，两次调用Add函数，所得值为什么会是“7”呢？

经过调试后可以看出，返回值的地址并没有发生变化，所以在第二次调用后，c地址上对应的值改变了，然而ret又是返回值的别名，所以ret随之变化。

·引用和指针：

引用只是原对象的一个别名，并没有额外开辟空间，和原对象共用一块地址空间，所以会发生改引用则原对象也发生修改的情况；指针则是开辟了4字节(32位系统下，64位系统为8字节)的空间来指向原对象。然而引用的底层实现却和指针几乎一模一样——

两者的不同：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时 必须初始化 ，指针没有要求

3. 引用在初始化时引用一个实体后，就 不能再引用其他实体 ，而指针可以在任何时候指向任何一个同类型实体

4. 没有 NULL 引用，但有 NULL 指针

5. 在 sizeof 中含义不同 ：引用结果为 引用类型的大小 ，但指针始终是 地址空间所占字节个数 (32 位平台下占 4个字节 )

6. 引用自加即引用的实体增加 1 ，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同， 指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

5.初谈初始化列表：

对于初始化，我们在C中学到，在创建一个变量的时候，通常使用“=”给其进行初始化操作。但对于“=”或许有些许争论，我们在进行赋值操作的时候也是用的这个符号，那么初始化=赋值吗？答案是肯定不等于——（这里引用primer中的一个警告）初始化并不等于赋值，初始化的含义是创建变量时赋予一个初始值，而赋值的含义是把对象的当前值擦除，以一个新的值来代替！

那么我们对于对象的初始化方式只有一种吗？肯定不是的——