【C++】入门

一、引用

1.1引用概念 

     引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存

空间，它和它引用的变量共用同一块内存空间。

好比是 你叫张三，但是在外面别人叫你张四。

代码形式 

int a = 0;
//引用:b是a的别名
int& b = a;
int& c = a;
int& d = b;

 

 

1.2引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体----->也就好比->y引用x，就和x捆绑一起了，不能引用z不能成为z的外号。

int x = 0;
int& y = x;
int z = 1;
//z赋值给y
y = z;

形参接收可以写成int& 

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int x = 0, y = 1;
	Swap(x, y);
	cout << x << "：" << y << endl;
	return 0;
}

 1.3常引用

指针与引用都不能进行权限的放大。

引用 

//可读可改
int x = 0;

//权限的方法
//m只读,不能修改m
const int m = 0;
//n变成m的别名
//权限放大，n的权限是可读可写
//int& n = m;

//权限平移
const int& n = m;

//权限缩小--->只是z不能修改，z只读
const int& z = x;

指针 

int a = 0;
const int* p1 = &a;
//*p1不能修改
p1++;
//权限的放大
//int* p2 = p1++;
//权限的平移
const int* p2 = p1;

//权限的缩小
int* p3 = &a;
const int* p4 = p3;

临时变量 

int main()
{
	//临时变量---->可以理解为被const修饰的变量
	//此变量不像C语言中
	//int tmp = 0;tmp = a; a = b; b = tmp;中的tmp变量
	//是一种没有名字的变量---->看下面

	double d = 12.34;
	//1.类型转换会产生临时变量
	int i = d;
	//d 先给临时变量 临时变量在给i
	const int& r1 = d;
	//int& r = d;//行不通，临时变量具有常性，此处属于权限的放大--->好比r改了临时变量就改了，这样不行

	//2.表达式运算也会产生临时变量
    int x = 0, y = 1;
    const int& r2 = x + y;

	return 0;
}

1.4引用和指针的区别

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

底层是一样的可以理解为都是指针 

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

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

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

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

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

7.引用和指针的最大区别:引用不能改变指向 

什么是指向，指向就是指针所指向的地址

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

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

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

二 、函数重载

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

 不同的作用域可以同名函数

namespace bit1 
{
	void swap(int* pa, int* pb) {
		cout << "1" << endl;
	}
}
namespace bit2
{
	void swap(int* pa, int* pb) {
		cout << "2" << endl;
	}
}

如果在代码中加

using namespace bit1;
using namespace bit2;

同时调用swap，此时他们不构成重载函数---->调用歧义

 只有同一作用域才能构成函数重载。

参数个数

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

 类型

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

 类型顺序

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

为什么C++支持函数重载 

 C语言直接用函数名字取查找

C++用修饰后的函数去查找------>可以通过链接后去查看

2.1函数重载与缺省参数 

2.1.1缺省参数

缺省参数分为全缺省参数与半缺省参数

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

【全缺省参数】

	void Date1(int year = 1,int month = 1,int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

【半缺省参数】 

	void Date1(int year ,int month = 1,int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

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

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

声明和定义不能同时出现，在声明给

了解以上缺省函数以后

【函数重载与缺省参数】

F()与F(int a = 10,int b = 20) 发生函数重载

F(40)a = 40 b = 20。F(24,73)a = 24 b = 73 F()发生调用歧义 ，导致报错

三、 内联函数

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

原函数有call-----> 需要跳转到Add函数地址中去调用 

 若添加inline则直接把Add函数展开

 宏定义

#define Add(a,b) ((a)+(b))
int main()
{
	int c = Add(1, 2);
	cout << c << endl;
	return 0;
}

优点：
1.增强代码的复用性。
2.提高性能。
缺点：
1.不方便调试宏。（因为预编译阶段进行了替换）
2.导致代码可读性差，可维护性差，容易误用。
3.没有类型安全的检查 。

C++有哪些技术替代宏？
1. 常量定义 换用const enum
2. 短小函数定义 换用内联函数 

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

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

假如有1000个位置调用，使用inline Add函数需要100行指令，展开则需要1000*100

假如使用Add函数，则仅需要展开1000 + 100

inline会导致编译出来的可执行程序变大

 3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址
了，链接就会找不到。

 

假设在声明函数添加inline则会发生错误---->导致链接找不到------无法解析的外部符号 "void __cdecl F(int)" (?F@@YAXH@Z) ---------->为什么找不到？inline函数没有地址，call（一个地址）没有---------所以导致链接不上

四、auto关键字(C++11)

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

int main()
{
	int j = 0;
	//右边初始化自动推导类型
	//auto可以替代写起来长的类型的定义，简化代码
	auto i = 0.0;
	int a  = sizeof(i);
	cout << a << endl;
	return 0;
 }

4.1auto使用细则 

1.auto与指针和引用结合起来使用

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

	int x = 10;
    //可指针可普通类型
	auto a1 = x;
	auto a2 = &x;

	//指定必须是指针
	auto* b = &x;
    
    //引用
    auto& c = x;

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

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

 4.2auto不能推导的场景

1. auto不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

2. auto不能直接用来声明数组

void TestAuto()
{
  int a[] = {1,2,3};
  auto b[] = {4，5，6};
}

 4.3范围for的使用条件

for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
{
	cout << array[i] << ' ';
}

上下等价 

	//C++11 范围for
	//自动取数组array中，赋值给e
	//自动++，自动判断结束
	int array[] = { 1,2,3,4,5 };
	for (auto e : array)
	{
		cout << e << " ";
	}
	cout << endl;
	for (auto a : array)
	{
		a *= 2;
		cout << a << " ";
	}
	cout << endl;
	for (auto e : array)
	{
		cout << e << " ";
	}
	cout << endl;
	//假若修改值，假若想修改array中的值需要用个&引用
	for (auto& a : array)
	{
		a *= 2;
	}
	for (auto a : array)
	{
		cout << a << " ";
	}

下面的代码就不行----->传递的是指针------->只能对数组进行使用 范围for

void TestFor(int array[])
{
  for(auto& e : array)
    cout<< e <<endl;
}

  五、指针空值nullptr(C++11)

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的
初衷相悖。 

所以C++使用nullptr替代NULL