C++中的函数

概要

这里我们主要讲的是有关c++中函数的的一些使用方法和注意事项

函数

函数缺省参数

1.在c++里，函数的形参列表中的形参是可以有默认值的。有默认值的参数即为默认参数 。
2.在函数调用时，有默认参数可以缺省。
用法：返回值类型 函数名 （参数= 默认值）{函数体}
我们看下面一个例子：

#include <iostream>
using namespace std;
int add(int x, int y, int z=100){
     return x + y + z;
}
int main(void){
   cout << add(1,2,3) << endl;
   cout << add(1,2) << endl;
return 0;
}

由结果知，我们在没有给定第三个参数时，函数将调用默认值；
但在这里我们要注意下：如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值。这就是靠右原则
这里，我们在定义add的时候这样子：int add(int x,int y = 20,int z)
看看会发生什么：

这里报错，形参3缺少默认参数，所以要遵守原则哦！
3.函数声明和函数实现（即函数定义），只允许其中一个有默认值，即如果函数声明有默认值，则函数实现的时候就不能有缺省参数。
来看实例：

#include <iostream>
using namespace std;
int add(int x, int y, int z=200); //error
int main(void){
   cout << add(1,2,3) << endl;
   cout << add(1,2) << endl;
   return 0;
}
int add(int x, int y, int z = 100){ //error
     return x + y + z;
}

想一想，我们这里如果在实现add函数的时候将在形参3也改为200可不可以呢？

哑元

c++中将只有类型而没有变量名的参数称为“哑元；

int func(int a, int ){
...
}

1.哑元的话一般我们用在代码迭代更新的时候用的较多

void func(int i,int j){…}==升级==>void func(int i){…}
void func(int i,int j){…}==升级==>void func(int i, int/*哑元*/){…}

2.操作符重载中，区分前后++/–

引用参数

1.可以将引用用于函数的参数，这时形参就是实参的别名
2.引用型函数参数作用
（1）在函数中修改实参的值

#include <iostream>
using namespace std;
void swap(int & ,int&);
int main()
{
    int i =3,j = 5;
    swap(i,j);
    cout<<"i="<<i<<endl<<"j="<<j<<endl;
    getchar();
    return 0;
}
void swap(int &a,int &b)
{
   int temp;
   temp = a;
   a =b;
   b= temp;
}

（2）避免实参到形参数值复制的开销，提高传参效率

#include <iostream>
using namespace std;
struct Teacher{
   char name[100];
   int age;
};
void print( Teacher& t){
    cout << t.name << ',' << t.age/*++*/ << endl;
}
int main(void){
    Teacher t = {"张飞",40};
    print(t); 
    return 0;
}

（3）引用型函数参数可能意外修改实参，如果不希望通过引用修改实参本身，可以将其声明为常引用，在提高传参效率的同时还可以接收常量型实参

int add(const int &a, const int &b){
    a++;   //error
    return a+b;
}
int main(void){
      add(3, 5);
      return 0;
}

返回应用

1.可以将函数的返回类型声明为引用型，这时函数的返回结果就是return后面数据的别名，避免了函数返回值的开销
2.函数中返回引用，一定要保证在函数返回以后，该引用的目标依然有效
（1）可以返回全局变量、静态变量和成员变量的引用
（2）可以返回引用型参数的本身
（3） 可以返回调用对象自身的引用
（4） 可以返回堆中动态创建对象的引用
（5）不能返回局部变量的引用//非常危险
我们就第五个，看下面例子

#include <iostream>
using namespace std;
int& add(const int &a, const int &b)
{
    int tmp = 0;
    tmp = a + b;
    return tmp; //风险 函数结束对应内存空间回收
}
int main(void){
     int x = 100;
     int y = 200;
     int &t = add(x,y);
     t++;//通过别名操作 已经被系统回收的内存
     cout << t <<endl;
     return 0;
}

虽然结果能出来，当编译器还是给我们警告：返回值是局部变量，这里我们最好不要这样子使用

函数的重载

1.重载的条件：同一作用域，函数名相同，但是的参数表必须有所区分（类型、个数、顺序），将构成重载关系
根据概念，我们来写几个重载函数：

#include <iostream>
using namespace std;
void func(int a, char *p){

}
void func(char *p, int a){
}
void swap(int *a, int *b){
      int tmp = *a;
     *a = *b;
    *b = tmp;
}
void swap(char *a, char *b){
      char tmp = *a;
      *a = *b;
      *b = tmp;
}
void swap(bool *a, bool *b){
       bool tmp = *a;
       *a = *b;
       *b = tmp;
}
int main(){
    int x = 10;
    int y = 20;
    swap(&x, &y);
    cout << x <<" " << y << endl;
    
    char a = 'a';
    char b = 'b';
    swap(&a, &b);
    cout << a << " " << b << endl;
    
    bool f1 = true;
    bool f2 = false;
    swap(&f1, &f2);
    cout << f1 << " " << f2 << endl;
    return 0;
}

2.重载的实现原理：
编译器将形参变量的类型作为最终函数名的一部分。
我们可以使用 nm a.out 看下编译器处理后的函数

我们看到，在080487c4后，就是我们前面定义的swap被处理后的函数名
，加了不同的后缀来进行区分，所以我们在使用的时候就不会导致函数名冲突啦，也就构成了重载；
此外，我们还需要注意的是：
（1.形参变量名不同 不构成重载的要素
（2.函数返回类型不同 不构成重载的要素
3.函数匹配的优先级
当前g++编译器匹配的一般规则：
1）完全匹配 //最高
2）常量转换 //较好
3）升级转换 //一般
4）降级转换 //较差
5）省略号匹配 //最差
下面我们来逐一看例子：

#include <iostream>
using namespace std;
void bar(int i){
    cout <<"bar(int)" << endl;
}
void bar(const char c){
    cout << "bar(const char)" <<endl;
}
void foo(char c){
    cout << "foo(char)" << endl;
}
void foo(int i){
    cout << "foo(int)" << endl;
}
void hum(int i, ...){
    cout <<"hum(int, ...)" << endl;
}
void hum(int i, int j){
   cout << "hum(int, int)" << endl;
}
int main(){
   int m = 100;
   bar(m);  //完全匹配
   char c = 'A';
   bar(c); //常量转换 char -----> const char
   short s = 10;
   foo(s); // short ----> int  升级转换
   hum(10, 1.23); // double -----> int 降级转换
   return 0;
}

我们这里还要注意两个问题；
（1）当我们定义的变量与重载函数的形参之间都是升级转换的时候，我们的编译器该怎么选择呢，比如看以下例子：

int func(unsigned int x){
return x;
}
double func(double x){
return x;
}
int n = 12;
func(n); // error

到这里，编译器也不知道该向哪个转换了；因此，我们这里要强转以下我们定义的类型。如：func((unsigned int)n);

内联函数

在函数声明或定义时，将inline关键字加在函数返回类型前面就是内联函数。

#include <iostream>
using namespace std;
inline int add(int x, int y){ //内联函数
return x+y;
}
int main(void){
int ret = add(3,5); // int ret = 3+5;
return 0;
}

这里，在调用的时候，直接将add里的执行内容替换到主函数里；不需要建立函数调用时的运行环境，不需要进行参数传递 ， 不需要跳转,效率更高。
注意：inline关键字只是建议编译器做内联优化，编译器不一定做内联；
内联函数的声明或定义必须在函数调用之前完成；
一般几行代码适合作为内联函数， 像递归函数 包含循环 switch goto复杂逻辑的函数不适合内联

new 和delete

在C语言中，如果需要使用堆内存，程序员可以用函数malloc()从堆中分配指定大小存储区域，用完之后必须用free()将之归还系统。如果用完之后没用free()释放，就会造成内存泄漏。
malloc()函数的使用比较麻烦，除了需要计算需求内存的大小之外，还必须对获得的内存区域进行类型转换。那么我们在c++里为此提供了new 和delete两个运算符。
用法：
new：
p = new type
p = new type(x)
p = new type[n]
其中p是指针变量，type是数据类型。用法1 只分配内存， 用法2将分配的堆内存初始化为x,用法3分配具有n个元素的数组。分配不成功返回空指针（NULL）。
delete:
delete p;
delete [] p;
其中p是用new分配到的堆空间指针变量。用法1用于释放动态分配的单个内存，用法2用于释放动态分配的数组存储区。

#include <iostream>
using namespace std;
int main(){
   int *p1, *p2, *p3;
   //p1 =(int *) malloc(sizeof(int));
   p1 = new int ; //在heap(堆)中分配一个int类型内存空间
   p2 = new int(123); //在heap(堆)中分配一个int类型内存空间并初始化为123
   p3 = new int[123]; //在heap(堆)中分配123个int类型内存空间
   *p1 = 100;
   p3[3] = 0x55;
   //free(p1);
   delete p1;
   delete p2;
  /*注释数组内存空间的释放
  *如果写成 delete p3; 只释放了一个int 类型内存空间p3[0] 其余都未释放 造成内存泄漏
   * */
   delete [] p3;
   return 0;
}

与c语言相比，c++是不是在这里稍微精简了呢！
好了，我们c++里面向过程编程的内容就到这里啦！感谢大家的观看，如有错误的地方，欢迎指正！！！大家记得分享哦< _ >！！！