鲁达 1 函数的封装与代回
为什么需要函数？对于一些重复性的功能实现，为避免复制、粘贴带来的麻烦，而提炼出函数（并通过参数实现一般化），是分治算法的一种实现，代码整体上也更加模块化。所以要理解函数的种种参数传递与返回机制，要能考虑如何提炼出函数和如何将函数打散后再代回原调用处。
2 普通变量、指针变量、引用变量之间的地址语义和值语义
变量的二重属性：变量首先是一个内存单元地址的名称化，这是变量的地址语义，内存单元的比特值根据类型实现其值语义；
2.1 普通变量：显式使用其值语义，隐式使用其地址语义；
2.2 指针变量：显式使用其地址语义，隐式使用其值语义；
2.3 引用变量：声明、定义、初始化时显式使用其地址语义（使用上类似指针变量），此外的其他应用场合显式使用其值语义（使用上类似普通变量）；所以说，引用变量其实质是一个有常量属性的实现了自动解引用的特殊指针。所以引用相对于指针，有其使用上的简洁性、安全性，但也有其模糊性。
int i=5; int* p = &i; int& r = i; i=++*p; r++; cout<<i;//7以上的赋值方式，同样也适用于实参与形参的结合，以及函数返回值的语法机制。
应该使用指针的情况: 可能存在不指向任何对象的可能性，需要在不同的时刻指向不同的对象(此时，你能够改变指针的指向) 。返回函数体中new出的内存空间的地址。多态中使用指针。
应该使用引用的情况: 如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，使用此时应使用引用。
数组用作函数形式参数时会丢失数组元素个数的信息，即退化为指针；
函数返回数组名，实际返回的是指向数组首元素的指针。
3 主调函数caller与被调函数callee之间的关系
主调函数caller与被调函数callee之间的关系主要有两种：
一是两者相互独立；
二是两者通过实参和形参的结合来建立联系，实现内存单元的共享，可读也可写共享的内存单元。
实现的机制是通过副本机制（包括传参和返回）来实现的。
3.1 值传递：副本保存的是值（不是地址和引用），主调函数和被函数之间相互独立；
3.2 指针传递和返回：副本保存的是地址（不是值），主调函数和被函数之间通过传递的参数变量相互影响；
3.3 引用传递和返回：副本保存的是地址（不是值），主调函数和被函数之间通过传递的参数变量相互影响；但引用在初始化时有指针语义，在使用时有普通变量语义（自动解引用）；
函数的调用与嵌套调用通过栈来实现回溯，函数内可以用{}来嵌套块作用域。
4 指针和引用做参数及返回时，对应数据处理的方式
当指针做参数时，函数要处理的往往不是指针本身，而是指针所指向的数据，所以通常会以解引用的形式做为左值或右值出现在函数体中，而当指针做为左值出现时，通常是用于指针的修改或移动（更多的情形是将形参指针赋给一个临时变量的指针，以避免形参指针的变更）。
当引用做参数时，函数体中对引用所指向的变量的处理，因为其特殊的语义，使用上就像普通变量。
5 实参与形参结合及函数返回值的理解
5.1 实参与形参结合：局部变量的声明、定义、初始化；
5.2 函数返回值：可以理解为函数名做为一个全局变量，类型就是函数的类型，值就是其返回值；
#include <iostream> using namespace std; int& fr(int b[],int i) { return b[i]; } //int& fr = b[i]; int* fp(int b[],int i) { return &b[i]; } //int* fp = &b[i] int main() { //调用时 int a[] = {1,2,3,4,5}; int n = fr(a,3);// 实参与形参结构相当于：int b[]; b = a,int i = 3; fr(a,3) = 14;//相当于a[3]; cout<<*fp(a,2)<<endl;// 实参与形参结构相当于：int b[]; b = a,int i = 3; system("pause"); return 0; }5.3 两者都可能会有隐式类型转换，当是类类型和对象时，会自动调用拷贝构造函数。
6 指针做为参数时，注意区分函数体对指针本身或指针所指向的对象的处理
且两种情形的作用域不同，指针参数的作用域是本函数体，指针所指向的对象的作用域在本函数体以外。
#include <iostream> using namespace std; void f(char* p) { *p = 'A'; //对指针指向的内存单元的操作（解引用） p++; //对指针本身的操作，p=p+1，指针值发生了变化，相当于指针移到了下一个位置， //这里是演示用，通常是用一个临时指针来做指针移动 *p = 'B'; cout<<p<<endl;//Bc } int main() { char arr[] = "abc"; f(arr); system("pause"); return 0; }7 可以返回指针或引用的数据结构
因为函数调用是通过栈机制来实现的，函数实现了一个独立的作用域机制，所以函数不能返回函数体内定义的非静态局部变量的指针或引用。
可以返回指针或引用的数据结构包括：
7.1 引用或指针参数指向内容（包括数组）；
#include <; #include <; #include <; int *func(int *p) { (*p)++; printf("%p\n",p); return p; //p本身虽是局部变量，但其值却是从主调函数传过来的地址值 } /* int& func(int& p) { p++; return p; } */ int main() { int i=10; int *p=&i; printf("%p\n",p); printf("%d\n", *(func(p))); system("pause"); return 0; } /* 0012FF44 0012FF44 11 */数组也是如此：
int* f2(int a[],int i) { return &a[i]; int& f2(int a[],int i) { return a[i]; }7.2 静态局部变量；
int& func() { static int i=10; //因为是全局的静态区 int& p=i; p++; return p; //OK：可以做为返回值 }7.3 全局变量；
7.4 堆上数据；
避免返回函数内部new分配的内存的引用，但可以返回new的指针（也违背“谁申请，谁释放”的原则，存在内存泄漏的安全隐患）。
7.5 成员函数对私有数据成员的引用
#include<iostream> using namespace std; class C { public: //返回一个引用，也就是n的引用 int& getReFN() { return n; } int getN() { return n; } private: int n; }c; int main() { //将返回的引用赋值给k，k和n是一样的 //尽管n声明为私有，但是执行下条语句时候，就可以在外界通过k随意访问该变量 int& k = c.getReFN(); k = 7; cout<<c.getN()<<endl;//7 c.getReFN() = 9; cout<<c.getN()<<endl;//9 system("pause"); return 0; }8 二级指针或指针引用做函数参数
8.1 二级指针或指针引用做函数参数：
#include <iostream> using namespace std; void GetMemory(char* *pp,int n) { *pp = new char[n];//pp的解引用是*pp } int main() { char* p = NULL; GetMemory(&p,100);//注意二级指针的赋值char**p = &p; strcpy(p,"Hello!"); cout<<p; delete[]p; p=NULL; system("pause"); return 0; }以上为什么不能用一级指针作为参数？还是要回到前面讨论的在函数体内当用指针做形参时，在函数体操作指针本身与指针指向的对象的区别。也就是指针也其解引用的区别。
8.2 指针引用做函数参数
相对于二级指针更简洁：
#include <iostream> using namespace std; void GetMemory(char* &pp,int n) { pp = new char[n]; } int main() { char* p = NULL; GetMemory(p,100);//注意指针引用的赋值char*&p = p; strcpy(p,"Hello!"); cout<<p; delete[]p; p=NULL; system("pause"); return 0; }8.3 当然也可以用指针函数
#include <iostream> using namespace std; char* GetMemory(int n) { char* pp = new char[n]; return pp; } int main() { char* p = NULL; p=GetMemory(100);//注意指针引用的赋值char*&p = p; strcpy(p,"Hello!"); cout<<p; delete[]p; p=NULL; system("pause"); return 0; }以上美中不足的是，违背了“谁创建、谁释放”的原则，容易造成内存泄漏。
但有时却不得已为之：
const int MAX = 55; typedef struct Heap { int sizeHeap; int* heapData; }HEAP,*LPHEAP; LPHEAP createHeap() { LPHEAP heap=(LPHEAP)malloc(sizeof(HEAP)); heap->sizeHeap=0; heap->heapData=(int*)malloc(sizeof(int)*MAX); return heap; }8.4 最常见的是链表操作：
struct node { char data; node * next; } void Insert(node * &head,char keyWord,char newdata) //keyWord是查找关键字符 { node *newnode=new node; //新建结点 newnode->data=newdata; //newdata是新结点的数据 node *pGuard=Search(head,keyWord); //pGuard是插入位置前的结点指针 if (head==NULL || pGuard==NULL) //如果链表没有结点或找不到关键字结点 { //则插入表头位置 newnode->next=head; //先连 head=newnode; //后断 } else //否则 { //插入在pGuard之后 newnode->next=pGuard->next; //先连 pGuard->next=newnode; //后断 } }9 三种传递方式的效率比较
如果是单个的基本数据类型，值传递、指针传递、引用传递三者的区别不是很大，但当传递的是复杂的数组、结构体、类对象时，区别就很大了。
#include <; #include <string> #include <iostream> #include <sstream> #include <; using namespace std; string test = "origion" ; string changed = "changed" ; string getTime() { time_t tt =time(NULL); tm* t =localtime(&tt); string mon; stringstream ss; ss<<t->tm_mon; ss>>mon; (); string day; ss<<(t->tm_mday); ss>>day; string hour; (); ss<<(t->tm_hour); ss>>hour; string min; (); ss<<(t->tm_min); ss>>min; string sec; (); ss<<(t->tm_sec); ss>>sec; string times = mon+"-"+day+":"+hour+":"+min+":"+sec ; return times ; } void func1(string s)//值传递 { s = changed ; } void func2(string& s)//引用传递 { s = changed ; } void func3(string* s)//指针传递 { *s = changed; } int main() { cout<<getTime()<<endl; for (int i = 0; i < 3000000; i++) { func1(test); } cout<<getTime()<<endl; for (i = 0; i < 3000000; i++) { func2(test); } cout<<getTime()<<endl; for (i = 0; i < 3000000; i++) { func3(&test); } cout<<getTime()<<endl; //func3(&test); system("pause"); return 0 ; } /* 9-26:18:29:50 9-26:18:29:54 9-26:18:29:56 9-26:18:29:58 */如果参数是一个较复杂类对象，较效果更明显。
10 赋值运算符重载与引用返回
赋值运算符重载一般使用引用作为返回，简洁，高效，还可以实现链式表达式操作：
String 的赋值函数 operator = 的实现如下： String & String::operator=(const String &other) { if (this == &other) //自己赋值给自己会形成循环调用构造函数的错误 return *this; delete m_data; //因为赋值相当于更新，原来的空间释放，使用新的堆空间 m_data = new char[strlen)+1]; strcpy(m_data, o); return *this; // 返回的是 *this 的引用，无需拷贝过程 }this是隐含的指向函数调用对象的指针，一般是隐式使用，在特殊场合下可以显式使用。
为什么是return *this而不是return this？要注意引用在地址语义和值语义上的的语法特性，引用是用一个变量名（或对象名）而不是指针来初始化的。
看下面实例：
int& at() { return m_data_; //副本机制是变量地址 } int at() { return m_data_; //副本机制是变量值 }11 其它
11.1 复制构造函数的参数为什么一定要用引用传递，而不能用值传递？
值传递的参数在参数传递时有一个构造过程，即用实际参数的值构造形式参数，这个构造过程是由复制构造函数完成的。如果将复制构造函数的参数设计成值传递，会引起复制构造函数的递归调用。
11.2 下标运算符重载函数为什么要用引用返回？
下标运算符的第一个运算数是数组名，即当前类的对象。将下标运算符重载成成员函数时，编译器会将程序中诸如a[i]的下标变量的引用改为a.operator[](i)。如果a不是当前类的对象，编译器就会报错。下标变量是左值，所以必须用引用返回。
11.3 链式表达式的实现要用可以做为左值的引用或指针做为函数返回值，使用引用更为简洁。 重载操作符>>或<<时，返回的类型应该是一个流类型，而且返回的类型必须是引用，也是为了链式表达式实现的需要。
11.4 一般用指针参数做为输出参数，放在参数列表的右边（输入参数放在左边），而函数的参数有时用于输出逻辑值。
11.5 当为了避免副本机制而使用址传递或返回而又不需修改共享内存时，可以附加const修饰，以增强安全性。
-End-