Lesson0: C++基础

1. 命名空间

解决变量、函数和类的名称出现命名冲突的问题 

1.1 命名冲突

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
int rand = 0;
int main()
{
	printf("%d\n", rand);
	return 0;
}

•  这里的rand和C标准库的stdlib.h中的rand函数会发生命名冲突，rand重定义

 1.2 嵌套定义

//命名空间的嵌套定义
namespace N1 //定义一个名为N1的命名空间
{
	int a;
	int b;
	namespace N2 //嵌套定义另一个名为N2的命名空间
	{
		int c;
		int d;
	}
}

•  同一个工程中允许存在多个相同名称的命名空间，编译器最后会将其成员合成在同一个命名空间中
• 但是我们不能在相同名称的命名空间中定义两个相同名称的成员

1.3 命名空间的使用

1.3.1 加命名空间名称及作用域限定符

#include <iostream>
namespace ly
{
	// 自动识别类型
	int i = 11;
	double d = 22.33;
}

int main()
{
	printf("%d,%lf", ly::i, ly::d);
	return 0;
}

• :: 叫做域作用限定符
• 编译器一般先访问局部域中找，再从全局域找，再从自定义域中找， 

1.3.2 使用using将命名空间中成员引入

#include <iostream>
using std::cout;
using std::endl;
int main()
{
	// 自动识别类型
	int i = 11;
	double d = 22.33;

	// >>流提取
	cout << i << "," << d << std::endl;

	return 0;
}

•  这里使用C++中的using关键字，只会直接把C++中的std命名空间中的cout和endl成员展开 

 1.3.3 使用using namespace 展开命名空间

#include <iostream>
using namespace std;
int main()
{
	// 自动识别类型
	int i = 11;
	double d = 22.33;

	// >>流提取
	cout << i << "," << d << std::endl;

	return 0;
}

• 这里使用C++中的using关键字，会直接把C++中的std命名空间中的所有成员展开

2. 缺省参数

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

2.1 全缺省参数

#include <iostream>
using namespace std;

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

int main()
{
	int a = 0, b = 0, c = 0;
	Print();
	return 0;
}

 2.2 半缺省参数

#include <iostream>
using namespace std;

void Print(int a, int b, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

int main()
{
	int a = 0, b = 0, c = 0;
	Print(a,b);
	return 0;
}

• 半缺省参数必须从右往左依次给出，不能间隔着给 
• 缺省参数不能在函数声明和定义中同时出现

3. 函数重载

C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表必须不同 

 3.1 错误案例一

#include<iostream>
using namespace std;
double Add(double left, double right)
{
	return left + right;
}

double Add(double right, double left)
{
	return left + right;
}

int main()
{
	cout << Add(1.1, 2.2) << endl;
	return 0;
}

• 因为是同类型的，所以顺序改变是没有用的，编译器是不能区分的

3.2 错误案例二

#include<iostream>
using namespace std;
short Add(short left, short right)
{
	return left + right;
}

int Add(short left, short right)
{
	return left + right;
}

int main() {
	cout << Add(1, 2) << endl;
	cout << Add(1, 2) << endl;
	return 0;
}

• 返回值类型不同是不够成重载的，编译器是不能区分的

3.3 函数重载的优势

#include<iostream>
using namespace std;
//两个函数类型不同
//void Swapi(int* p1, int* p2)
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//void Swapd(double* p1, double* p2)
void Swap(double* p1, double* p2)
{
	double tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

int main()
{
	int a = 1, b = 2;
	double c = 1.1, d = 2.2;
	Swap(&a, &b);
	Swap(&c, &d);

	cout << a;
	cout << c;

	return 0;
}

• 在C++中出现了函数重载使代码更加简洁，看上就像是在调用同一函数一样
• 而C语言是没有函数重载的概念，写起来就会麻烦点，代码也不简洁

3.4 理解C语言不支持函数重载

•  这一堆报错就是gcc编译器中的函数重定义

•  这要是用g++编译器，就没有问题

3.4.1 C++的函数名修饰规则

首先我们知道程序翻译的最后一个过程是链接

• 汇编阶段: 把每个源文件汇总出来的符号分配一个地址（若符号只是一个声明，则给其分配一个无意义的地址），然后分别生成一个符号表。
• 链接期间: 会将每个源文件的符号表进行合并，若不同源文件的符号表中出现了相同的符号，则取合法的地址为合并后的地址

---

•  而上面的代码gcc编译器想要编译通过，只能改代码，改函数名，
• C语言没有函数名修饰规则，不支持函数重载

3.4.2 总结:

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

2. 另外我们也理解了，为什么函数重载要求参数不同，与返回值没关系。 

4. 引用

给变量取了一个别名,不开辟空间

#include<iostream>
using namespace std;
int main()
{
	int a = 0;
	int& b = a;
	cout << &b << endl; // 取地址
	cout << &a << endl; // 取地址
	a++;
	b++;
	cout << b << endl;//2
	cout << a << endl;//2
	return 0;
}

•  这里的int & b = a;&不是取地址，而是C++的引用，注意和C语言区分

4.1 引用的三个特性

#include<iostream>
using namespace std;
int main()
{
	int a = 1;
	// int& b;  // 1、引用在定义时必须初始化

	int& c = a;
	int& d = c;

	int& b = a; // 2、一个变量可以有多个引用
	++a;
	cout << b << endl;
	cout << a << endl;
	
	int x = 10;
	// 3、引用一旦引用一个实体，再不能引用其他实体
	b = x; // 这里b不是x的别名，是把x赋值给a的别名b
	cout << b << endl;
	++x;
	cout << x << endl;
	return 0;
}

• 引用在定义时必须初始化
• 一个变量可以有多个引用
• 一个引用只能是一个变量的别名

4.2 使用场景

#include<iostream>
using namespace std;
int& Count1()
{
	int n = 0;
	n++;
	return n;
}

int& Count2()
{
	static int n = 0;
	n++;
	return n;
}

int main() {
	int& ret1 = Count1();
	printf("ret1第一次：%d\n", ret1);
	printf("ret1第二次：%d\n", ret1);
	int& ret2 = Count2();
	printf("ret2第一次：%d\n", ret2);
	printf("ret2第二次：%d\n", ret2);
	return 0;
}

• Count1函数中的n是在栈区开辟空间的，而这里是传引用返回，返回的是n这个变量，而Count1函数栈帧被销毁之后，自然变量n就不在了，自然就是随机值
• 注意：这里ret1第一次打印是1，实属巧合，再打印第二次，结果是随机值(如果栈帧结束，系统会清理栈帧并置成随机值)，因为printf函数也是会形成栈帧，就可能会把Count1函数之前形成栈帧的那块空间覆盖掉
•  被static修饰的变量是放在静态区的，Count2函数返回对象是出了作用域还存在，自然两次打印结果都是1

出了作用域还在的——>传引用返回

出了作用域被销毁——>传值返回

4.3 常引用

权限不能放大，但是可以缩小，权限是支持平移的

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int& b = a;
	cout << typeid(a).name() <<endl;//int
	cout << typeid(b).name() << endl;//int

	// 权限不能放大
	const int c = 20;
	int& d = c;//error
	//const int& d = c;

	// 权限可以缩小
	int e = 30;
	const int& f = e;

	int ii = 1;
	double dd = ii;
	double& rdd = ii;//error
	const double& rdd = ii;//正确

	const int& x = 10;

	return 0;
}

•  对于同类型的变量，被const修饰之后，由之前的可读可写变成了可读不可写
• 对于不同类型的变量，通常会发生隐式类型转换，并不会改变原变量类型，中间都会产生一个临时变量 
• 临时变量具有常性，所以临时变量可读不可写，这也是变量ii不能赋值给dd，但却可以赋值给rdd的原因，也是出现了const int& x  = 10;这样的代码的原因
• 不能将一个安全的类型交给一个不安全的类型,这是error

4.4 引用和指针的关系

4.4.1 从使用场景来说

• 引用和指针使用场景基本一样，但是链表的链式结构是引用无法代替的，只能使用指针

4.4.2 从语法特性来说

• 引用在定义时必须初始化，指针没有要求。
• 引用在初始化时引用一个实体后，就不能再引用其他实体，
  而指针可以在任何时候指向任何一个同类型实体。
• 没有NULL引用，但有NULL指针。
• 在sizeof中的含义不同：引用的结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节）。
• 引用进行自增操作就相当于实体增加1，
  而指针进行自增操作是指针向后偏移一个类型的大小。
• 有多级指针，但是没有多级引用。
• 访问实体的方式不同，指针需要显示解引用，而引用是编译器自己处理。
• 引用比指针使用起来相对更安全

4.4.3 从底层原理来说

#include<iostream>
using namespace std;
int main()
{
	// 语法的角度，ra没有开空间
	int a = 10;
	int& ra = a;
	ra = 20;

	// 语法的角度，pa开辟了4或8个字节的空间
	int* pa = &a;
	*pa = 20;

	return 0;
}

•  lea是一条取地址的汇编命令，底层原理中引用是用指针实现的

5. 内联函数

5.1 为什么要引入内联函数

• C++中引入内联函数主要是为了解决宏的问题或者说，优化C语言中的宏
• 宏的优点: 代码维护性强，宏函数效率高(减少栈帧的建立)
• 宏的缺点: 可读性差，没有类型安全检查，不方便调试(预处理就会被替换掉)

5.2 在反汇编中查看inline的作用 

•  release版本的优化太强，可能在反汇编中什么都看不见
• 如果要在Debug版本下，通过反汇编来查看inline的作用，需要进行上面的配置

#include<iostream>
using namespace std;
inline void Add(int a, int b)
{
	int c = a + b;
	printf("Add(%d, %d)->%d\n", a, b, c);
}

void Sub(int a, int b)
{
	int c = a - b;
	printf("Sub(%d,%d)->%d\n", a, b, c);
}

int main()
{
	Add(1, 2);
	Sub(1, 2);

	return 0;
}

 

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

5.3 inline函数三大特性

1. inline是一种以空间换时间的做法，省去调用函数开销，所以代码很长，或者有递归的函数不适宜作为内联函数
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内部实现代码指令长度比较长(10行左右，不同编译器不同)/递归等等，编译器优化时会忽略掉内联，这时inline将不起作用
3. inline不建议声明和定义分离，如果分离就会导致链接错误，因为inline被展开，就没有函数地址，链接就会找不到

6. auto关键字(C++11)

C++11 规定

auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，
auto声明的变量必须由编译器在编译时期推导而得。

6.1 auto能推导的场景

场景一：auto与指针和引用结合起来使用

#include<iostream>
using namespace std;
int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;

    *a = 20;
    *b = 30;
    c = 40;

    return 0;
}

 

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

场景二：在同一行定义多个变量 

#include<iostream>
using namespace std;
void TestAuto()
{
    auto a = 1, b = 2;
    auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
int main()
{
    TestAuto();
    return 0;
}

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

6.2 auto不能推导的场景 

场景一：auto不能作为函数的参数

#include<iostream>
using namespace std;
// 此处代码编译失败，auto不能作为形参类型，
//因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{
    //...
}
int main()
{
    TestAuto(1);
    return 0;
}

场景二：auto不能直接用来声明数组

#include<iostream>
using namespace std;
// 此处代码编译失败，auto不能作为形参类型，
//因为编译器无法对a的实际类型进行推导
void TestAuto()
{
    int a[] = { 1,2,3 };
    auto b[] = { 4,5,6 };
}

int main()
{
    TestAuto();
    return 0;
}

 6.3 基于范围的for循环(C++11)

#include<iostream>
using namespace std;
void TestFor_CPP()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (auto& e : array)//这里只能用引用
        e *= 2;

    for (auto e : array)
        cout << e << " ";
}

void TestFor_C()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        array[i] *= 2;

    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        printf("%d ", array[i]);
}

int main()
{
    TestFor_C();
    cout << endl;
    TestFor_CPP();
    return 0;
}

• C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。
• 迭代器的循环与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

6.3.1 范围for的使用条件

#include<iostream>
using namespace std;
void TestFor(int array[])
{
    for (auto& e : array)//范围不明确
        cout << e << endl;
}

int main()
{
    int a[] = { 1, 2, 3, 4, 5, 6 };
    TestFor(a);
    return 0;
}

1. for循环迭代的范围必须是确定的
2. 迭代的对象要实现++和==操作

6.4 指针空值nullptr(C++11) 

C语言中的NULL其实是一个关键字，在stddef.h中

•  可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。
• 其实在使用空值的指针时，都不可避免的会遇到一些麻烦

6.4.1 C++98中的指针空值 vs C++11中的指针空值

#include<iostream>
using namespace std;
void f(int)
{
	cout << "f(int)" << endl;
}

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

int main()
{
	int* p = NULL;
	f(0);
	f(NULL);
	f(p);

	// C++11 nullptr 关键字 替代NULL
	f(nullptr);
	int* ptr = nullptr;

	return 0;
}

• 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下，将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。所以引入了nullptr

6.4.2 对指针空值nullptr的补充说明

• 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的
• 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
• 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。