1 函数重载
1.1 定义
要求：
1）同一作用域内
2）函数名相同
3）形参表不同（与形参个数及每个形参类型有关，与形参名无关）
重载关系的函数调用哪个：
根据实参类型和形参类型进行匹配，调用最匹配的函数
// overload_pre.cpp
// 函数之间的关系--重载关系(1.同一作用域内 2.函数名相同 3.形参表不同)
// 形参表是否相同 与 形参名无关 与 形参的个数 以及 每一个对应形参的类型有关
#include <iostream>
using namespace std;
void foo( char* c, short s ) {
cout << "1. foo" << endl;
}
void foo( int i, double d ) {
cout << "2. foo" << endl;
}
void foo( const char* c, short s ) {
cout << "3. foo" << endl;
}
void foo( double d, int i ) {
cout << "4. foo" << endl;
}
// int foo( double i, int d ) {} // error-是否为重载关系和返回值类型无关
// void foo( double i, int d ) {} // error-形参表是否相同 与 形参名无关
int main( void ) {
char* c; short s;
foo( c, s ); // 1
const char* cc;
foo( cc, s ); // 3
int i; double d;
foo( i, d ); // 2
foo( d, i ); // 4
return 0;
}1.2 重载和隐藏：
-只有同一作用域内的同名函数才涉及重载的关系
-不同作用域的同名函数涉及的是隐藏关系（定义表隐藏可见表）
// overload.cpp 详谈同一作用域
#include <iostream>
using namespace std;
namespace ns1 {
void foo( char* c, short s ) {
cout << "1. foo" << endl;
}
void foo( int i, double d ) {
cout << "2. foo" << endl;
}
}
namespace ns2 {
void foo( const char* c, short s ) {
cout << "3. foo" << endl;
}
void foo( double d, int i ) {
cout << "4. foo" << endl;
}
}
int main( void ) {
using ns2::foo; //名字空间声明,从这行代码开始ns2中foo引入当前作用域(出现在定义表中)
using namespace ns1;//名字空间指令,从这行代码开始ns1中的foo在当前作用域可见(出现在可见表中)
char* c; short s;
foo( c, s ); // 第3个foo将第1个foo函数隐藏
return 0;
}1.3 重载匹配优先级
1）普通方式调用重载关系的函数：
完全匹配 > 常量转换 > 升级转换(小转大) > 标准转换(大转小) > 自定义转换 > 省略号匹配
2）函数指针方式调用重载关系的函数：
函数指针本身的类型决定其调用哪个版本的重载函数。
工作中建议完全匹配。
// overload2.cpp 重载匹配优先级
#include <iostream>
using namespace std;
void foo( char* c, short s ) { // _Z3fooPcs 完全匹配
cout << "1. foo(char*, short)" << endl;
}
void foo( const char* c, short s ) { // _Z3fooPKcs 常量转换
cout << "2. foo(const char*, short)" << endl;
}
void foo( char* c, int s ) { // _Z3fooPci 升级转换（小转大，没有数据损失）
cout << "3. foo(char*,int)" << endl;
}
void foo( char* c, char s ) { // _Z3fooPcc 标准转换（大转小，可能数据损失）
cout << "4. foo(char*,char)" << endl;
}
void foo( ... ) { // _Z3fooz 省略号(可变长)匹配
cout << "5. foo(...)" << endl;
}
int main( void ) {
char * c; short s;
foo( c,s ); //_Z3fooPcs(c,s)
// 普通方式调用重载关系的函数,根据实参类型和形参类型匹配，来确定调用哪个foo
void(*pfunc)(const char*,short) = foo; // _Z3fooPKcs 定义函数指针，形参可无名
pfunc(c,s); // 函数指针方式调用重载关系的函数,
// 根据函数指针本身的类型，来确定调用哪个foo
return 0;
}注意上述代码，定义函数指针，可以不写形参名。
1.4 重载揭秘
重载是通过C++换名机制来实现的：
nm a.out 命令 查看函数符号名
通过extern "C" 可以要求C++编译器按照C方式编译函数，即不做换名，当然也就无法重载：
// extern/cal.cpp
extern "C" { //extern "C" {} ,缩不缩进都可
int add( int a, int b ) {
return a + b;
}
int sub( int a, int b ) {
return a - b;
}
}// extern/main.c
#include <stdio.h>
int main( void ) {
int c = add( 5, 3 );
int d = sub( 5, 3 );
printf("c=%d,d=%d\n", c, d);
return 0;
}
//g++ -c cal.cpp
//nm cal.o //由于extern "C"，函数没换名，与c代码中一致
//gcc -c main.c
//nm main.o
//gcc main.o cal.o
//./a.out2 动态内存（堆内存）分配
可以继续使用标准C库函数malloc()/free()，
free(野指针)后果很严重（段错误，double free），free(空指针)安全：
// new.cpp 动态(堆)内存分配
#include <iostream>
#include <cstdlib>
using namespace std;
int main( void ) {
int* pm = (int*)malloc( 4 );
cout << "*pm=" << *pm << endl; // 初始值为0
free( pm ); // 当这行代码执行结束后，pm指向的堆内存被释放，进而pm变为野指针
pm = NULL; // pm变为空指针
free( pm ); // 给free传递的为野指针,释放野指针后果很严重,释放空指针是安全
return 0;
}更建议使用new/delete操作符在堆中分配/释放内存：
int* pi = new int; //初始值一般为0
delete pi;
在分配内存的同时初始化：
int* pi = new int( 100 ); //初始值为100
可以数组方式new：
int* pi = new int [4] {10, 20, 30, 40}; // {}方式是11标准才支持的，编译时-std=c++11
想申请16字节，实际多申请4字节，存储数组元素的个数
但也要数组方式delete：
delete[] pi; 加[]，才能将多申请的4字节也释放掉
通过new操作符分配N维数组，返回N-1维数组指针：
int (*pa) [4] = new int [3][4]; // 返回值类型是 int (*)[4]
int (*pb) [4][5] = new int [3][4][5]; // 返回值类型是 int (*)[4][5]
不能通过delete操作符释放已释放过的内存。
delete野指针后果很严重（段错误，double free），delete空指针安全。
故建议释放指针指向的内存后，立即置空：
delete(pn);
pn = NULL;
new操作符申请内存失败，将抛出异常 。
// new.cpp 动态(堆)内存分配
#include <iostream>
#include <cstdlib>
using namespace std;
int main( void ) {
int* pm = (int*)malloc( 4 );
cout << "*pm=" << *pm << endl; // 初始值为0
free( pm ); // 当这行代码执行结束后，pm指向的堆内存被释放，进而pm变为野指针
pm = NULL;
free( pm ); // 给free传递的为野指针,释放野指针后果很严重,释放空指针是安全
int* pn = new int(100);
cout << "*pn=" << *pn << endl; // 可以自己指定初始值为100
delete pn; // 当这行代码执行结束后, pn指向的堆内存被释放，进而pn变为野指针
pn = NULL;
delete pn; // 给delete传递野指针，释放野指针后果很严重,释放空指针是安全
int* parr = new int[4]{10,20,30,40};//以数组方式new一块内存,永远返回第1个元素的地址
for( int i=0; i<4; i++ ) {
cout << parr[i] << ' ';
}
cout << endl;
delete[] parr; // 数组方式new的也要以数组方式delete
// 不管是几维数组，都应该当做一维数组看待
int(*p)[4] = new int[3][4]; // 返回值是一维数组类型的指针
delete[] p;
try {
new int[0xFFFFFFFF];
}
catch(...) { //捕获...
}
return 0;
}
//g++ new.cpp -std=c++113 左值和右值
C++所有数据，不是左值，就是右值：
左值：能够取地址的值，通常具名
右值：不能取地址的值，通常匿名
// lrvalue.cpp 左值 和 右值
#include <iostream>
using namespace std;
int foo( ) {
int m=888;
return m;
}
int main( void ) {
// 当前作用域的生命期
// 具名内存-->能够取址-->左值|非常左值(无const修饰)
// |常左值 (有const修饰)
int a = 10;
&a;
a = 15;
const int b = 10;
&b;
// b = 15; // error
// 语句级生命期
// 匿名内存-->不能取址-->右值|直接更改右值毫无意义(98/03标准给出结论)
//
10;
// &10; // error
// 10 = 15; // error
/*|888|*/foo( ); // (1)分配一块内存空间 (2)生成跳转指令
// &foo( ); // error
// foo( ) = 15; // error
return 0;
}4 引用（如影随形，从一而终）
1）引用即内存的别名
int a = 10; // a是内存的真名
int& b = a; // 不是赋值，而是给a起别名！（给引用b，赋真名）
2）C++层面，引用本身不占内存，并非实体，
对引用（别名）的所有操作都是在对目标内存进行操作。
3）引用必须初始化，且不能更换目标。
int c = 20;
b = c; // 仅仅是对引用的目标内存a进行赋值
4）不存在引用的引用
int a = 10;
int& b = a; //别名b，真名a
int& d = b; //别名d，真名a
5）引用的常属性必须和目标的常属性“一致”
const int e = 10;
const int& f = e; // OK
int& g = e; // ERROR
6）可以限定更加严格
int a = 10;
const int& h = a; // OK
// alias.cpp 引用:就是一块内存的别名
#include <iostream>
using namespace std;
int main( void ) {
int a = 10;
int& b = a; // 这并不是利用a的数据给b赋值,而应该理解为 引用b是a所代表内存的别名
b = 20; // 对 引用b赋值，其实就是在对引用b的目标内存(a)赋值
cout << "a=" << a << ", b=" << b << endl;//读取引用b的值，
//其实读取的为引用b的目标内存(a)的值
cout << "&a:" << &a << ", &b:" << &b << endl;
// 取引用b的地址，其实取的为引用b的目标内存(a)的地址
int c = 30;
b = c;
cout << "a=" << a << ", b=" << b << ", c=" << c << endl;
cout << "&a:" << &a << ", &b:" << &b << ", &c:" << &c << endl;
return 0;
}7）引用可以延长右值的生命周期
8）常引用 即 万能引用
// alias2.cpp 5 内联函数
调用普通函数(非内联函数)的问题：
-每个普通函数调用语句都需要发生跳转操作，这种跳转操作会带来时间开销：
内联就是用函数已被编译好的二进制代码，替换对该函数的调用指令。
内联在保证函数特性的同时，避免了函数调用的时间开销：
// inline.cpp 内联函数:编译器的优化策略
#include <iostream>
using namespace std;
void foo( int x ) { // 非内联(普通)函数
cout << "foo(int): " << x << endl;
}
inline void bar( int x ) { // 内联函数
cout << "bar(int): " << x << endl;
}
int main( void ) {
foo( 10 ); // 将此处替换为 跳转指令
foo( 20 ); // ...
foo( 30 ); // ...
bar( 10 ); // 见此处替换为 bar函数编译后产生的二进制指令集
bar( 20 ); // ...
bar( 30 ); // ...
return 0;
}内联会使文件的体积变大，进而导致进程的内存变大，因此只有频繁调用的简单函数才适合内联。
稀少被调用的复杂函数和递归函数都不适合内联。
inline关键字仅表示期望该函数被优化为内联，但是否适合内联则完全由编译器决定。
