C++在C的基础上完善了一些C的不足，容纳了面向对象的编程思想，并增加了很多有用的库，以及编程规范，C++有63个关键字
这些变量、函数和类的名称将都存在于全局作用域中，如果我们定义的变量如果跟这些关键字一样的话，就会造成很多冲突，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题出现的。
?
命名空间，需要使用到namespace关键字，后面是命名空间的名字，然后接一对{}即可，{}里面中即为命名空间的成员。
?
命名空间是可以嵌套的?
?如何使用命名空间的呢，我们需要加命名空间名称及作用域限定符，或者使用using将命名空间中某个成员引入，或者使用using namespace 命名空间名称 把整个命名空间引入
加命名空间名称及作用域限定符
使用using将命名空间中某个成员引入?
?
?使用using namespace 命名空间名称 把整个命名空间引入
?现在大家可以知道为什么有些程序在运行前都要先使用using namespace std了吧，为了把C++的成员引入，这样在使用的时候就不用指定命名空间访问了，不过不建议这样做，把成员都引入了，那跟没有这个命名空间就没有区别了，建议要使用那个引入那个。
C++输入&输出
?
说明：
1，使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件
以及按命名空间使用方法使用std。?
2，cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含<
iostream >头文件中。
3. <<是流插入运算符，>>是流提取运算符。
?
4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。
C++的输入输出可以自动识别变量类型。
缺省参数
缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实
参则采用该形参的缺省值，否则使用指定的实参
?我们还可以半缺省参数
注意：缺省参数不能在函数声明和定义中同时出现
?
函数重载 ：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这
些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型
不同的问题?
引用：引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
注意：引用类型必须和引用实体是同种类型的
引用特性：
1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体?
引用的权限
引用的使用场景：
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直
接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效
率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回。
引用做函数的参数效率比较
引用做返回值效率比较
?
?引用和指针的不同点:
1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32
位平台下占4个字节)
6. 引用++即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全
?
代码框
//#include <iostream>
//namespace space
//{
命名空间里面的成员可以是变量，可以是函数，或类型
// int rand = 2;
//
// struct Node
// {
// struct Node* next;
// int val;
// };
// int Add(int a,int b)
// {
// return a+b;
// }
//}
//
//namespace N1
//{
// //属于N1命名空间的成员
// int b = 2;
//
// namespace N2
// {
// //属于N1命名空间的成员N2命名空间的成员
// int a = 1;
// }
//}
//using namespace N1;
//using namespace N1::N2;
//
//int main()
//{
// printf("%d
",b);
// printf("%d
",a);
// return 0;
//}
//int main(int argc, const char * argv[]) {
// //属于函数内的局部变量
// int rand = 3;
// //如果没有指定在命名空间内访问，默认先在局部找，再在全局找，如果都没有找到就报错
// printf("%d
",rand);
// //有指定的命名空间访问，就会在命名空间访问
// printf("%d
",N1::rand);
// //有指定的命名空间访问，就会在命名空间访问
// printf("%d
",N1::N2::rand);
// return 0;
//}
//#include <iostream>
std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
//using namespace std;
//
//int main()
//{
// cout<<"hello,world!"<<endl;
// return 0;
//}
//#include <iostream>
//using namespace std;
注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。
//void Func(int a = 1, int b = 2, int c = 30);
//
//void Func(int a = 10, int b = 20, int c = 30)
//{
//cout<<"a = "<<a<<endl;
//cout<<"b = "<<b<<endl;
//cout<<"c = "<<c<<endl;
//}
//
//int main()
//{
//Func(); // 全缺省，按默认值输出
//Func(9); //传一个参数时，对应第一个a，传两个参数时对应 a,b，
//Func(9,,8);//不能跳过某个参数传递
//return 0;
//}
//#include <iostream>
//using namespace std;
参数类型不同
//void func(int a, int b)
//{
// cout << "f(int a,int b)" << endl;
//}
参数类型不同
//void func(int a, char)
//{
// cout << "f(int a,char b)" << endl;
//}
参数类型一样
//void func(char a, char b)
//{
// cout << "f(char a,char b)" << endl;
//}
没有参数
//void func()
//{
// cout << "f()" << endl;
//}
//
//int main()
//{
// func();
// func(1,2);
// func(1,'a');
// func('a','b');
// return 0;
//}
//#include <iostream>
//using namespace std;
//
//void TestRef()
//{
// int a = 0;
// printf("%d
",a);
// int &ra = a;
// //int &rra;//引用时必须初始化，初始化后无法个性
// int &rrra = a;
// rrra = 2;//对别名进行修改也就是对a进行修改，
// printf("%d
",rrra);
//}
//
//
//int main()
//{
// TestRef();
// return 0;
//}
//#include <iostream>
//using namespace std;
//引用做参数的话，可以减少拷贝，增加一定的效率
//void Swap(int& left, int& right)
//{
//int temp = left;
//left = right;
//right = temp;
//}
//
//int main()
//{
// int a = 1, b =2;
// Swap(a, b);
// cout<< a << "
" << b << endl;
// return 0;
//}
//#include <iostream>
//using namespace std;
//
//int main()
//{
// //引用的权限可以减少，不可增加
// const int a = 1;
// //int &ra = a;//a 是不可修改的而引用的类型是可以修改这是不允许的
// const int &ra = a;
//
// int b = 2;
// //b是可修改的，而引用的的rb可以设置为不可修改，权限可减小
// const int &rb = b;
//
// return 0;
//}
//#include <time.h>
//#include <iostream>
//using namespace std;
//
//
//struct A{ int a[10000]; };
//A a;
值返回
//A TestFunc1() { return a;}
引用返回
//A& TestFunc2(){ return a;}
//void TestReturnByRefOrValue()
//{
以值作为函数的返回值类型
//size_t begin1 = clock();
//for (size_t i = 0; i < 100000; ++i)
//{
// TestFunc1();
//}
//size_t end1 = clock();
以引用作为函数的返回值类型
//size_t begin2 = clock();
//for (size_t i = 0; i < 100000; ++i)
//{
// TestFunc2();
//}
//size_t end2 = clock();
计算两个函数运算完成之后的时间
//cout << "TestFunc1 time:" << end1 - begin1 << endl;
//cout << "TestFunc2 time:" << end2 - begin2 << endl;
//}
//
//int main()
//{
// TestReturnByRefOrValue();
// return 0;
//}
#include <time.h>
#include <iostream>
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;
}?
?