1. c++ 关键字

c++ 98中，规定的关键字总共有63个：

2. c++ 命名空间

目的：解决 C 语言命名冲突问题；
定义格式：namespace 关键字 命名空间名称 {}

namespace N 
{
	//成员：既可以是变量，也可以是函数
	int a = 10;

	int add(int left, int right) 
	{
		return left + right;
	}


}

需要清楚的是，除了以上定义外，命名空间还可以嵌套定义，一个命名空间相当于一个作用域；

namespace N1 
{
	//成员：既可以是变量，也可以是函数
	int a = 10;

	int add(int left, int right) 
	{
		return left + right;
	}

	namespace N2
	{
		//成员：既可以是变量，也可以是函数
		int b = 10;

		int add(int left, int right)
		{
			return left + right;
		}

	}
}

同一个工程中，可以存在多个相同名称的命名空间,但成员名称不能相同；
使用方式：

#include<stdio.h>
namespace N1 
{
	//成员：既可以是变量，也可以是函数
	int a = 10;

	int add(int left, int right) 
	{
		return left + right;
	}

	namespace N2
	{
		//成员：既可以是变量，也可以是函数
		int b = 10;

		int add(int left, int right)
		{
			return left + right;
		}


	}


}


int a = 100;



int main()
{
	printf("%d
", ::a);//结果为全局变量a的值=100
	printf("%d
", N1::a);//结果为命名空间N1中a的值=10
	return 0;
}

对应结果：

3. c++ 输入与输出

输入：cin
输出：cout

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

	//输入
	int a, b, c;
	cin >> a;
	cout << a << endl;
	cin >> a >> b >> c;
	cout << a <<" "<< b << " "<< c << " "<< endl;
	//std::cout << "hello.world!!" << std::endl;

	cout << "hello.world!!" << endl;
	cout << 100<<endl;
	cout << 100 << " " << 12.34 << endl;
	return 0;
}

对应结果：

4. c++ 缺省参数

缺省参数就是在声明或定义函数时，为函数的参数指定一个默认值，在函数调用时，当用户没有传递实际参数时，使用默认值；相反，则使用指定的传递参数值；

#include <stdio.h>
#include<iostream>
using namespace std;

void testFun(int a = 0)
{
	cout << a << endl;
}
int main()
{

	testFun();//没有传参，使用默认值
	testFun(10);//传参时，使用指定传参值
	return 0;
}

对应结果：

分类：
（1）全缺省参数----每个参数都有默认值；
（2）半缺省参数-----部分参数具有默认值，但必须是从右往左依次给出的；

5. c++ 函数重载

函数重载：必须处于相同的作用域，函数名称相同，参数列表不同，三者均满足才能构成重载，与返回值类型无关；

#include <iostream>
using namespace std;
//1.参数个数不同
void test() 
{
	cout << "test()" << endl;
}
void test(int a)
{
	cout << "test(int)" << endl;
}

//2.参数类型不同

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

//3.类型的次序不同
void test(int a,double b)
{
	cout << "test(int,double)" << endl;
}

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

	
	return 0;
}

函数重载调用原理：

1. 编译器编译时，首先会对传递的实参类型进行推演，然后根据推演的结果选择合适的函数进行调用；
2. 当类型不能完全匹配时，编译器会先进行隐式类型转换，转换之后有合适的函数就调用，没有则报错；

注意：C语言不支持函数重载！

6. c++ 引用

6.1 引用概念

（1） 概念：给已存在的变量取一个别名，没有自身的内存空间；

（2）使用：

类型& 引用变量名（对象名） = 引用实体；

例如：

int main() 
{
	int a = 0;
	int& ra = a;
	a = 100;//ra的值也会发生相应的改变
	return 0;
}

交换函数：

void Swap(int& left,int& right)
{
 int temp  = left;
 left = right;
 right = temp;
}

注意：引用类型与引用实体必须为同种类型；

6.2 引用特性

（1）引用在定义时必须初始化；

int main() 
{
	
	int& ra;//报错，没有进行初始化
	return 0;
}

（2）一个变量可以有多个引用；

int main() 
{
	int a = 0;
	int& ra = a;
	int& rra = a;
	int& rrrra = ra ;
	return 0;
}

（3）引用一旦引用一个实体，再不能引用其他实体；

6.3 常引用

常引用：被 const 修饰的引用；

int main()
{

	const int a = 10;
	const int& ra = a;//前面也必须带有const，否则会报错
	//ra = 100; // 报错，常引用不能再赋值
	return 0;
}

6.4 引用与指针区别

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

int main()
{
   int* pa;//代码不会报错
   int& ra;//报错，没有进行初始化

}

2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体；
3. 没有NULL引用，但有NULL指针；
4. 在 sizeof 中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)；

#include <iostream>
using namespace std;
int main()
{
	char ch = 'A';
	char* pc = &ch;

	char& rc = ch;
	cout << sizeof(pc) << endl;   //4
	cout << sizeof(rc) << endl;   //1

	
	return 0;
}

5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；
6. 有多级指针，但没有多级引用；
7. 引用比指针使用起来相对更安全；

7. c++ 内联函数

c++ 中的内联函数对应于 C 语言中的宏；

（1）概念：

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

（2） 特性：

inline 是一种以空间（内存空间变大）换时间（效率变高）的做法，省去了调用函数的开销，提高了运行效率，因此，对于代码很长或者有循环/递归的函数不适宜使用；

8. c++ auto 关键字

1）概念：

c++11中规定，auto 不是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto 声明的变量必须由编译器在编译时期推导而得；

具体来讲：auto相当于一个占位符，编译器在编译阶段会根据变量的初始化表达式来推演初始化表达式的类型，最后将推演的结果进行替换；

#include<iostream>
using namespace std;

int main()
{
	auto a = 10; //编译器会自动将auto替换为int
	auto b = 20.56;//编译器会自动将auto替换为double
	//打印变量类型
	cout << typeid(a).name() << endl;//int
	cout << typeid(b).name() << endl;//double 
	return 0;
}

对应结果：

2）应用规则：

1，auto 声明指针类型时，用 auto 和 auto* 没有任何区别，但用 auto声明引用类型时则是有区别的，需要添加 & ；

声明指针时：

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	auto* pa1 = &a;
	auto pa2 = &a;
	cout<< typeid(pa1).name() << endl; //int*
	cout << typeid(pa2).name() << endl;//int*
	return 0;

}

声明引用时：

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	auto& ra = a;
	auto rra = a;
	//打印地址是否相同
	cout<< &ra << endl;
	cout << &rra << endl;
	return 0;

}

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

类型相同时：

#include<iostream>
using namespace std;
int main()
{
	auto a = 10, b = 20, c = 30;
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	return 0;
}

类型不相同时：

#include<iostream>
using namespace std;
int main()
{
	auto a = 10, b = 20.04, c = 30;//报错
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	return 0;
}

3）注意事项：

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

void testFun(auto a)//报错，编译器无法进行推演
{

}
int main()
{

	return 0;
 }

报错信息：

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

void testFun()
{
	int a[] = { 1,2,3,4 };
	auto b[] = { 4,5,6,7 };//报错
}

报错信息：

9. 范围 for 循环

格式：for 循环后的括号由冒号“ ：”分为两部分；
第一部分是范围内用于迭代的变量；
第二部分则表示被迭代的范围；

#include<iostream>
using namespace std;
int main()
{
	int a[] = { 1,2,3,4,5,6,7,8 };
	for (auto e : a) //a的范围必须是确定的
	{
		cout << e << endl;
	}
	return 0;
 }