void function1(int x)
{
x=5;
}

void function2(int *x)
{
*x=5;
}
 
int main()
{
int a=0;
function1(a);
//此时a=0
/*因为调用时候，首先是执行int x=a的操作，函数里面依然是对x=5赋值，没有改变a
*/

function2(&a);
//此时a=5
/*因为调用时候，首先是执行int *x=&a的操作，函数里面是对a的地址里面的值修改为5，由于a变量地址是不会变的，所以a地址里存的被修改了，值也被修改了。
*/

 return 0;
}

实参直接作为参数传递给函数时候，函数会先将形参初始化，将实参的值传递给形参，进入函数里面后，依然是对形参进行修改。调用结束后，实参的值并没有修改

函数原型void function1(int x) {x=5; }

int a=0;function1(a)

翻译过程并不是直接把x用a替换，然后a=5,

而是先int x=a=0，然后x=5，这样调用完毕，x释放，但是a的值没有改变。
要想改变，可以用指针，

函数原型void function2(int *x) {*x=5;}

int a=0;function1(&a)

翻译过程就是首先将a的地址复制给x,然后*x=5，就是将这个地址里存的值改为5，因为a的地址不变，所以a的值被修改了

void Get_Value_2(unsigned int*data0,unsigned int *data1)
{
         //buf中数据长度
         unsignedshort buf_len = 0;
         //buf数据中值的位数
         unsignedshort buf_data_len = 0;
         unsignedshort buf_data_len_0 = 0;
         unsignedshort buf_data_len_1 = 0;
         
         
         unsignedchar i = 0;
         
         buf_len= Version_buf[2];
         buf_len<<= 8;
         buf_len|= Version_buf[1];
         
         buf_data_len= buf_len - 1 - 5;
         
         buf_data_len_0= 0;
         for(i= 0;i< buf_data_len;i++)
         {
                   if(Version_buf[8+i]!= 0x2C)
                            buf_data_len_0++;
                   else
                            break;
         }
         //总的长度减去逗号1个字符
         buf_data_len_1= buf_data_len - buf_data_len_0 - 1;
         
         *data0= 0;
         for(i= 0;i< buf_data_len_0;i++)
         {
                   *data0+= (Version_buf[8+i]-0x30)*pow(10,buf_data_len_0 - 1 -i);
         }
         
         *data1= 0;
         for(i= 0;i< buf_data_len_1;i++)
         {
                   *data1+= (Version_buf[8+buf_data_len_0+1+i]-0x30)*pow(10,buf_data_len_1 - 1 -i);
         }
}
 
 
妙哉。。。
因为不止一个参数，不能用return的方式返回。
同时，若用全局变量的方式，则只能用于传递同一组参数。若采用指针传递方式，则可实现传递两个参数，并具有通用性。。。
 

python中函数参数是引用传递（不是值传递）。对于不可变类型，因变量不能被修改，所以运算时不会影响到变量本身；而对于可变类型来说，函数体中的运算有可能会更改传入的参数变量.


形参： 函数需要传递的参数
实参：调用函数时传递的参数

c语言我们都知道形参不能改变实参，实参能改变形参，我们能保证自己很熟悉这个概念吗，能不能保证自己每次都不犯错，掉坑里。

#include <iostream.h>

#include <string.h>

void fun( char *s)

{

char a[10];

strcpy ( a, “AAAAAA” );

cout<<“形参未改变，实参传递给实参的值：”<<s<<endl;

s=a;

cout<<"形参改变后字符串后的值：        "<<s<<endl;

}

main( )

{

char *p= “BBBBBB” ;

fun( p );

cout<<"实参在形参被改变后的值：        "<<p<<endl;

}

这是我自己写的实参改变形参的一段代码，末尾我会附上运行截图

在谈论这个问题前先明确几个概念
形参是什么？

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
实参是什么？

实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使实参获得确定值。
要实现调用函数，形参传递到实参要注意的事项有哪些？
实参的类型，数量定义的顺序都是不能改变的，这样才能调用，不然会出现不匹配错误，比如定义一个函数

void  ss(int a,char c) //a和c就是形参

我们在调用的时候就要提前定义实参，严格按照  整形，字符型的顺序才能调用

int f;

char v;

ss(f,v)；//f和v就是实参

参数的传递方向是单向的，只能从实参传到形参（不要妄想形参反客为主改变实参，那是不可能的，之后用代码进一步证明）
附上我写的字符串复制的例子，感兴趣的话可以自己实践一下，也可以复制我的操作一下
简单解释一下我的这个指针指向的例子

实参p是字符型指针，赋给初始值为BBBBBB，然后利用函数，形参为字符型指针s，形参改变实参的证明就是我们没给s赋初值但是初始值为实参的值，这里输出BBBBBB，所以实参改变了形参；
s初始值和实参一样为BBBBBB，我们这里继续改变形参的值，改为AAAAAA，输出，发现形参s改变成AAAAAA；
我们都知道C语言是从上到下按顺序执行的，我们在main函数调用函数后来看一下有没有通过改变形参的值改变了实参，输出实参p,实际上没有改变，实参p的值依然是BBBBBB,所以实参并没有受到改变；
本人很菜，有什么不完全或者有误的地方请指出，有问题请留言或者私聊我，写作不易，有帮助的话请留下一个赞，谢谢。

附上我的运行截图帮助理解：