【C++】入门

一.关键字（C++98）
a:asm auto
b:bool break
c:case catch char class const const_cast continue
d:delete do double dynamic_cast default
e:else enum explicit extern
f:false float for friend
g:goto
i:if inline int
l:long
m:mutable
n:namesapce new
o:operator
p:private protected public
r:reinterpret_cast return
s:short signed sizeof static static_cast struct switch
t:template this try typedef typeid typename throw register true
u:union unsigned using
v:virtual void volatile
w:wchar_t while
二.命名空间（namespace）
目的：对标识符的名称进行本地化，以避免命名冲突或名字污染
1.命名空间定义

//普通命名空间
namespace N1
{
 int a;
 int Add(int left, int right)
 {
  return left + right;
 }
}

/嵌套的命名空间
namespace N2
{
 int a;
 int b;
 int Add(int left, int right)
 {
  return left + right;
 }
 namespace N3
 {
  int c;
  int d;
  int Sub(int left, int right)
  {
   return left - right;
  }
 }
}

同一工程中允许存在多个相同名称的命名空间，编译器最后会将其合成在同一个命名空间中。
一个命名空间就定义了一个作用域，命名空间中所有内容都局限于该命名空间中。
2.命名空间使用
如：

namespace N1
{
 int a;
 int Add(int left, int right)
 {
  return left + right;
 }
}

namespace N2
{
 int a;
 int b;
 int Add(int left, int right)
 {
  return left + right;
 }
 namespace N3
 {
  int c;
  int d;
  int Sub(int left, int right)
  {
   return left - right;
  }
 }
}

namespace N
{
 int a = 10;
 int b = 20;
 int Add(int left, int right)
 {
  return left + right;
 }
 int Sub(int left, int right)
 {
  return left - right;
 }
}

上面是三个命名空间，a、b被重复使用
命名空间的使用有三种方法
（1）加命名空间名称及作用域限定符

int main()
{
 printf("%d\n", N::a);
 return 0;
}

（2）使用using将命名空间中成员引入

using N::b；
int main()
{
 printf("%d\n", N::a);
 printf("%d\n", b);

 return 0;
}

（3）使用using namespace 命名空间名称引入

using namespace N；
int main()
{
 printf("%d\n", N::a);
 printf("%d\n", b);
 Add(10, 20);
 return 0;
}

三.输入（cin）&输出（cout）

#include<iostream>
using namespace std；

int main()
{
 int a;
 double b;
 char c;
 
 cin >> a;
 cin >> b >> c;
 
 cout << a << endl;
 cout << b << " " << c << endl;
 
 return 0;
}

使用cout标准输出（控制台）和cin标准输出（键盘）时，必须包含头文件以及std标准命名空间。
使用C++输入输出更方便，不需要增加数据格式控制，如：整形–%d等。
四.缺省参数
1.概念
声明或定义函数时为函数参数设定的一个默认值。在调用时，如果没有指定实参则采用该默认值，否则使用指定的实参。

#include<iostream>
using namespace std;

void TestFunc(int a = 0)
{
 cout << a << endl;
}
int main()
{
 TestFunc();//使用默认值（a=0）
 TestFunc(10);//使用指定值（a=10）
 return 0;
}

2.分类
（1）全缺省参数：每个参数都带有默认值

#include<iostream>
using namespace std;

void TestFunc(int a = 10, int b = 20, int c = 30)
{
 cout << "a=" << a<<endl;
 cout << "b=" << b << endl;
 cout << "c=" << c << endl;
}
int main()
{
 TestFunc();
 return 0;
}

（2）半缺省参数

#include<iostream>
using spacename std;

void TestFunc(int a, int b = 10, int c = 20)
{
 cout << "a=" << a << endl;
 cout << "b=" << b << endl;
 cout << "c=" << c << endl;
}
int main()
{
 TestFunc(1);//a=1,b、c不变
 return 0;
}

半缺省参数必须从左往右依次给出，不能间隔着给出。
缺省参数不能在函数声明和定义中同时出现，放在函数声明中好一些。
缺省值必须是常量或全局变量。
C语言不支持（编译器不支持）。
五.函数重载
1.概念
C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数、类型或顺序）必须不同。

int Add(int left, int right)
{
 return left + right;
}
double Add(double left, double right)
{
 return left + right;
}
long Add(long left, long right)
{
 return left + right;
}
int main()
{
 cout<<Add(10, 20)<<endl;
 cout<<Add(10.1, 20.0)<<endl;
 cout<<Add(10L, 20L)<<endl;
 return 0;
}

2名字修饰（name mangling）
是一种在编译的过程中，将函数、变量的名称重新改编得机制，简单来说就是编译器为了区分各个函数，将函数通过某种算法，重新修饰为一个全局唯一的名称。
被重新修饰后的名字中包含了函数的名字以及参数类型。只要参数列表不同，编译器在编译时通过对函数名字进行重新修饰，将参数类型包含在最终的名字中，就可保证名字在底层的全局唯一性。

函数签名	修饰后名称
int func(int)	?func@@YAHH@Z
float func(float)	?func@@YAMM@Z
int C::func(int)	?func@C@@AAEHH@Z
int C::C2::func(int)	?func@C2@C@@AAEHH@Z
int N::func(int)	?func@N@@YAHH@Z
int N::C::func(int)	?func@C@N@AAEHH@Z

3.extern “C”
有时在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加extern “C”，将该函数按照C语言规则来编译。

六.引用
1.概念：给已存在变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一快内存空间。
类型& 引用变量名（对象名）=引用实体；

int main()
{
 int a = 10;
 int& ra = a;
 cout << &a << endl;
 cout << &ra << endl;
 return 0;
}

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

3.常引用

int main()
{
 const int a = 10;
 //int& ra=a;  此语句编译时会出错，a为常量
 const int& ra = a;
 return 0;
}

4.引用使用场景
（1）做参数

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

（2）做返回值

int& TestRefReturn(int& a)
{
a+=10;
return a;
}

如果函数返回时，离开函数作用域后，其栈上空间已经还给系统，因此不能用栈上的空间作为引用类型返回。如果以引用类型返回，返回值的生命周期必须不受函数的限制（比函数生命周期长）。

5.传值、传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，效率十分低下，尤其是当参数或者返回值类型非常大时，效率更低。
传值和传指针在作为传参以及返回值类型上效率相差很大。

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 < 10000; ++i)
 {
  TestFunc1();
 }
 size_t end1 = clock();
 size_t begin2 = clock();
 for (size_t i = 0; i < 10000; ++i)
 {
  TestFunc2();
 }
 size_t end2= clock();
 cout << "TestFunc1 time:" << end1 - begin1 << endl;
 cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
 for (int i = 0; i < 10; ++i)
 {
  TestReturnByRefOrValue();
 }
 return 0;
}

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

七.内联函数
1.概念
以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数压栈的开销，提升程序运行的效率。
在函数前增加inline关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。
在release模式下，查看编译器生成的汇编代码中是否存在call
在debug模式下，需要对编译器进行设置，否则不会展开（debug模式下，，编译器默认不会对代码进行优化）

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

八.宏
1.优点
增强代码的复用性
提高性能

2.缺点
不方便调试宏（预编译阶段进行了替换）
导致代码可读性差，可维护性差，容易误用
没有类型安全的检查

3.C++技术替代宏
常量定义换用const
函数定义换用内联函数

九.auto
1.简介
使用auto修饰的变量，是具有自动存储器的局部变量。
C++11中，auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int TestAuto()
{
 return 10;
}
int main()
{
 int a = 10;
 auto b = a;
 auto c = 'a';
 auto d = TestAuto();
 cout << typeid(b).name() << endl;
 cout << typeid(c).name() << endl;
 cout << typeid(d).name() << endl;
 return 0;
}

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

2.使用规则
（1）auto与指针和引用结合起来使用
用auto声明指针类型时，用auto和auto*没有区别，但用auto声明引用类型时必须加&
（2）在同一行定义多个变量当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量

3.不能推导的场景
（1）auto不能作为函数的参数
（2）auto不能直接用来声明数组
（3）为避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
（4）auto在实际中最常见的优势用法是新式for循环，lambda表达式等进行配合使用
（5）auto不能定义类的非静态成员变量
（6）实例化模板时不能使用auto作为模板参数

十.基于范围的for循环（C++11）
1.范围for的语法
对于一个有范围的集合而言，for循环后的括号由冒号":"分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

int main()
{
 int array[] = { 1,2,3,4,5 };
 for (auto& e : array)
 {
  e *= 2;
 }
 for (auto e : array)
 {
  cout << e << " ";
 }
 cout << endl;
 return 0;
}

2.范围for的使用条件
（1）for循环迭代的范围必须是确定的
对于数组而言，就是数组中第一个元素和最后一个元素的范围
对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围
（2）迭代的对象要实现++和==操作

十一.指针空值nullptr（C++11）
1.C++98中的指针空值
NULL可能被定义为字面常量0，或者被定义为无类型指针（void*）常量
在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针（void*）常量，但是编译器默认情况下将其看成是一个整型常量，如果要将其按照指针方式来使用，必须对其进行强转（void*）0

2.nullptr与nullptr_t
为了避免混淆，C++11提供了nullptr，即：nullptr代表一个指针空值常量。nullptr类型为nullptr_t，仅可以被隐式转化为指针类型，nulllptr_t被定义在头文件中。
注意：（1）在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的
（2）在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同
（3）为了提高代码的健壮性，后续表示指针空值时最好使用nullptr