c++函数

1、函数的概念

什么是函数
在《C++Primer》中对于函数这样说道：
函数是一个命名了的代码块，我们通过调用函数执行相应的代码，函数可以有0个或者多个参数，而且会产生一个结果

总结：
我觉得函数可以说是一个能够实现一定功能的盒子，把他需要的工具放进去，他给你返回一个结果，可以说函数的内部是一个未知的东西，我们只需要知道这个函数能实现什么样的功能就行了，不需要去知道里面的代码怎么写的。

为什么使用函数

当一个项目或者代码全部紧挨在一起的话，会显得开发十分繁杂，比如一个源文件的main函数中写了很多的代码，前20行实现一个功能，接下来100行实现另一个功能，再300行又实现一个功能…，这样下去，在一个main函数中零零散散地实现了很多功能！但是，过几天反过来再来看源代码，感觉就是脑袋一翁，一个main函数里面写了好几百行代码，不知道这些东西是什么，这样的开发会造成效率的丧失，会让我们没有思路，所以将一个个功能用一个个的函数封装起来，并做好注释，会节省我们很多的开发时间，使得代码可读性，容错性都会大大提高，所以一个良好的使用函数和注释的习惯是一个程序员必备（可以这么说）的品质

2、函数基础

一个函数由以下部分组成
返回类型+函数名（参数列表）{代码块}
 比如一个代码，求两个数的和并输出

#include
int main(){
    int a,b;
    std::cin>>a>>b; //输入两个数的值
    int count = a+b;//count为a+b之后的值
    std::cout<<"两数之和为:"<
    return 0;
}

在上面的代码中，再main函数中定义了一个求两数之和的程序，所有的计算代码都在main函数里面，下面我们对其加法功能进行一个封装

#include
void addData(int a,int b){  
    int count = a+b;//count为a+b之后的值
    std::cout<<"两数之和为:"<
}
int main(){
    int a,b;
    std::cin>>a>>b; //输入两个数的值
    addData(a,b); 
    return 0;
}

我们将求和并输出的代码封装到了一个函数addData中，可以说addData就是实现一个两数相加并输出的功能，对于之后还需要进行两数相加的操作，我们不需要重复地写相加输出代码，只需要调用addData即可，这样不仅提高了代码的可读性，将不同功能进行了区分，而且减少了代码的重复书写，对于一些经常要用到的代码操作，使用函数将这个功能封装起来是一个很好的方法！

3、形参和实参

在函数的编写格式中，在函数名的后面的括号里放入的参数是形式参数

返回类型+函数名(形参列表){…}

上面的代码中，在int addData(int a,int b)里面，这里面的a，b是一个形式参数，可以这么理解，现在这些参数a,b的具体值我不知道。我只知道他是一个整型变量，当在运行函数调用时，传入的才是实际参数，比如main函数中的addData(a,b)，此时的a,b是我们输入的已经初始化了的函数，将实际参数放入函数的过程叫做传递参数，即传递具体的值给函数的形式参数，进行特定的操作，它就类似于一个公式一样，你必须给定实际的值，才能得到实际的结果，在传递参数的过程中需要注意几点

传入的实际参数必须跟形式参数的类型一样

传入的实际参数必须是按照顺序传递的

传入的实际参数的数量必须与形式参数的数量相同

//比如前面的addData

addData(3,2); //正确--传递的数量正确
addData(3.0,2); //正确--3.0会强制转换为int类型
addData("321");//错误--传递的类型不正确
addData(2,3,1);//错误--传递的参数数量不对

参数的定义

每一个形参之间必须用逗号隔开，并注明类型

可以不定义形式参数

形式参数可以是任何基本类型或者本身定义的类型，可以是指针，引用，值

int fun();//正确--隐式的定义无形式参数
int fun(void);//正确--显示的定义无形式参数
int fun(int a,b);//错误--每一个形式参数前都要有一个变量类型
int fun(int a int b);//错误--不同的形式参数之间没有用逗号隔开
int fun(int a,int b);//正确--值传递
int fun(int *a,int *b);//正确--指针传递
int fun(int &a,int &b);//正确--引用传递

4、函数的调用

直接调用

直接调用即在代码中调用函数，比如说addData()

嵌套调用

嵌套调用指的是，举一个例子，在a函数中会调用b函数，而在b函数中又调用了a函数

5、函数的参数传递

C++函数的传递个人感觉是一个十分骚气的操作，他的值传递不像Java这么简单，如果不了解c++的传值类型，可能有一些方法的调用得到的结果往往不是我们所想的那样
比如设计一个函数

/cout<>    1
//cout<<&a<>    008FF9BC
//&  为取地址值符号
#include 
using namespace std;
int main()
{
    int a = 1;
    int b = 2;
    cout << "交换前 a = " << &a << "\tb = " << &b << endl;
    cout << "打印出交换函数内部的a,b地址" << endl;
    void swap(int, int); 
    swap(a, b);
    cout << "交换后 a = " << &a << "\tb = " << &b << endl;
    return 0;
}
void swap(int x, int y)
{
    int temp;
    temp = x;
    x = y;
    y = temp;
    cout << "交换函数swap内部 a = " << &x << "\tb = " << &y << endl;
}

我们可以发现单独的交换函数的参数地址其实并不会改变，交换前交换后的地址都是一样的，唯一不一样的是交换时的地址

你写了一个函数，能够交换两个变量的值，于是在main函数中测试这个函数，却发现输出的结果往往不是我们想象的那样，发现值并没有交换,于是焦头烂额，我这思路没错啊…，到底错在哪里呢，其实是因为c++函数的传值的差异，如果读者有兴趣的话，不妨听我来讲一讲这其中的原因！

多次运行的你可以发现没错的地址值都是随机的，并不是唯一的

int main(){
  int a,b;
 cin>>a>>b;
 cout<<"a的值为："<
 cout<<"b的值为："<
 swaps(a,b);
 cout<<"a的值为："<
 cout<<"b的值为："<
 return 0;
}

1、值传递

可以知道，每一个变量的定义都会在内存中对应一个地址，每一个地址是对应着特定的编号的，值即这个对应内存地址里面存储的数据，将值作为形式参数传入数组，比如上面main函数的swab(a,b),你以为swap里面用到的a，b就是main函数里面定义的a，b，但是实际不是这样的，可以对函数做一些修改，打印出他的内存地址

#include
using namespace std;
void swaps(int a,int b){
 cout<<"Function Swap address_a is"<<&a<
 cout<<"Function Swap address_b is"<<&b<
 int temp = a;
 a = b;
 b = temp;
}
int main(){
  int a,b;
 cin>>a>>b;
 cout<<"Address_a"<<&a<
 cout<<"Address_b"<<&b<
 cout<<"a："<
 cout<<"b："<
 swaps(a,b);
 cout<<"a："<
 cout<<"b："<
 return 0;
}

可以看到，运行结果根本没有交换a，b的值，因为在swap里面的a和b与在mian函数里面输入的a和b地址都不一样，根本就不是同一个变量！所以这样的交换数据的函数根本不是一个可以成功交换的函数，他其实是重新定义了两个int类型变量，只是值与a和b相等，所以值传递并不能达到修改变量的作用，

可以看到当我们在调用函数时传入参数，但是不想改变（非本愿）传入的变量的值时，我们可以采用值传递的形参定义方式

2、指针传递

相比较于值传递，指针传递又是另外一个方法，指针变量指向的是这个变量存储的内存位置，即指针变量指向内存地址，这个指针变量存储在另一个内存中，通过这个指针，我们可以修改这个指针指向的地址位置的变量数值，对于上面的两数交换的数据，我们就可以用指针传递的形式达到交换两个数据的效果

修改代码如下

#include<iostream>
using namespace std;
void swaps(int *p,int *q){
  cout<<"Function swaps Point p Address:"<<&p<<endl;
 cout<<"Function swaps Point q Address:"<<&q<<endl;
 int temp = *p;
 *p = *q;
 *q = temp;
}
int main(){
 int a,b;
 cin>>a>>b;
 int *p=&a,*q=&b;
 cout<<"Point p Address:"<<&p<<endl;
 cout<<"Point q Address:"<<&q<<endl;
 cout<<"a:"<<a<<endl;
 cout<<"b:"<<b<<endl;
 swaps(p,q);
 cout<<"a:"<<a<<endl;
 cout<<"b:"<<b<<endl;
}

从运行结果可以看到，达到了一个交换的效果，以指针的形式，但是可以看到传入的指针跟mian函数里面定义的指针也是不一样的！其实指针传递可以理解为另类的值传递，传递的指针参数也是一个变量类型，在这种swap函数的修改其实是对指针变量指向的内存地址里面的值进行修改，即main函数里面变量a和b的地址里面的值进行修改，也就可以理解为修改了a和b里面的值,这里可以用一张图表明

3、引用传递

引用传递其实是跟地址传递具有相同的效果，但是，唯一的区别是引用变量一旦定义，里面的指向的地址位置是不能修改的，相当于*const p

代码实现

#include<iostream>
using namespace std;
void swaps(int &p,int &q){
  cout<<"Function swaps a Address:"<<&p<<endl;
 cout<<"Function swaps b Address:"<<&q<<endl;
 int temp = *p;
 *p = *q;
 *q = temp;
}
int main(){
 int a,b;
 cin>>a>>b;
 cout<<"a Address:"<<&a<<endl;
 cout<<"b Address:"<<&b<<endl;
 cout<<"a:"<<a<<endl;
 cout<<"b:"<<b<<endl;
 swaps(a,b);
 cout<<"a:"<<a<<endl;
 cout<<"b:"<<b<<endl;

可以看到引用变量传入的值就是mian函数里面的a和b，地址是一样的

4、数组传递

一维数组

数组的传递其实就是指针的传递，当然在C++的STL中有一个可以代替数组的更安全的类型array（这里不考虑),对于c++中的数组类型，其实就是一个指针类型,比如说定义一个数组int a[],这里a就是指向a[0]的指针，要获得a[1],只需要a++即可

//打印数组

void prints1(int a[],int len){
 for(int i=0,i<len;i++){
     printf("%d\t",a[i]);
 }
 printf("\n");
}
void prints2(int *a,int len){
 for(int i=0,i<len;i++){
     printf("%d\t",*a);
     a++;
 }
 printf("\n");
}

//这两个方法感觉都是指针传递，因为他们都能修改传入的原数组的值

int main(){
 int a[3] = {1,2,3};
 prints1(a,3);
 prints2(a,3);
 return 0;
}

可以看到***a和a[]**其实没有区别

二维数组

二位数组其实也没啥，也就是按照一维数组的思想，但是人为的规定了一些限制，因为二维数组数据在内存中是顺序条状存储的，即从1到n个连续的内存位置，存储的是二位数组，计算机才不会管你的几行几列，它只知道只有顺序存储和链式存储之所以有二位数组，是人为的规定了，比如1到多少个内存位置是第一行…，既然这样，同样可以用一个*p来访问二位数组 ,于此同时也可以用双指针（或者说行指针）来访问二位数组

采用一维指针的方式访问

void PrintDoubleArray(int *p,int row,int lie){
  for(int i = 0;i<row;i++){
  for(int j = 0;j<lie;j++){
      printf("%d\t",*p);
      p++;
  }
  printf("\n");
}
}

采用二维数组的形式访问

void PrintDoubleArray1(int p[][3],int row,int lie){
for(int i=0;i<row;i++){
  for(int j=0;j<lie;j++){
      printf("%d\t",p[i][j]);
  }
  printf("\n");
}
}

采用行指针的形式访问

void PrintDoubleArray2(int (*p)[3],int row,int lie){
for(int i=0;i<row;i++){
  for(int j=0;j<lie;j++){
      printf("%d\t",*((*p+i)+j));
  }
  printf("\n");
}

这三个方法都能够打印出二维数组，但是他们的定义放方式不同

一个是采用以为数组，即把二维数组当作一个长一点的一维数组，用指针往后自增来遍历二维数组中的每一个元素

另一个是采用索引的方法a[i][j]的形式，来访问二位数组中的每一个元素，但是形式参数的第二个[]里面必须有一个常数，即你传入的二维数组的列数必须是跟形式参数一样的，否则无法传递

第三个是以行指针的形式，他的访问方式如下

分类表示方法备注

行指针 p+i, *p[i] 下标为第i行的指针

元素指针 *(p+i)+j, p[i]+j 第i行第j列的元素指针

元素 ((p+i)+j), *(p[i]+j) 第i行第j列的元素

测试代码，分别用上面三种传值方法输出二维数组

int main(){
    int a[][3]={{1,2,3},{2,3,4},{3,2,5},{1,5,1}};
    int *p = &a[0][0];
    PrintDoubleArray(p,4, 3);
    cout<<endl;
    PrintDoubleArray1(a,4,3);
    cout<<endl;
    PrintDoubleArray2(a,4,3);
    return 0;
 }

可以看到得到的结果是一样的

5、为参数默认值

在函数中，除了传递变量之外，还可以为设置的形式参数设置默认值，当一个参数具有默认值时，调用其时可以不需要传入该形式参数

比如一个函数中的某些参数，我们没有传入时，他是他执行默认的方法，比如一个时间显示器，我们需要传入的参数为时区，当我们没有传入时区时，默认的为北京时间，就显示一个北京时间

void showTime(int opt = 1){
 switch(opt){
     case 1:{
         cout<<"BeJing time:"<<"xxxx.xx.xx.xx\n";
         break;
     }
     case 2:{
         cout<<"NewYork time:"<<"xxxx.xx.xx.xx\n";
         break;
     }
 }
}

然后测试一下

int main(){
 int des = 2;
  showTime();
 showTime(des);
 return 0;
}

可以看到，当没有传入参数时，这个方法将调用形式参数opt的默认值1进行处理，否则按照传入参数进行处理

6、函数的重载

函数的重载的意思即为相同的函数名实现不同的功能，一个相同的函数名他的参数数量，返回类型又可以不同，用来实现其他的功能

比如我们设计一个比较两个变量的大小的函数，可看到

bool compare(int a,int b){
 return a>b;
}
bool compare(double a,double b){
  return a>b;
}
bool compare(float a,float b){
 return a>b;
}

可以看到，函数名是相同的，但是参数的类型是不同的，他们都实现了一个比较的函数，为了简化上面的代码，我们可以用函数模板来写这个函数，函数模板会在后面介绍，再打个比方，一个物体是有面积的，但是对于不同的物体，传入的参数和求面积的方式是不同的

void area(int r){//求圆的面积
 cout<<"The area of Circle is:"<<3.14*r*r;
}
void area(int a,int b){//求矩形的面积
 cout<<"The area of Rectangle is:"<<a*b;
 }

可以看到上面的函数定义中，一个area函数能有不同的求面积的方法，参数的数量和类型可以不同，即相同的函数名可以实现很多的方法

7、函数模板

对于上面的compare函数，要实现不同的比较方法，需要重新写很多份代码，这样大大加大了代码的冗余度，为了解决这个问题，其实c++是有一个函数模板编程方法的，即起始我们不知道这个形式参数的具体类型是什么，而是在程序运行的时候将特定的变量代替这个模型，定义的格式为

template //T是一个起初未知的模板类型

bool compare(T a,T b){

return a>b;

}

template<typename T> //T是一个起初未知的模板类型
bool compare(T a,T b){
 return a>b;
}

我们并不知道T的具体类型是什么样子的，但是这样的话可以大大地减少代码的冗余度，这个变量类型T只有在实际的编译运行过程中根据用户的输入变量类型来替代，但是T不能是所有的变量类型，它也是有限制的，是根据代码来确定适配范围的，如果一个类型没有重载>这个运算符，这种类型传入无法比较大小，这是程序运行的过程中是会报错的

8、内联函数和constexpr函数

内联函数

在程序的运行中，一次函数的调用远非我们想象的只是执行几行语句那么简单，假设有这么一个函数

string& shortString(const string &st1,const string &st2){
 return st1.size()>st2.size()?st2:st1;
}

//这个函数的意思即为返回两个字符串中长度较小的字符串的引用类型

在shortString函数执行的过程中，并不是简单的return st1.size()>st2.size()?st2:st1;在执行这句话之前，还有着一系列的操作，比如将方法入口拷贝到寄存器，并且在返回时恢复，或者需要拷贝实参，返回返回值…，需要经历一系列的操作之后，上面那一句话只是这一系列操作的一部分，那么对于这些十分简单的函数语句描述，可以用内联函数来实现，内联函数能够避免函数调用的额外开销，将函数指定为内联函数，通常是在每个调用点的内联地址展开，而无需前面的这么多步操作
，定义内联函数十分简单，只需要在返回值前面加一个inline即可,上面的方法改为内联为
inline string& shortString(const string &st1,const string &st2){
    return st1.size()>st2.size()?st2:st1;
}
cout<<shortString(st1,st2)<<endl;
//其实在编译的的过程中变相的执行了
cout<<(st1.size()>st2.size()?st2:st1)<<endl;

需要注意的是

内联函数只是一个声明，至于在编译的过程中编译器是否把这个函数当作内联函数还得看编译器的想法，即有时候我们可能觉得这个函数是内联函数，但是编译器在编译的过程中并不这样认为
内联机制只适用于语句少，代码体简单的函数，如果函数比较复杂的话，inline就没有作用了
constexpr函数
constexpr函数是指能用于常量表达式的函数，即返回值可以是字面值常量，使用constexpr需要注意
返回值和形式参数都必须是字面值类型
函数体中有且只有一条return语句
constexpr int new_fun(){return 42;} //一个constexpr函数
constexpr int foo = new_fun(); //一个正确的常量表达式

9、函数的指针

函数指针也是函数调用中的一个方法，可以把函数想象成一个变量，那么对于函数也可以存在指针，函数指针指向某种特定的类型，函数的类型由他的返回值和形参类型共同决定，与函数名无关

**定义函数指针

返回类型 (指针名)(形参列表); //函数指针的定义

//比如对于前面定义的函数shortStirng

string& (st)(const string &st1,const string& st2);//未初始化

、

初始化函数指针

st = shortString; //st指向名为shortString的函数
st = &shortString; //等价赋值语句：取地址符可选

使用函数指针

string s1 = st("abc","defs"); //调用shortString函数
string s2 = (*st)("abc","defs");//等价的调用
string s3 = shortString("abc","defs");

定义的函数指针必须指向返回类型和形参类型和数量相同的函数,当函数指针为空时可以给他定义为nullptr或者0

string::size_type sunLength(const string &,const string &);
bool cstringCompare(const char *,const char*);
pf = nullptr; //空指针
pf = 0; //也是空指针的意思
pf = sunLength;//错误--返回类型不同
pf = cstringCompare; //错误--参数类型不匹配

函数和函数指针可以作为函数中的形式参数

函数和函数指针和数组有些类似，可以作为函数的形式参数

void funa(const string *st1,const string &st2,string& st(const string &,const string &)); //函数类型作为形参
void funb(const string *st1,const string &st2,string& (*st)(const string &,const string &));//函数指针类型作为形参，当以函数指针作为形参时，可以直接将函数名作为实参使用，编译器会将这个实参转换为函数指针类型
funb("abe","sdass",shortString);
用typedef和decltype用特定的名字代替函数指针和函数名

void a(){
}
//testfun1和testfun2都是函数类型
typedef bool testfun1();
typedef decltype(a) testfun2;
//testfun3和testfun4都是函数指针类型
typedef bool (*testfun3)();
typedef decltype(a) *testfun4;

//以函数指针作为形式参数
//等价的传值
void funa(testfun1); //testfun1 == bool testfun1()
void funb(testfun2); //testfun2 == void a()
void func(testfun3); //testfun3 == bool (*testfun3)()
void fund(testfun4); //testfun4 == void (*testfun4)() 即a函数的指针类型

返回指向函数的指针

using F = int (int*,int); //F是一个函数类型
using PF = int(*)(int*,int);//F是一个指针类型
PF f1();//正确--返回类型为PF指针的函数
F f2();//错误--函数不能返回一个函数，只能返回函数的指针
F *f3();//正确

C++学习必备——文章中含有源码