lesson0-C++入门
个人主页：Lei宝啊
愿所有美好如期而遇
目录
#1. C++关键字
#2. 命名空间
编辑
#3. C++输入&输出
#4. 缺省参数
#5. 函数重载
#6. 引用
#7. 内联函数
#8. auto关键字(C++11)
#9. 基于范围的for循环(C++11)
#10. 指针空值---nullptr(C++11)
#1. C++关键字
C++总计63个关键字，C语言32个关键字，C++兼容%99的C语言，只有极少部分在C++中不可使用，后面我们会提到，关键字没有必要现在全部知道，后面可以慢慢学。
#2. 命名空间
首先我们通过几个C语言代码引入。
假如说我们今天引入一个
#include
#include
int rand = 0;
int main()
{
printf("%d", rand);
return 0;
} 
首先我们知道stdlib头文件展开后，rand函数就也在全局出来了，于是和我们定义的rand就命名冲突了，如果说我们定义在主函数中，那么就是局部优先，不会冲突。
#include
#include
int main()
{
int rand = 0;
printf("%d", rand);
return 0;
} 
那么我们如何去避免命名冲突这种情况发生？很遗憾，C语言无法避免，于是C++里解决了这个问题，他引入了命名空间，命名空间里变量和函数的生命周期还是全局，但是如果不展开或者使用域作用限定符，那么命名空间里的一系列变量和函数都无法使用，看例子：
域作用限定符 ::
一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中
#include
using namespace std;
namespace jj_jntm
{
int a = 0;
int Add(int x = 0, int y = 0)
{
return x + y;
}
void COUT()
{
int x = a;
cout << x << endl;
}
}
int main()
{
int a = 1;
cout << a << endl;
cout << jj_jntm::a << endl;
cout << jj_jntm::Add(1, 2) << endl;
a = 2;
//外面的a改变不会影响命名空间里的a，两者是独立的。
jj_jntm::COUT();
//只有命名空间里的a改动时，命名空间里调用的该a才会改变
jj_jntm::a = 3;
jj_jntm::COUT();
return 0;
}
命名空间还可以嵌套。
#include
using namespace std;
namespace jj_jntm
{
int a = 0;
int Add(int x = 0, int y = 0)
{
return x + y;
}
void COUT()
{
int x = a;
cout << x << endl;
}
namespace basketball
{
int kk = 0;
}
}
int main()
{
cout << jj_jntm::basketball::kk << endl;
return 0;
} 
同一个工程允许命名空间的名字相同，因为编译器最后会将他们合成一个命名空间。
使用 using 将命名空间中某个成员引入
#include
using namespace std;
namespace jj_jntm
{
int a = 0;
int Add(int x = 0, int y = 0)
{
return x + y;
}
void COUT()
{
int x = a;
cout << x << endl;
}
namespace basketball
{
int kk = 0;
}
}
using jj_jntm::a;
using jj_jntm::COUT;
int main()
{
int a = 9;
COUT();
//cout << jj_jntm::basketball::kk << endl;
return 0;
}
为什么呢？我们使用using展开部分命名空间，但是这与头文件展开完全是不同的，using仅仅是允许编译器进入namspace里对其进行搜索，我们不展开的时候，或者不指定的时候，编译器默认不会进去搜索的。
所以我们展开a和COUT，意思就是允许编译器在命名空间里去寻找了，而后定义的a赋值9不会影响到命名空间里的a，因为他是重新定义了一个局部变量。
这个就是在主函数中找不到a，我们就去全局找，又因为我们展开了a，所以可以在命名空间里找到a，于是命名空间里的a被修改为了6。
使用using namespace 命名空间名称 引入（展开到全局）
#include
using namespace std;
namespace jj_jntm
{
int a = 0;
int Add(int x = 0, int y = 0)
{
return x + y;
}
void COUT()
{
int x = a;
cout << x << endl;
}
namespace basketball
{
int kk = 0;
}
}
using namespace jj_jntm;
int main()
{
int a = 3;
cout << Add(a, 2) << endl;
cout << Add(jj_jntm::a, 2) << endl;
COUT();
//cout << jj_jntm::basketball::kk << endl;
return 0;
} 
#3. C++输入&输出
使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件输入：std::cin
输出：std::cout
换行：std:endl
>> << 可以看做流向。
#include
using std::cout;
using std::cin;
int main()
{
int a = 0;
//从键盘输入数据流入a中
std::cin >> a;
//a先流出到屏幕上，而后是换行符
std::cout << a << std::endl;
int b = 0;
cin >> b;
cout << b << std::endl;
return 0;
} 
当然，我们最好是能在输入前有个提示。
#4. 缺省参数
缺省参数是 声明或定义函数时 为函数的 参数指定一个缺省值 。在调用该函数时，如果没有指定实 参则采用该形参的缺省值，否则使用指定的实参
我们来看代码：
#include
using std::cout;
using std::cin;
using std::endl;
int Add(int a = 0, int b = 0)
{
return a + b;
}
int main()
{
cout << Add(1, 1) << endl;
cout << Add() << endl;
cout << Add(1) << endl;
return 0;
} 
值得注意的是，实参必须从左向右给，缺省值必须从右向左缺。
int Add(int a = 1, int b = 2, int c = 3)
{
return a + b + c;
}
int main()
{
cout << Add() << endl;
cout << Add(2) << endl;
cout << Add(2,3) << endl;
cout << Add(2, 3, 4) << endl;
return 0;
}
你也许会有疑问，我能不能跳着给实参，或者跳着缺省？
那么如果是这样，我怎么能知道这个2是传给b的还是传给c的，也就是说，1和2有一个是传给b的，那剩下的那个是给哪个缺省值呢？无法区分。
另外，如果函数的声明和定义不在同一个文件，而我们又想给函数缺省值，那么就给在声明，不可同时给。
这显然不可以，所以不能同时给，就是为了避免这样的情况。
至于说我难道不能给定义吗？一定要给声明？好好好，我写了一个函数，但是不给你源码，只给你用，给你个接口，你说我缺省在定义里，你怎么知道这个函数该不该缺省，所以说写在声明里。
#5. 函数重载
C语言中，假设我们有一个函数，叫做
int Add(int a,int b)，这是一个加法函数，返回值为int类型，当我们想做double类型的两个数相加时，那么就要再写一个函数，并且重新起一个名字，不管是叫Add_double也好，还是叫什么，如果我们有多个加法函数，那么要起多少个名字？总之是给我们带来了不便，我们就想，能不能不改名字，还能找到这样的函数，C语言不可以，于是C++有了函数重载。
1 、参数类型不同
#include
using namespace std;
int Add(int a, int b)
{
return a + b;
}
double Add(double a, double b)
{
return a + b;
}
int main()
{
cout << Add(1314.0, 0.0);
cout << Add(500, 20) << endl;
return 0;
} 
2、参数个数不同
#include
using namespace std;
void f()
{
cout << "我没有参数" << endl;
}
void f(int a)
{
cout << "哈哈，我有参数：" << a << endl;
}
int main()
{
f();
f(6);
return 0;
} 
3、参数类型顺序不同
#include
using namespace std;
int Add(int a, int b)
{
return a + b;
}
int Add(int a, int b, int c)
{
return a + b + c;
}
int main()
{
cout << "两个参数:>" << Add(1, 2) << endl;
cout << "三个参数:>" << Add(1, 2, 3) << endl;
return 0;
} 
#6. 引用
引用概念引用 不是新定义一个变量，而 是给已存在变量取了一个别名 ，编译器不会为引用变量开辟内存空 间，它和它引用的变量共用同一块内存空间
类型& 引用变量名(对象名) = 引用实体
int main()
{
int a = 6;
int& b = a;
cout << "a地址> " << &a << " b地址> " << &b << endl;
return 0;
}所以b就是a的别名，好比你的大名和小名，不管叫那个都是你。
void Swap(int* a, int* b)
{
int temp = *a;
*a = *b;
*b = temp;
}
int main()
{
int a = 1;
int b = 2;
Swap(&a, &b);
cout << "a = " << a << " b = " << b << endl;
return 0;
}
void Swap(int& a, int& b)
{
int temp = a;
a = b;
b = temp;
}
int main()
{
int a = 1;
int b = 2;
Swap(a, b);
cout << "a = " << a << " b = " << b << endl;
return 0;
}
引用特性
1. 引用在 定义时必须初始化2. 一个变量可以有多个引用3. 引用一旦引用一个实体，再不能引用其他实体
int main()
{
int a = 0;
int& b = a;
int& c = a;
int& d = c;
cout << a << b << c << d << endl;
return 0;
}
int main()
{
int a = 0;
int b = 1;
int& c = a;
c = b;
cout << c << endl;
return 0;
}
int main()
{
int a = 0;
int b = 1;
int& c = a;
c = b;
cout << c << endl;
cout << "&a = " << &a << "\n&c = " << &c << "\n&b = " << &b << endl;
return 0;
}
常引用
const int a = 0;
const int& c = a;
const int& e = 10;
//这是OK的
const double& d = a;
至于上面的const限定的为什么可以，我们先来看代码。
int main()
{
int a = 9;
double c = a;
return 0;
}这里为什么可以呢？
在强制类型转换时，会生成一个临时变量，将临时变量的值强制转换后在赋值。
使用场景
1. 做参数
我们上面的交换函数就是。
int& Add(int a, int b)
{
static int c = a + b;
return c;
}
int main()
{
int& a = Add(3, 5);
cout << a << endl;
a = 98;
a = Add(a, 2);
cout << a << endl;
return 0;
}
int& Add(int a, int b)
{
static int c;
c = a + b;
return c;
}
int main()
{
int& a = Add(3, 5);
cout << a << endl;
a = 98;
a = Add(a, 2);
cout << a << endl;
return 0;
}
那么问题是，我直接返回值不好吗，为什么要引用返回呢？
1.以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直 接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效 率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低.
引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
int main()
{
int a = 10;
int& ra = a;
cout << "&a = " << &a << endl;
cout << "&ra = " << &ra << endl;
return 0;
}
在 底层实现上 实际是有空间的，因为 引用是按照指针方式来实现 的。
引用和指针的不同点:1. 引用概念上定义一个变量的别名，指针存储一个变量地址。2. 引用 在定义时 必须初始化 ，指针没有要求3. 引用 在初始化时引用一个实体后，就 不能再引用其他实体 ，而指针可以在任何时候指向任何 一个同类型实体4. 没有 NULL 引用 ，但有 NULL 指针5. 在 sizeof 中含义不同 ： 引用 结果为 引用类型的大小 ，但 指针 始终是 地址空间所占字节个数 (32 位平台下占4 个字节 )6. 引用自加即引用的实体增加 1 ，指针自加即指针向后偏移一个类型的大小7. 有多级指针，但是没有多级引用8. 访问实体方式不同， 指针需要显式解引用，引用编译器自己处理9. 引用比指针使用起来 相对 更安全
对5的解释：
int main()
{
char a = 4;
char* pa = &a;
char& b = a;
cout << sizeof(pa) << endl;
cout << sizeof(b) << endl;
return 0;
}
对9的解释：
不会有野指针这样的风险，而且频繁使用“*指针变量名”的形式进行运算容易产生错误而且可阅读性较差。
#7. 内联函数
inline放在我们写的函数的前面，如：inline int Add(int a,int b);
以 inline 修饰 的函数叫做内联函数， 编译时 C++ 编译器会在 调用内联函数的地方展开 ，没有函数调 用建立栈帧的开销，内联函数提升程序运行的效率。
内联函数有什么作用？
简单来说就是减少栈帧的开销，我们来看调用一个函数的过程。
我们要给这个函数建立栈帧，然后执行下面一系列操作。
但是inline函数就相当于这样。
不需要call 函数的地址，进入后再去执行。
当我们将源文件编译结束，如果编译器响应的话，未忽略我们的inline建议，那么此时我们已经找不到这个函数的地址，他已经完成了替换，也就少了call 函数地址这个过程。
我用的编译器是
，在debug下，需要调一些东西inline才会替换，看图示：
调成程序数据库。
改为只适用于_inline，release版本下会优化。inline在合适的条件下会替换。
inline int Add(int a, int b)
{
int c = a + b;
return c;
}
int ADD(int a,int b)
{
return a + b;
}
int main()
{
int ret = ADD(1, 2);
int a = Add(1, 2);
return 0;
}
上面的ADD还会call函数地址，而Add直接替换展开了。
特性
#8. auto关键字(C++11)
auto声明的变量必须由编译器在编译时期推导而得
#include
using namespace std;
int main()
{
int a = 0;
auto b = a;
cout << typeid(b).name() << endl;
return 0;
} 
我们看到b是auto类型。
当然，我们也可以这样测试一下，
int main()
{
int a = 0;
int* pa = &a;
auto* p = &a;
cout << typeid(pa).name() << endl;
cout << typeid(p).name() << endl;
return 0;
} 我们也可以发现，p的类型仍然匹配，auto的推导是正确的。
那么auto可不可以做函数的参数和返回值呢？
编译器明确告诉我们此处不可以使用auto，因为如果这样的话，我们的参数传什么类型，他就推导什么类型，返回值就可能不符合我们的预期，以及函数内部的实现也会出问题，至于返回值auto就更不可行了，让编译器去思考你想返回什么值？真是子非鱼，安知鱼之乐。
同时，auto不能声明数组。
#9. 基于范围的for循环(C++11)
int main()
{
//第一种遍历数组的方式
int arr[10] = { 1,2,3,4,5,6,7,8,9 };
for (int i = 0; i < 10; i++)
{
cout << arr[i] << " ";
}
cout << endl;
//第二种就是范围for
for (auto a : arr)
{
cout << a << " ";
}
cout << endl;
return 0;
}注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。
另外要说到的一点是以下方式是不可以的 ，for循环迭代的范围必须是确定的，我们传过去一个指针，没有办法确定他的范围在哪里，对于数组而言，就是数组中第一个元素和最后一个元素的范围
#10. 指针空值---nullptr(C++11)
我们在C语言中使用NULL，但是NULL有一个缺陷。
NULL实际是一个宏，在传统的C头文件(stddef.h)中，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量,不论采取何 种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦。
void A(int)
{
cout << "int" << endl;
}
void A(int*)
{
cout << "int*" << endl;
}
int main()
{
A(0);
A(NULL);
A((int*)NULL);
return 0;
}应该输出什么呢？
基于这样的情况，所以C++引进了nullptr
void A(int)
{
cout << "int" << endl;
}
void A(int*)
{
cout << "int*" << endl;
}
int main()
{
//A(0);
//A(NULL);
A(0);
A(nullptr);
return 0;
}
