cpp入门

关键字

c++总计63关键字，c语言32关键字

asm	do	if	return	try	continue
auto	double	inline	short	typedef	for
bool	dynamic_cast	int	signed	typeied	public
break	else	long	sizeof	typename	throw
case	enum	mtable	static	union	wchar_t
catch	explicit	namespace	static_cast	unsigned	default
char	export	new	struct	using	friend
class	extern	operator	switch	virtual	register
const	false	private	template	void	true
const_cast	float	protected	this	volatile	while
delete	goto	reinterpret_cast

c++第一个程序

#include<iostream>
using namespace std;
int main()
{
cout<<"hello world"<<endl;//打印出hello world
return 0;
}

此时我们和c语言做一下对比，发现多了一行using namespace std 语句，这句设计右命名空间，而cou类似于c语言的printf而endl类似于\n，

命名空间

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

命名空间的定义

定义命名空间，需要用到namespace关键字，后面跟的命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员
命名空间的使用：
命名空间名称加左右限定符

#include<iostream>
using namespace std;
namespace s
{
	int a = 10;
	int add(int x, int y)
	{
		return x + y;
	}
}
int main()
{
	int ret = s::add(1, 2);
	int z = s::a;
	cout << ret << endl;
	cout << z << endl;
	return 0;
}

• 命名空间的嵌套

#include<iostream>
using namespace std;
namespace s
{
	int a = 10;
	int add(int x, int y)
	{
		return x + y;
	}
	namespace d
	{
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}
int main()
{
	int ret = s::d::sub(1,3);
	cout << ret << endl;
	return 0;
}

• 命名空间的合并

同一个工程中允许存在多个相同命名空间，编译器最后会合并在同一个命名空间中。在同一个命名空间中，禁止出现多次定义定义同一个变量

#include<iostream>
using namespace std;
namespace s
{
	int a = 10;
	int add(int x, int y)
	{
		return x + y;
	}
	namespace d
	{
		int sub(int x, int y)
		{
			return x - y;
		}
	}
}
namespace s 
{
	int b = 20;
}
int main()
{
	cout<<s::b<<endl;
	return 0;
}

命名空间的使用

命名空间的使用有三种方法：

• 命名空间名称+作用域限定符

int main()
{
cout<<s::a<<endl;
return 0;
}

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

有点使用灵活，经常使用

using s::a;
int main()
{
cout<<a<<endl;
return 0;
}

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

这种方法变向直接把N在全局域中展开

using namespace s;
int main()
{
cout<<s::a<<endl;
return 0;
}

c++的输入与输出

• 使用cout标准输出(控制台)和cin标准输入(键盘)时,必须包含头文件以及std标准命名空间
• 使用c++输入输出更方便，不需要增加数据格式控制

缺省参数

缺省参数概念

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

void a(int a = 10)
{
	cout << a << endl;
}
int main()
{
	a();
	a(11);
	return 0;
}

缺省参数分类

• 全缺省参数

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

• 半缺省参数

规定半缺省参数必须从右到左依次来给，不能间隔着给；

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

• 缺省参数不能再函数声明和定义中同时出现，理由编译器无法确定改用哪个缺省值
  

函数重载

函数重载概念

函数重载:是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 顺序)必须不同，常用来处理实现功能类似数据类型不同的问题,返回值相不相同无所谓，相同的类型的顺序无论怎么替换都不符合函数重载

void add(int x,int y)
{
cout<<x+y<<endl;
}
void add(double x,double y)
{
cout<<x+y<<endl;
}
void add(double x,int y)
{
cout<<"调用double，int类型的函数"<<endl;
}
void add(int x,double y)
{
cout << "调用int,double类型的函数" << endl;
}

名字修饰

现在有一个问题为啥c语言不支持函数重载，而c++支持函数重载

在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预处理、编译、汇编、链接。
此时我们引入函数名修饰规则(每个编译器都有自己的规则)
此时我们讲解的是Linux下的函数修饰规则

• 采用c语言编译器编译后结构

#include<stdio.h>
int add(int x,int y)
{
	return x+y;
}
int main()
{
	add(1,2);
	return 0;
}

#include<iostream>
using namespace std;
int add(int x,int y)
{
return x+y;
}
double add(double x,double y)
{
return x+y;
}

由上图可以知道g++的函数名修饰规则为成**【_Z+函数长度+函数名+类型首字母】**

extern “C”

由于c语言和c++对函数的命名规则不相同，导致c++的函数c语言无法使用
有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，意思是告诉编译器，将该函数按照C语言规则来编译。

引用

引用概念

语法：类型& 引用变量名(对象名)=引用实体(变量);

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int& ra = a;
	cout << &a << endl;
	cout << &ra << endl;
	return 0;
}

注意：引用类型必须和引用实体是同种类型的

引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

常引用

一个变量如果要对一个常量取别名要加const
变量具备读写的权限，但常量只具备读的权限，不具备写的权限::
当然一个被const修饰的变量想要引用一个变量是可以的
这有点想venn图，大的可以推出小的，小的推不出大的
对于不同类型的变量可以加个const修饰

使用场景

做参数

#include<iostream>
using namespace std;
void Swap(int& x,int &y)
{
int tmp=x;
x=y;
y=tmp;
}
int main()
{
int x=1;
int y=2;
Swap(x,y);
cout<<"x="<<x<<" y="<<y<<endl;
}

做返回值

int & Count()
{
int n=0;
n++
return n;
}
int main()
{
int &ret=Count();
cout<<1<<endl;
cout<<2<<endl;
cout<<3<<endl;
cout<<ret<<endl;
return 0;
}

为什么ret的值变成随机值，请学下函数的栈帧建立与销毁

如何放ret变成随机值？？？
直接在Count函数里面的n加个static

传与引用作为返回值的效率比较

#include<iostream>
#include <time.h>
using namespace std;
struct A { int a[10000]; };
void TestFunc1(A a) 
{
}
void TestFunc2(A& a) 
{
}
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

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

通过上述代码的比较，发现传值返回比传引用返回的效率更慢
为啥怎么慢呢？？
在传实参或者返回变量的过程中，函数不会直接传变量本身，而是进行一份临时的拷贝，会有一定的系统开销
然而引用由于是直接使用变量本身，不需要临时拷贝，所以效率会相对与传值更高些

引用与指针的区别

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

内联函数

概念

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

#include<iostream>
using namespace std;
inline int add(int x,int y)
{
	return x+y;
}
int main()
{
	int ret=add(1,2);
	cout<<ret<<endl;
	return 0;
}

使用汇编语言进行查看

特性

1.1. inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

宏的优缺点

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

C++使用了下面两种方法方式替换宏：
1.常量定义换用const
2.函数定义换用内联函数

auto关键字

简介

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它.
C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

用法

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

#include<iostream>
using namespace std;
int main()
{
int x=10;
auto a=x;
auto b=&x;
auto* c=&x;
auto& d=x;
}

2.同一行定义多个变量

同一行定义多个变量必须相同类型，否则报错

#include<iostream>
using namespace std;
int main()
{
	auto a = 1, b = 2;
	auto c = 1, d = 2.0;
	return 0;
}

3.auto 无法用作函数的参数
因为在声明时，编译不知道参数是什么类型的
4.auto 无能用来声明数组
因为推导不出数组是什么类型

auto与for的使用联合

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

#include<iostream>
using namespace std;
int main()
{
	int arr[] = { 2,2,3,4,5 };
	for (auto e : arr)
	{
		cout << e << endl;
	}
	return 0;
}

for (auto e : arr)的意思是将数组arr中的内容依次取来赋值给变量e，这样在for循环中就可以输出e的内容也就是数组中的内容了。