C++函数特性

内联函数

使用内联函数，编译器将使用的相应函数代码替换函数使用。

节省了调用函数的时间，占用了更多的内存。
如果要使用这项特性，需要：
（1）在函数声明前加上inline关键词
（2）在函数定义前加上inline关键词

引用变量

引用是已定义变量的别名，主要用途是用作函数形参。将引用变量用作参数，函数将使用原始数据，而不是副本。

int a;
int & b=a;

a和b的值和地址均相同。
必须在声明引用变量时进行初始化。

int & b=a;
int *const pr=&a;

其中*pr和b等效。

int a=1;
int & b=a;
int c=2;
b=c;

这会导致a和b（其实是一个东西）被赋值为了2，而不会导致b成为c的引用。

int a=1;
int * pr=&a;
int &b=*pr;
int c=2;
pr=&c;

pr将指向c，但是b仍然是a的引用，这无法改变。

相比于C的按值传递和按指针传递，C++增添了按引用传递这一功能。
（Java中只有按值传递参数）

void swap1(int a,int b){
//创建a和b两个变量，把传递值赋入
int temp;
temp=a;
a=b;
b=temp;
}

这样的交换是没有效的，因为实际上只交换了副本值。

void swap2(int *p,int *q){
//p和q是两个指向地址的指针
int temp;
temp=*p;
*p=*q;
*q=temp;
}

用指针传入是可行的，但是这不是现在的重点。

void swap3(int &a,int &b){
//使a和b成为传入变量的引用
int temp;
temp=a;
a=b;
b=temp;
}

按引用传入，这样是可行的。

如果实参和引用参数不匹配，系统将生成临时变量。

double side=3.0;
double *pd=& side;
double &rd=side;
long edge=5L;
double lens[4]={2.0,5.0,10.0,12.0};
double c1=f(side);
double c2=f(lens[2]);
double c3=f(rd);
double c4=f(*pd);//以上均可以创建引用
double c5=f(edge);
double c6=f(7.0);
double c7=f(side+10.0);//这三个需要建立临时变量

double f(const double &a){
return a*a;
}

如果函数的目的仅仅是传递参数而不是修改，那最好在前面加上const修饰符。

对结构而言，也可以使用引用变量。

struct fun{
int a;
float b;
}
void work(fun &w);
fun & acc(fun &w);//这可以返回一个结构

尽量避免返回一个临时变量的引用。

如果在引用返回值前面加上const修饰符，可以避免一些不必要的错误。

string result=work(a,b);
···
···
const string & work(string &s1,const string &s2){
string temp=s1+s2;
return temp;
}

这会导致程序崩溃，因为它返回了temp的引用，而temp在函数运行完之后已经释放了。

对于继承而言，父类的引用可以指向子类对象。
参数类型father &的函数可以接受son对象作为参数。

使用引用参数的主要原因：
（1）修改数据对象
（2）传递引用而不是整个数据对象，提高运行速度

对于只传递值而不作修改的函数：
（1）如果数据对象很小，应该按值传递
（2）如果对象是数组，只能使用指针
（3）如果数据对象是较大的结构，应该使用const引用
（4）如果数据对象是类对象，使用const引用

对于修改调用函数数据的函数：
（1）如果数据对象是内置数据类型，使用指针
（2）数据对象是数组，只能使用指针
（3）数据对象是结构，使用引用或指针
（4）数据对象是类对象，使用引用

默认参数

默认参数指当函数调用中省略实参时自动使用的值。

void fun(int n=1);

如果省略参数n，则默认值为1；否则传递的值将覆盖1.

对于带参数列表的函数，必须从右向左添加默认值。

void f1(int n,int m=1,int k=2);//ok
void f2(int n,int m=1,int k);//no

调用f1可以用以下三种方式：

f1(1);//相当于f1(1,1,2);
f1(1,2);//相当于f1(1,2,2);
f1(1,2,3);

f1(1, ,3);//不可以这么做

函数声明中声明了默认参数时，函数定义中的默认参数可以不写。

函数重载

如果两个函数的参数数目、类型、顺序都相同，则称它们的特征标相同。C++允许定义名称相同的函数，条件是它们的特征标不同。

void print(const char* str,int width);
void print(double d,int width);
void print(long l,int width);
void print(int i,int width);
void print(const char* str);

但是有一些看上去不同的特征标是不能共存的：

double cube(double x);
double cube(double &x);

对于const变量来说：

void f1(char *bits);
void f1(const char* bits);
void f2(char *bits);
void f3(const char *bits);
······
const char p1[20]="abababa";
char p2[20]="23333";
f1(p1);  //f1(const char* bits);
f1(p2);  //f1(char* bits);
f2(p1);  //no match
f2(p2);  //f2(char *bits);
f3(p1);  //f3(const char* bits);
f3(p2);  //f3(const char* bits);

原因是把非const值赋给const值是合法的，反之是不合法的。

下述做法也是不合法的：

long fun(int n);
double fun(int n);

函数模板

函数模板允许以泛型的方式编写程序，其中泛型可以用具体类型替换。通过将类型作为参数传给模板，可以让编译器自行生成该类型的函数。

template<typename AnyType>
void swap(AnyType &a,AnyType &b){
AnyType temp;
temp=a;
a=b;
b=temp;
}

函数模板也可以重载。

如果想对于某个特定的类进行特别的操作，可以采用显示具体化。具体化优先于常规模板，非模板函数优先于具体化和常规模板。

template<> void swap<string>(string&,string&);

在程序中也可以定义显示实例化：

template void swap<int>(int &,int &);

不可以在同一文件中使用同一类型的显示实例化和显示具体化。

int m=1;
double n=2.0;
cout<<add<double>(m,n);

虽然这里类型不匹配，但是强制为double类型实例化。

template<typename T>
T f(T a,T b);  //#1

int f(int a,int b);//#2
···

int m=1,n=2;
double x=1.0,y=2.0;
cout<<f(m,n);//#2
cout<<f(x,y);//#1 with double
cout<<f<>(m,n);//#1 with int,<>意味着要用模板函数
cout<<f<int>(x,y);//#1 with int，显示实例化