【引用，缺省函数，重载和函数模板】

int main()
{
  int a = 10;
  int &x;      // error 定义引用必须初始化
  int &y = NULL;  // error 没有空引用
  int &b = a;
  int &&c = b;   // error //没有引用的引用、所为的二级引用
}

2.const 和引用的关系

int main()
{
  int a = 10;
  const int b = 20;
  int &x = b; // error;
  const int &x = b;  // ok;
  const int &y = a;  // ok;
  const int &z = 10; // ok;
  return 0;
}

其他引用举例：

int main()
{
  int a = 10, b= 20;
  int ar[5]={1,2,3,4,5};
  int *p = &a;
  int *&rp = p;    //引用指针
  int &x = ar[0];
  int (&br)[5] = ar; //引用数组//int &ar[5];//error
  return 0;
}

3.引用和指针的区别

1.从语法规则上讲，指针变量存储某个实例 (变量或对象）的地址；引用是某个实例的别名。
2.程序为指针变量分配内存区域； 而不为引用分配内存区域。
3.指针变量的值可以发生改变，存储不同实例的地址； 引用在定义时就被初始化，之后无法改变（不能是其他实例的引用）。
4.++引用与++指针的效果不一样。
例如就++操作而言，对指针变量的操作，会使指针变量指向下一个实体（变量或对象）的地址；而不是改变所指实体（变量或对象）的内容。
5.对引用的操作直接反应到所引用的实体（变量或对象）。
6.不可以对函数中的局部变量或对象以引用或指针方式返回

int * func_1()
{
  int a = 10;
  return &a;
}
int & func_2()
{
  int a = 10;
  return a;
}
// 都是错误的

其他区别：
解引用是指针使用时要在前加 “ * ” ；引用可以直接使用。
指针变量的值可以为空(NULL,nullptr); 没有空引用。
指针变量作为形参时需要测试它的合法性(判空NULL); 引用不需要判空；
对指针变量使用“sizeof”得到的是指针变量的大小。对引用变量使用“sizeof”得到的是变量的大小。
理论上指针的级数没有限制；但引用只有一级。即不存在引用的引用，但可以有指针的指针。
4.从汇编角度理解指针和引用（汇编代码都是一样的，发现了吗）

当程序执行函数调用时，系统要建立栈空间，保护现场，传递参数以及控制程序执行的转移等等，这些工作需要系统时间和空间的开销。
inline bool IsNumber(char ch) { return ch>=ʹ0ʹ&&ch<=ʹ9ʹ?1:0; }

在debug版本下 设置编译器。

要点：
inline是一种以空间换时间的做法，省去调用函数额开销。但当函数体的代码过长或者是递归函数
即便加上inline关键字，也不会在调用点以内联展开该函数。
inline对于编译器而言只是一个建议，编译器会自动优化。
inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。
如果函数的执行开销小于开栈清栈开销(函数体较小 )，使用inline处理效率高。如果函数的执行开销大于开栈清栈开销，使用普通函数方式处理。

一般情况下，函数调用时的实参个数应与形参相同，但为了更方便地使用函数，C++也允许定义具有缺省参数的函数，这种函数调用时，实参个数可以与形参不相同。
缺省参数指在定义函数时为形参指定缺省值（默认值）。
这样的函数在调用时，对于缺省参数，可以给出实参值，也可以不给出参数值。如果给出实参，将实参传递给形参进行调用，如果不给出实参，则按缺省值进行调用。
缺省参数的函数调用：缺省实参并不一定是常量表达式，可以是任意表达式，甚至可以通过函数调用给出。如果缺省实参是任意表达式，则函数每次被调用时该表达式被重新求值。但表达式必须有意义；

缺省参数可以有多个，但所有缺省参数必须放在参数表的右侧，即先定义所有的非缺省参数，再定
义缺省参数。这是因为在函数调用时，参数自左向右逐个匹配，当实参和形参个数不一致时只有这样才
不会产生二义性。

void fun(int a, int b = 23 , int c = 8000)
{
cout << "a = " << a << " b = " << b << " c = " << c << endl;
}
int main()
{
fun(12);
  fun(10,20);
  fun(10,20,30);
  fun(10,,30); // error;
return 0;
}

习惯上，缺省参数在公共头文件包含的函数声明中指定，不要函数的定义中指定。声明中给默认值 定义中的函数形参就不要给默认值。测试函数中只能看到.h中的声明的默认值 看不见.cpp文件中的默认值。

在C++中可以为两个或两个以上的函数提供相同的函数名称，只要参数类型不同，或参数类型相同 而参数的个数不同， 称为函数重载。

// 重载函数
void print(int a,char b);
void print(char a,int b);

函数重载的规则：

1.如果两个函数的参数表相同， 但是返回类型不同，会被标记为编译错误：函数的重复声明。

int my_max(int a,int b)
{
  return a > b ? a : b;
}
unsigned int my_max(int a,int b) // error;
{
  return a > b ? a : b;
}
int main()
{
  int ix = my_max(12,23);
  unsigned int  = my_max(12,23); // error;
  reutrn 0;
}

2.参数表的比较过程与形参名无关。

// 声明同一个函数
int my_add(int a,int b);
int my_add(int x,int y);

3.如果在两个函数的参数表中，只有缺省实参不同，则第二个声明被视为第一个的重复声明。

void Print(int *br,int n);
void Print(int *br,int len = 10);

4.typedef 名为现有的数据类型提供了一个替换名，它并没有创建一个新类型 ，因此 ，如果两个函数参
数表的区别只在于一个使用了 typedef ，而另一个使用了与 typedef 相应的类型。则该参数表被视为相
同的参数列表。

5.当一个形参类型有 const 或 volatile 修饰时,如果形参是按值传递方式定义,在识别函数声明是否相同时
,并不考虑 const 和 volatile 修饰符.

6.当一个形参类型有 const 或 volatile 修饰时,如果形参定义指针或引用时,在识别函数声明是否相同时 , 就要考虑 const 和 volatile 修饰符.

实例1（第二个函数和主函数中ip定义的指针能力不一致引发的重载的失败）

using namespace std;
void fun(int* p) {}
void fun( int* const p) {}
void fun(int& a) {}
void fun(const int& a) {}
int main()
{
	int a = 10, b = 20;
	const int* ip = &a;
	 const int & c = a;
	//int* & s = ip;
	fun(ip);
	//printf("%d", c);
	return 0;
}

实例2

void fun(int* p) {}
void fun(const int*  p) {}
void fun(int& a) {}
void fun(const int& a) {}
int main()
{
	int a = 10, b = 20;
	const int* ip = &a;
	 const int & c = a;
	//int* & s = ip;
	fun(ip);
	//printf("%d", c);
	return 0;
}

编译器没有报错。

7.注意函数调用的二义性;
如果在两个函数的参数表中,形参类型相同,而形参个数不同,形参默认值将会影响函数的重载.

void fun(int a) {}
void fun(int a, int b) {}
void fun(int a, int b = 10);

8 值型别进行函数的重载
左值和右值：
“在C++之中的变量只有左值与右值两种：其中凡是可以取地址的变量就是左值，而没有名字的临时变量，字面量就是右值”。
例如 ++i是左值 i++是右值。

前者，对 i + 1 后再赋给 i，最终的返回值就是 i，所以，++i 的结果是具名的，名字就是 i；而对于 i++ 而言，是先对 i 进行一次拷贝，将得到的副本作为返回结果，然后再对 i + 1，由于 i++ 的结果是对 i + 1前 i 的一份拷贝，所以它是不具名的。假设自增前i的值是 6，那么，++i 得到的结果是 7，这个 7 有个名字，就是 i ；而 i++ 得到的结果是 6，这个 6 是 i + 1 前的一个副本，它没有名字，i 不是它的名字，i 的值此时也是 7。可见，++i 和 i++ 都达到了使 i + 1的目的，但两个表达式的结果不同。

9. 函数重载解析的步骤如下
   1 确定函数调用考虑的重载函数的集合, 确定函数调用中实参表的属性.
   2 从重载函数集合中选择函数 ,该函数可以在 (给出实参个数和类型 )的情况下可以调用函数.
   3 选择与调用最匹配的函数.

“C”或者“C++”函数在内部（编译和链接）通过修饰名识别。修饰名是编译器在编译函数定义或者原型时生成的字符串。
修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。
调用约定：
__stdcall 是Pascal程序的缺省调用方式，通常用于Win32 Api中，函数采用从右到左的压栈方式，自己在退出时清空堆栈。
C调用约定（即用 __cdecl 关键字说明）按从右至左的顺序压参数入栈，由调用者把参数弹出栈。
对于传送参数的内存栈是由调用者来维护的（正因为如此，实现可变参数的函数只能使用该调用约
定）。
__fastcall 调用约定是“人”如其名，它的主要特点就是快，因为它是通过寄存器来传送参数的（实际上，它用 ECX 和 EDX 传送前两个双字（ DWORD ）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈），在函数名修饰约定方面，它和前两者均不同。
thiscall 仅仅应用于“ C++ ”类的成员函数。 this 指针存放于ECX 寄存器，参数从右到左压。
thiscall 不是关键词，因此不能被程序员指定。
在C/C++中，一个程序要运行起来，需要经历以下几个阶段：预编译（预处理）、编译、汇编、链接。Name Mangling是一种在编译过程中，将函数名、变量名的名字重新命名的机制。

extern 关键字的使用：

关键字 :
extern “C” ： 函数名以C的方式修饰约定规则；
extern “C＋＋” ： 函数名以C＋＋的方式修饰约定规则；

为了代码重用，代码就必须是通用的；通用的代码就必须不受数据类型的限制。那么我们可以把数
据类型改为一个设计参数。这种类型的程序设计称为参数化(parameterize) 程序设计。软件模块由模板
(template) 构造。包括函数模板(function template)和类模板(class template)。
函数模板可以用来创建一个通用功能的函数，以支持多种不同形参，简化重载函数的设计。
函数模板定义如下：

template<模板参数表>
返回类型 函数名(形式参数表)
{
 ...;//函数体
}

实例：

template<class T>
T my_max(T a, T b)
{
  return a > b? a:b;
}
int main()
{
my_max(12, 23);
my_max('a', 'b');
my_max(12.23, 34.45);
return 0;
}

实参推演:

在编译过程中，根据函数模板的实参构造出独立的函数，称为模板函数(template function)。这个
构造过程被称为模板实例化（ template instantiation ）。

函数模板不是简单替换,而是根据实参推演形参的类型 是生成了不同形参类型的函数