**
直接调用
直接调用即在代码中调用函数，比如说addData()
嵌套调用
嵌套调用指的是，举一个例子，在a函数中会调用b函数，而在b函数中又调用了a函数
**
C++函数的传递个人感觉是一个十分骚气的操作，他的值传递不像Java这么简单，如果不了解c++的传值类型，可能有一些方法的调用得到的结果往往不是我们所想的那样
比如设计一个函数
**
//cout<<a<<endl; ==>> 1
//cout<<&a<<endl;==>> 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的值为：”<<a<<endl;
cout<<“b的值为：”<<b<<endl;
swaps(a,b);
cout<<“a的值为：”<<a<<endl;
cout<<“b的值为：”<<b<<endl;
return 0;
}
**
**
可以知道，每一个变量的定义都会在内存中对应一个地址，每一个地址是对应着特定的编号的，值即这个对应内存地址里面存储的数据，将值作为形式参数传入数组，比如上面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<<endl;
cout<<“Function Swap address_b is”<<&b<<endl;
int temp = a;
a = b;
b = temp;
}
int main(){
int a,b;
cin>>a>>b;
cout<<“Address_a”<<&a<<endl;
cout<<“Address_b”<<&b<<endl;
cout<<“a：”<<a<<endl;
cout<<“b：”<<b<<endl;
swaps(a,b);
cout<<“a：”<<a<<endl;
cout<<“b：”<<b<<endl;
return 0;
}
可以看到，运行结果根本没有交换a，b的值，因为在swap里面的a和b与在mian函数里面输入的a和b地址都不一样，根本就不是同一个变量！所以这样的交换数据的函数根本不是一个可以成功交换的函数，他其实是重新定义了两个int类型变量，只是值与a和b相等，所以值传递并不能达到修改变量的作用，
可以看到当我们在调用函数时传入参数，但是不想改变（非本愿）传入的变量的值时，我们可以采用值传递的形参定义方式
**
**
相比较于值传递，指针传递又是另外一个方法，指针变量指向的是这个变量存储的内存位置，即指针变量指向内存地址，这个指针变量存储在另一个内存中，通过这个指针，我们可以修改这个指针指向的地址位置的变量数值，对于上面的两数交换的数据，我们就可以用指针传递的形式达到交换两个数据的效果
修改代码如下
#include
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里面的值,这里可以用一张图表明
**
**
引用传递其实是跟地址传递具有相同的效果，但是，唯一的区别是引用变量一旦定义，里面的指向的地址位置是不能修改的，相当于*const p
代码实现
#include
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，地址是一样的
一维数组
数组的传递其实就是指针的传递，当然在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;
}
可以看到得到的结果是一样的
**
**
在函数中，除了传递变量之外，还可以为设置的形式参数设置默认值，当一个参数具有默认值时，调用其时可以不需要传入该形式参数
比如一个函数中的某些参数，我们没有传入时，他是他执行默认的方法，比如一个时间显示器，我们需要传入的参数为时区，当我们没有传入时区时，默认的为北京时间，就显示一个北京时间
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进行处理，否则按照传入参数进行处理
**
**
函数的重载的意思即为相同的函数名实现不同的功能，一个相同的函数名他的参数数量，返回类型又可以不同，用来实现其他的功能
比如我们设计一个比较两个变量的大小的函数，可看到
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.14rr;
}
void area(int a,int b){//求矩形的面积
cout<<“The area of Rectangle is:”<<a*b;
}
可以看到上面的函数定义中，一个area函数能有不同的求面积的方法，参数的数量和类型可以不同，即相同的函数名可以实现很多的方法
**
感谢每一个认真阅读我文章的人，看着粉丝一路的上涨和关注，礼尚往来总是要有的：
① 2000多本Python电子书（主流和经典的书籍应该都有了）
② Python标准库资料（最全中文版）
③ 项目源码（四五十个有趣且经典的练手项目及源码）
④ Python基础入门、爬虫、web开发、大数据分析方面的视频（适合小白学习）
⑤ Python学习路线图（告别不入流的学习）
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
200
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
