#include <stdio.h>
#include <stdlib.h>
int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决
int main()

 printf("%d\\n", rand);
return 0;

// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

2.1定义命名空间

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

被定义的在命名空间中的变量，函数等不能被直接访问

下面是正确的访问方式

namespace lrt

	class date
	
	public:
		int year;
		int month;
		int day;
	;


namespace lwj

	class SeqList
	
	public:
		int size;
	;


int main()

	lrt::date date;
	int a = date.year;

2.2使用using将命名空间中某个成员引入

2.3使用using namespace 命名空间名称引入

namespace lwj

	class SeqList
	
	public:
		int size;
	;


using namespace lwj;
int main()

	SeqList List1;

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

3. C++输入&输出

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

3. >是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。 C++的输入输出可以自动识别变量类型。

5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载等知识，

#include <iostream>
using namespace std;
int main()

    // 可以自动识别变量的类型
	float a;
	int b;
	cin >> a >> b;
    cout<<a<<" "<<b<<endl;
   return 0;

4. 缺省参数

4.1 缺省参数概念

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

void Func(int in = 0)

 cout<<in<<endl;

int main()

 Func();     // 没有传参时，使用参数的默认值
 Func(100);   // 传参时，使用指定的实参
retur

2 缺省参数分类

2.1全缺省参数

void Func(int a = 10, int b = 20, int c = 30)
 
     cout<<"a = "<<a<<" ";
     cout<<"b = "<<b<<" ";
     cout<<"c = "<<c<<" ";

2.2半缺省参数


void Func(int a , int b = 20, int c)
 
     cout<<"a = "<<a<<" ";
     cout<<"b = "<<b<<" ";
     cout<<"c = "<<c<<" ";

注意:

1. 半缺省参数必须从右往左依次来给出，不能间隔着给

2. 缺省参数不能在函数声明和定义中同时出现

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

4. C语言不支持（编译器不支持）

5. 函数重载

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

1. 实际项目通常是由多个头文件和多个源文件构成，而通过C语言阶段学习的编译链接，我们可以知道，【当前a.cpp中调用了b.cpp中定义的Add函数时】，编译后链接前，a.o的目标文件中没有Add的函数地址，因为Add是在b.cpp中定义的，所以Add的地址在b.o中。那么怎么办呢？

2. 所以链接阶段就是专门处理这种问题，链接器看到a.o调用Add，但是没有Add的地址，就会到b.o生成的符号表中找Add的地址，然后链接到一起。

3. 那么链接时，面对Add函数，链接接器会使用哪个名字去找呢？这里每个编译器都有自己的函数名修饰规则。

举例：

在linux下，采用gcc编译完成后，函数名字的修饰没有发生改变。

在linux下，采用g++编译完成后，函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

所以C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分。

6. 内联函数

6.1 概念以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

6.2 特性

1. inline是一种以空间换时间（生成的可执行程序变大）的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、若是递归、且频繁调用的函数采用inline修饰，则编译器会忽略inline特性，把它当做普通函数处理。（inline函数不能写的太长，太多运算）

3. inline不建议声明和定义分离，分离会导致链接错误。因为inline在编译时被展开，但定义和声明分离导致展开失败，同时不会在编译时进入符号表，链接就会找不到。

6.3宏的优缺点？

优点：

1.增强代码的复用性。

2.提高性能。

缺点：

1.不方便调试宏。（因为预编译阶段进行了替换）

2.导致代码可读性差，可维护性差，容易误用。

#define ADD(X,Y) X+Y;
#define ADD(X,Y) (X+Y);  //a||b+c&&d 加的优先级更高
#define ADD(X,Y) (X)+(Y);
#define ADD(X,Y) ((X)+(Y));

3.没有类型安全的检查。

C++有哪些技术替代宏？

1. 常量定义换用const enum

2. 短小函数定义换用内联函数

C++初阶：入门总结命名空间 | 缺省参数 | 函数重载 | 引用 | 内联函数

文章目录

【写在前面】

点到为止，并不深入。其次建工程这里就不说了，在之前的基础上 —— 文件名.cpp 就可以了

一、C++关键字 (C++98)

💨 C 语言有 32 个关键字，而 C++ 有 63 个关键字，C 语言的关键字在 C++ 中继续可以使用

ps：在本章中不对关键字进行详讲

❗ I/O ❕

//C++兼容C绝大多数语法 
#include<stdio.h>
int main01()

	printf("Hello CPLUSPLUS\\n");
	return 0;

//但C++通常会这样写
#include<iostream>
using namespace std;
int main()

	cout << "Hello CPLUSPLUS" << endl;
	return 0;

二、命名空间

对比 C 语言，一般 C++ 每增加一个语法都是为了解决一些 C 语言做不到的事或者是 C 语言做的不好的地方

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

❗ C语言命名冲突示例 ❕

在不同的作用域中，可以定义同名的变量；在同一作用域下，不能定义同名的变量

#include<stdio.h>
//#include<stdlib.h>
int a = 0;
int rand = 10;
int main()

	int a = 1;
	printf("%d\\n", rand);
	return 0;

📝 分析：

可以看到我们定义了一个 rand 变量输出是没有问题的，但如果包含了 stdlib 头时就会产生命名冲突，此时我们的 rand 变量就和库里的产生冲突；
实际除此之外在大型项目开发时，还有可能和同事之间发生冲突。C 语言面对这种问题是无法解决的，而对于这种场景 C++ 使用了命名空间

💦 命名空间定义

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

⚠ 注意一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

//1. 普通的命名空间
namespace N1 // N1为命名空间的名称

 	//命名空间中的内容，既可以定义变量，也可以定义函数
 	int a;
 	int Add(int left, int right)
 	
 		return left + right;
 	

//2. 命名空间可以嵌套
namespace N2

	 int a;
	 int b;
	 int Add(int left, int right)
	 
		 return left + right;
	 
 
 	namespace N3
 	
		 int c;
		 int d;
 		int Sub(int left, int right)
 		
			 return left - right;
		
	

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中
namespace N1

 	int a = 10;

namespace N1

 	int b = 20;

❗ 用命名空间解决变量 rand 和 stdlib 库里的命名冲突 ❕

#include<stdio.h>
#include<stdlib.h>
namespace WD//定义了一个命名空间域

	int rand = 10;//定义变量
	int Add(int x, int y)//定义函数
	
		return x + y;	
	
	struct Node//定义结构体类型
	
		struct Node* next;
		int val;	
	;

int main()

	printf("%p\\n", rand);//函数指针
	printf("%d\\n", WD::rand);//rand变量；‘::’叫做域作用限定符
	WD::Add(3, 5);//调用函数
	struct WD::Node node1;//结构体
	
	return 0;

❗ 嵌套命名空间 ❕

#include<stdio.h>
#include<stdlib.h>
namespace WD

	int w = 20;
	int h = 10;
	namespace WH//嵌套命名空间域
	
		int w = 10;
		int h = 20;
	

int main()

	printf("%d\\n", WD::WH::h);//访问嵌套命名空间
	return 0;

❗ 相同名称的命名空间 ❕

namespace WD

	int a = 10;
	int b = 20;
	namespace WH
	
		int a = 20;
		int b = 10;
	

namespace WD//相同名称的命名空间

	int rand = 50;
	//int a = 10;//err，在合并的时候冲突了

💦 命名空间使用

❓ 如何使用命名空间里的东西 ❔

1️⃣ 全部直接展开到全局

using namespace WD;
//using namespace std;//std是包含C++标准库的命名空间

💨优点：用起来方便

💨缺点：自己定义的东西也会暴露，导致命名污染

2️⃣ 访问每个命名空间中的东西时，指定命名空间

std::rand;

💨优点：不存在命名污染

💨缺点：如果要去访问多个命名空间里的东西时，需要一一指定

3️⃣ 仅展开常用的内容

using WD::Node;
using WD::Add;

💨优点：不会造成大面积的污染；把常用的展开后，也不需要一一指定

namespace WD

	int a = 10;
	int b = 20;
	//...

int main()

	//using namespace WD;//1.展开WD空间所有内容
	//printf("%d\\n", WD::a);//2.指定命名空间
	//using WD::a;//3.仅展开a

❓ 上面说了 C++ 把库里的东西都放到 std 这个域里了，那直接展开 std 不就行了或者包头 ❔

注意

1️⃣ #include <iostream>：展开定义

2️⃣ using namespace std;：允许用

所以两者缺一不可

三、C++中的I/O

❗ 说明 ❕

使用 cout 标准输出 (控制台) 和 cin 标准输入 (键盘) 时，必须包含 < iostream> 头文件以及 std 标准命名空间（std是包含 C++ 标准库的命名空间）
⚠ 注意早期标准库将所有功能在全局域中实现，声明在 .h 后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在 std 命名空间下，为了和 C 头文件区分，也为了正确使用命名空间，规定 C++ 头文件不带 .h ；旧编译器 (vc 6.0) 中还支持 <iostream.h> 格式，后续编译器已不支持，因此推荐使用 < iostream > + std 的方式。

#include<iostream>
using namespace std;
int main()

	cout<<"Hello world!!!"<<endl;
	return 0;

❗ 上面这种写法其实有一定的规范缺陷 ❕

C++ 为什么用一个库去包它的命名空间，就是怕我们定义的与库冲突。但是一句 using namespace std; 就把库展开了，那么定义 std 的优势就无了。所以在项目中比较规范的写法如下：

#include<iostream>
//展开常用————工程项目中常见的对命名空间的用法
using std::cout;
using std::endl;
int main()

	//只要是库里的都得指定std
	//std::cout << "Hello world!!!" << std::endl
	//但如果cout经常要用的话，就在上面单独展开
	cout << "Hello world!!!" << endl;
	return 0;

⚠ 注意，在日常做题时不需要像项目那样规范，可以直接全部展开 std

❗ cout && cin ❕

cout 和 cin 类似 C 语言的 printf 和 scanf，这里只是先了解下，因为对于 C 语言中的 I/O 是函数，而 C++ 是对象

#include<iostream>
using namespace std;
int main()

	int n;
	cin >> n;//cin可以理解为键盘；>>可以理解为输入运算符/流提取运算符(官方)
	int* a = (int*)malloc(sizeof(int) * n);
	for(int i = 0; i < n; ++i)
	
		cin >> a[i];
	
	for(int i = 0; i < n; ++i)
	
		cout << a[i] << " ";//cout可以理解为控制台；<<可以理解为输出运算符/流插入运算符(官方)
	
	cout << endl;//等价于count << '\\n';
	return 0;

❗ 对于I/O，C++比C便捷 ❕

C++ 不需增加数据格式控制，比如：整形 – %d，字符 – %c，它会自动实别

#include<iostream>
using namespace std;
int main01()

	int n;
	cin >> n;
	double* a = (double*)malloc(sizeof(int) * n);
	for(int i = 0; i < n; ++i)
	
		cin >> a[i];//它会自动实别
	
	for(int i = 0; i < n; ++i)
	
		cout << a[i] << " ";//它会自动实别
	
	count << endl;
	return 0;

//挺爽的吧！！！
int main()

	char ch = 'C';
	int i = 10;
	int* p = &i;
	double d = 3.14;
	double b = 3.1415926;
	cout << ch << endl;
	cout << i << endl;
	cout << p << endl;
	cout << d << endl;
	cout << b << endl;//注意对于浮点数，C++最多输出5位，当然也可以指定输出多少位，但是相对指定的方式(比较麻烦)可以配合printf使用
	return 0;

❗ 当然C++也并不完美 ❕

#include<iostream>
using namespace std;
struct Student

	char name[10];
	int age;
;
int main()

	struct Student s =  "小三", 18 ;
	//输出结构体信息。类似下面场景printf更好
	//对于这种情况C++中不用纠结用啥，用习惯自己的就好
	cout << "名字:" << s.name << " " << "年龄:" << s.age << endl;
	printf("名字:%s 年龄:%d\\n", s.name, s.age);
	return 0;

四、缺省参数

💦 缺省参数概念

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

#include<iostream>
using namespace std;
void TestFunc(int a = 0)//参数缺省值

	cout << a << endl;

int main()

	TestFunc();//没有指定实参，使用缺省值
	TestFunc(10);//指定实参，使用实参
	return 0;

❗ 有什么用 ❕

比如在 C 语言中有个很苦恼的问题是写栈时，不知道要开多大的空间，之前我们是如果栈为空就先开 4 块空间，之后再以 2 倍走，如果我们明确知道要很大的空间，那么这样就只能一点一点的接近这块空间，就太 low 了。但如果我们使用缺省，明确知道不需要太大时就使用默认的空间大小，明确知道要很大时再传参

#include<iostream>
using namespace std;
namespace WD

	struct Stack
	
		int* a;
		int size;
		int capacity;	
	;

using namespace WD;
void StackInit(struct Stack* ps)

	ps->a = NULL; 
	ps->capacity = 0;
	ps->size = 0;

void StackPush(struct Stack* ps, int x)

	if(ps->size == ps->capacity)
	
		//ps->capacity *= 2;//err
		ps->capacity == 0 ? 4 : ps->capacity * 2;//这里就必须写一个三目
	


void StackInitCpp1(struct Stack* ps, int defaultCP)

	ps->a = (int*)malloc(sizeof(int) * defaultCP);
	ps->capacity = 0;
	ps->size = defaultCP;

void StackInitCpp2(struct Stack* ps, int defaultCP = 4)//ok

	ps->a = (int*)malloc(sizeof(int) * defaultCP);
	ps->capacity = 0;
	ps->size = defaultCP;

int main()

	//假设明确知道这里至少需要100个数据到st1
	struct Stack st1; 
	StackInitCpp1(&st1, 100);
	//假设不知道st2里需要多少个数据 ———— 希望开小点
	struct Stack st2;  
	StackInitCpp2(&st1);//缺省
	return 0;

💦 缺省参数分类

❗ 全缺省参数 ❕

void TestFunc(int a = 10, int b = 20, int c = 30)

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << endl;

int main()

	//非常灵活，
	TestFunc();
	TestFunc(1);
	TestFunc(1, 2);
	TestFunc(1, 2, 3);	
	//TestFunc(1, , 3);//err，注意它没办法实现b不传，只传a和b，也就是说编译器只能按照顺序传
	return 0;

⚠ 注意：

1️⃣ 全缺省参数只支持顺序传参

❗ 半缺省参数 ❕

//void TestFunc(int a, int b = 10, /*int f, - err*/ int c = 20);//err，

void TestFunc(int a, int b = 10, /*int f, int x = y, -> err*/ int c = 20)

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	cout << endl;

int main()

	//TestFunc();//err，至少得传一个，这是根据形参有几个非半缺省参数确定的
	TestFunc(1);
	TestFunc(1, 2);
	TestFunc(1, 2, 3);	
	return 0;

//a.h
void TestFunc(int a = 10);
//a.cpp
void TestFunc(int a = 20)

⚠ 注意：

1️⃣ 半缺省参数必须从右往左依次来给出，且不能间隔着给

2️⃣ 缺省参数不能在函数声明和定义中同时出现

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

4️⃣ C 语言不支持缺省

五、函数重载

自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。

比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是 “谁也赢不了！”，后者是 “谁也赢不了！”

💦 函数重载概念

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

//1.参数个数
int Add(int x)

int Add(int x, int y)

//2.参数类型
int Add(int x, int y)

int Add(int x, double y)

//3.参数顺序
int Add(int x, float y)

int Add(float y, int x)

❗ 怎么调用 ❕

int Add(int left, int right)

	return left + right;

double Add(double left, double right)

	return left + right;

long Add(long left, long right)

	return left + right;

int main()

	//这里分别调用三种不同的函数
	Add(10, 20);//默认整型
	Add(10.0, 20.0);//浮点型
	Add(10L, 20L);//长整型
	return 0;