C++ 入门

命名空间

使用命名空间的目的是对标识符的名称进行本地化，防止命名污染和冲突

#include <stdio.h>
#include <stdlib.h>
int rand = 10;

int main()
{
	printf("%d\n", rand);
	return 0;
}

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

C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决

定义

namespace N
{
	// 命名空间中可以定义变量/函数/类型
	int rand = 10;
	int Add(int left, int right)
	{
		return left + right;
	}
		struct Node
	{
		struct Node* next;
		int val;
	};
}
//2. 命名空间可以嵌套
// test.cpp
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;
		}
	}
}
//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
	int Mul(int left, int right)
	{
		return left * right;
	}
}

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

 使用

namespace N
{
	// 命名空间中可以定义变量/函数/类型
	int a = 0;
	int b = 1;
	int Add(int left, int right)
	{
		return left + right;
	}
	struct Node
	{
		struct Node* next;
		int val;
	};
}
int main()
{
	printf("%d\n", a);  
    //编译报错：error C2065: “a”: 未声明的标识符
	return 0;
}
//下面三种正确使用命名空间
//加命名空间名称及作用域限定符
int main()
{
	printf("%d\n", N::a);
	return 0;
}
//使用using将命名空间中某个成员引入
using N::b;
int main()
{
	printf("%d\n", N::a);
	printf("%d\n", b);
	return 0;
}
//使用using namespace 命名空间名称 引入
using namespace N;
int main()
{
	printf("%d\n", N::a);
	printf("%d\n", b);
	Add(10, 20);
	return 0;
}

缺省参数

概念

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

#include<iostream>
using namespace std;

void Func(int a = 0)
{
	cout << a << endl;
}
int main()
{
	Func();     // 没有传参时，使用参数的默认值
	Func(10);   // 传参时，使用指定的实参
	return 0;
}

分类

全缺省参数

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

半缺省参数

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

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给
2. 缺省参数不能在函数声明和定义中同时出现
3. 缺省值必须是常量或者全局变量
4. C语言不支持（编译器不支持）

函数重载

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

// 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;
}
// 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;
}

引用

概念

引用是给某一个对象起了另外一个名字，可以通过这个别名来对原对象进行操作，同时编译器不会对引用变量开辟空间，它和它所引用的对象共用一个空间。

用法

类型 & 引用对象名 = 引用实体（引用类型必须和实体类型保持一致）

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& ra = a;
	cout << a << " " << ra << endl;
	ra = 0;
	cout << a << " " << ra << endl;
	return 0;
}

特性

1、引用在定义的时候必须初始化

2、一个对象可以有多个引用

3、一旦引用一个实体，就不能再引用别的实体

常引用

int main()
{
	const int a = 10;
	//int& ra = a;   // 该语句编译时会出错，a为常量
	const int& ra = a;
	
	// int& b = 10; // 该语句编译时会出错，b为常量
	const int& b = 10;
}

引用可以将权限缩小、平移，但不可以将权限扩大 

因为a是const修饰的常量，所以理应无法修改它的值，但不使用const修饰的引用却能修改a的值，这是将权限扩大，所以编译器会报错，所以必须使用const修饰的引用才不会报错。

引用的跨类型 

这个过程是因为引用遇到不同类型时会先引用一个临时变量来引用x，然后再引用这个临时变量。

但是临时变量具有常性，所以第一种引用时非法的，而第二种表明不能对临时变量修改，所以是合法的

使用场景

作为参数是，引用可以作为输出型参数，减少拷贝效率

当作为返回值时，引用可以修改返回对象，减少拷贝效率

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;
}

Add函数运行结束后，该函数对应的栈空间就被回收了，即c变量就没有意义了，在main中ret引用Add函数返回值，实际应用的就是一块已经被释放的空间。空间被回收了指的是空间不能使用了，但是控件本身还在，而ret引用的c的位置被修改成7了，因此ret的值就改变了。

注意：如果函数返回时，出了函数作用域，如果返回对象还在，则可以使用引用返回，如果还给系统了，则必须使用传值返回。

引用和指针

引用和指针在功能上是重叠的，类似的

c++的引用可以替代一些复杂场景下的指针让代码简单化，但不能完全替代指针，因为引用定义后不能改变指向。

通过反汇编我们可以看到，引用在底层方面其实和指针是一样的，引用的底层就是用指针实现的。

但是他们在语法上是有区别的

1.引用在定义的时候必须初始化

2.引用是别名，不需要开空间，指针是地址，需要开空间存地址

3.引用不可以改变指向，指针可以

4.引用相对安全，只有空指针和野指针没有空引用，相对应，只有NULL指针，没有NULL引用

5.在sizeof下，引用的结果为引用类型的大小，但指针始终是空间地址所占字节个数

6.引用自加一，即引用的实体加一，指针加一，是指针向后偏移一个地址

7.有多级指针没有多级引用

内联函数

用inline关键字修饰的函数就是内联函数，在编译时编译器会将函数的代码在调用内联函数的地方展开，减去了函数压栈的开销，提升程序运行的效率。

内联函数的特性

内联函数是一种空间换时间的做法，省去了创建栈和压栈的开销，但是代码复杂或循环递归就会被编译器忽略，因为内联说明只是向编译器发出请求，编译器可以选择忽略。

内联函数不能声明和定义分离，因为一旦声明为内联函数，在调用的时候就会直接展开，没有了函数的地址，就无法将其链接到定义的部分。

内联函数与C语言中的宏函数有些类似，虽然宏的性能不错，但是因为宏缺乏类型的安全检查和无法调试（在预处理阶段就进行了宏替换），在C++中宏函数被内联函数替代，宏常量定义被const取代。

auto

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一
个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

1.auto可以和指针和引用结合使用

用auto声明指针类型时，用auto和auto* 没有任何区别，但用auto声明引用类型时则必须加& 

2.在同一行定义多个变量

void TestAuto()
{
	auto a = 1, b = 2;
	auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译
器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。 

3.auto一般会忽略顶层const

4.auto不能作为函数的参数，不能用来声明数组

范围for循环

对于一些有范围的集合，我们可能不知道他的长度或者在使用循环的时候不小心越界，c++11为了解决这个问题，引入了范围for循环。

循环分为两部分，第一部分是变量的类型，第二部分是被迭代的范围，两者中间用:隔开。

int main()
{
	int array[] = { 1,2,3,4,5 };
	for (auto& e : array)
	{
		e += 2;
		cout << e << " ";
	}
	cout << endl;
}