精华内容
下载资源
问答
  • 【C++ - 18】C++函数参数传递三种方式

    万次阅读 多人点赞 2014-05-28 10:04:52
    当进行函数调用的时候,要填入与函数形式参数个数相同的实际参数,在程序运行的过程中,实参会将参数值传递给形参,C++函数参数传递有以下三种方式。 一. 值传递 1. 利用值传递方式,实际上是把实参的内容复制到...

     

           当进行函数调用的时候,要填入与函数形式参数个数相同的实际参数,在程序运行的过程中,实参会将参数值传递给形参,C++函数参数传递有以下三种方式。

     

    一. 值传递

    1. 利用值传递方式,实际上是把实参的内容复制到形参中,实参和形参是存放在两个不同的内存空间中。在函数体内对形参的一切修改对实参都没有影响

    2. 如果形参是类的对象,利用值传递的话每次都要调用类的构造函数构造对象,效率比较低

    3. 看下面这个例子

     

    #include<iostream>
    #include<algorithm>
    using namespace std;
    
    class Node{
    public:
    	Node(){}
    private:
    	int value;
    };
    
    //形参是内置数据类型
    void Fun(int a){
    	cout<<"形参a的地址 = "<<&a<<endl;
    }
    
    //形参是类的对象
    void Fun(Node node){
    	cout<<"形参node的地址 = "<<&node<<endl;
    }
    
    int main(){
    	//内置数据类型
    	int a = 10;
    	cout<<"实参a的地址 = "<<&a<<endl;
    	Fun(a);
    	//数据类型是类
    	Node node;
    	cout<<"实参node的地址 = "<<&node<<endl;
    	Fun(node);
    
    	return 0;
    }
    


    输出结果如下

     

    说明形参和实参确实是存放在两个不同的内存单元中

     

    二. 指针传递(地址传递)

    1. 当进行指针传递的时候,形参是指针变量,实参是一个变量的地址或者是指针变量,调用函数的时候,形参指向实参的地址。

    2. 指针传递中,函数体内可以通过形参指针改变实参地址空间的内容。

    3. 看下面例子

     

    //指针传递
    void swap(int *a, int *b){
    	cout<<"形参指针a的地址 = "<<a<<endl;
    	cout<<"形参指针b的地址 = "<<b<<endl;
        int tmp = *a;
    	*a = *b;
    	*b = tmp;
    }
    
    int main(){
    	int a = 5;
    	int b = 10;
    	cout<<"实参变量a的地址 = "<<&a<<endl;
    	cout<<"实参变量b的地址 = "<<&b<<endl;
    	cout<<"实参变量a的值 = "<<a<<endl;
    	cout<<"实参变量b的值 = "<<b<<endl;
    	//调用函数,指针传递方式
    	swap(&a, &b);
    	cout<<"实参变量a的值 = "<<a<<endl;
    	cout<<"实参变量b的值 = "<<b<<endl;
    	getchar();
    	return 0;
    }
    


    输出结果

     

    说明指针传递的过程中, 确实是把实参的地址传递给形参,通过形参指针确实可以更改实参指向的内存空间的值。

     

    三. 传递引用

    1. 引用实际上是某一个变量的别名,和这个变量具有相同的内存空间。 

    2. 实参把变量传递给形参引用,相当于形参是实参变量的别名,对形参的修改都是直接修改实参。

    3. 在类的成员函数中经常用到类的引用对象作为形参,大大的提高代码的效率

    4. 看以下例子

     

    //引用传递
    void Fun(int &a){
    	cout<<"形参引用a的地址 = "<<&a<<endl;
    	a = 100; //对形参引用进行修改
    }
    
    int main(){
    	int a = 10;
    	cout<<"实参a的地址 = "<<&a<<endl;
    	cout<<"实参a的值 = "<<a<<endl;
    	Fun(a);
    	cout<<"实参a的值 = "<<a<<endl;
    	getchar();
    	return 0;
    }
    

     

     

     

    输出结果

    说明,形参引用的修改会直接修改实参变量的值。建议采用传递引用的方式

     

     

    展开全文
  • C语言中函数参数传递三种方式

    万次阅读 多人点赞 2017-07-22 21:09:40
    C语言中函数参数传递三种方式(1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。(2)传址,就是传变量的地址...
    C语言中函数参数传递的三种方式

    (1)传值,就是把你的变量的值传递给函数的形式参数,实际就是用变量的值来新生成一个形式参数,因而在函数里对形参的改变不会影响到函数外的变量的值。
    (2)传址,就是传变量的地址赋给函数里形式参数的指针,使指针指向真实的变量的地址,因为对指针所指地址的内容的改变能反映到函数外,也就是能改变函数外的变量的值。
    (3)传引用,实际是通过指针来实现的,能达到使用的效果如传址,可是使用方式如传值。
    说几点建议:如果传值的话,会生成新的对象,花费时间和空间,而在退出函数的时候,又会销毁该对象,花费时间和空间。
    因而如果int,char等固有类型,而是你自己定义的类或结构等,都建议传指针或引用,因为他们不会创建新的对象。


    例1:下面这段代码的输出结果为:
    #include<stdio.h>
    void change(int*a, int&b, int c)
    {
          c=*a;
          b=30;
          *a=20;
    }
    int main ( )
    {
          int a=10, b=20, c=30;
          change(&a,b,c);
          printf(“%d,%d,%d,”,a,b,c);
          return 0;
     }
    结果:20  30  30


    解析:
    该题考察函数传参问题。
    1,指针传参 -> 将变量的地址直接传入函数,函数中可以对其值进行修改。
    2,引用传参 -> 将变量的引用传入函数,效果和指针相同,同样函数中可以对其值进行修改。
    3,值传参   -> 在传参过程中,首先将c的值复制给函数c变量,然后在函数中修改的即是函数的c变量,然后函数返回时,系统自动释放变量c。而对main函数的c没有影响。


    例2:
    #include<stdio.h>  
    void myswap(int x, int y)  
    {  
        int t;  
        t=x;  
        x=y;  
        y=t;  
    }  
    int main()  
    {  
        int a, b;  
        printf("请输入待交换的两个整数:");  
        scanf("%d %d", &a, &b);  
        myswap(a,b);  //作为对比,直接交换两个整数,显然不行  
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);  
        return 0;  
    }  
     
     
    #include<stdio.h>  
    void myswap(int *p1, int *p2)  
    {  
        int  t;  
        t=*p1;  
        *p1=*p2;  
        *p2=t;  
    }  
    int main()  
    {  
        int a, b;  
        printf("请输入待交换的两个整数:");  
        scanf("%d %d", &a, &b);  
        myswap(&a,&b);  //交换两个整数的地址  
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);  
        return 0;  
    }  
     
    #include<stdio.h>  
    void myswap(int &x, int &y)  
    {  
        int t;  
        t=x;  
        x=y;  
        y=t;  
    }  
      
    int main()  
    {  
        int a, b;  
        printf("请输入待交换的两个整数:");  
        scanf("%d %d", &a, &b);  
        myswap(a,b);  //直接以变量a和b作为实参交换  
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);  
        return 0;  
    }  
    第一个的运行结果:输入2 3,输出2 3 
    第二个的运行结果:输入2 3,输出3 2
    第三个的运行结果:输入2 3,输出3 2

    解析:
    在第一个程序中,传值不成功的原因是指在形参上改变了数值,没有在实参上改变数值。
    在第二个程序中,传地址成功的原因利用指针改变了原来的地址,所以实参就交换了。

    在第三个程序中,引用是直接改变两个实参变量a,b的值,所以就交换了。

    下文会通过例子详细说明关于值传递,指针传递,引用传递 

      1)值传递:

        形参是实参的拷贝,改变形参的值并不会影响外部实参的值。从被调用函数的角度来说,值传递是单向的(实参->形参),参数的值只能传入,

    不能传出。当函数内部需要修改参数,并且不希望这个改变影响调用者时,采用值传递。

      2)指针传递:

        形参为指向实参地址的指针,当对形参的指向操作时,就相当于对实参本身进行的操作

      3)引用传递:

        形参相当于是实参的“别名”,对形参的操作其实就是对实参的操作,在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

        下面的代码对此作出了细致解释(从实参,形参在内存中存放地址的角度 说明了问题的本质,容易理解  )

     1 #include<iostream>
     2 using namespace std;
     3 //值传递
     4  void change1(int n){
     5     cout<<"值传递--函数操作地址"<<&n<<endl;         //显示的是拷贝的地址而不是源地址 
     6     n++;
     7 }
     8 
     9 //引用传递
    10 void change2(int & n){
    11     cout<<"引用传递--函数操作地址"<<&n<<endl; 
    12     n++;
    13 }
    14  //指针传递
    15 void change3(int *n){
    16      cout<<"指针传递--函数操作地址 "<<n<<endl; 
    17     *n=*n+1;
    18  } 
    19 int     main(){
    20     int n=10;
    21     cout<<"实参的地址"<<&n<<endl;
    22     change1(n);
    23     cout<<"after change1() n="<<n<<endl;
    24     change2(n);
    25     cout<<"after change2() n="<<n<<endl;
    26     change3(&n);
    27     cout<<"after change3() n="<<n<<endl;
    28     return true;
    29 }

    运行结果如下,(不同的机器可能会有所差别)

    可以看出,实参的地址为0x22ff44

        采用值传递的时候,函数操作的地址是0x22ff20并不是实参本身,所以对它进行操作并不能改变实参的值

    • 再看引用传递,操作地址就是实参地址 ,只是相当于实参的一个别名,对它的操作就是对实参的操作
    • 接下来是指针传递,也可发现操作地址是实参地址

        那么,引用传递和指针传递有什么区别吗?

      引用的规则: 
    引用被创建的同时必须被初始化(指针则可以在任何时候被初始化)。 

    • 不能有NULL引用,引用必须与合法的存储单元关联(指针则可以是NULL)。 
    • 一旦引用被初始化,就不能改变引用的关系(指针则可以随时改变所指的对象)。 

      指针传递的实质:

        指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的

        任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)如果理解不了大可跳过这段

      指针传递和引用传递一般适用于:

        函数内部修改参数并且希望改动影响调用者。对比指针/引用传递可以将改变由形参“传给”实参(实际上就是直接在实参的内存上修改,不像值传递将实参的值拷贝到另外的内存地址中才修改)。

        另外一种用法是:当一个函数实际需要返回多个值,而只能显式返回一个值时,可以将另外需要返回的变量以指针/引用传递给函数,这样在函数内部修改并且返回后,调用者可以拿到被修改过后的变量,也相当于一个隐式的返回值传递吧。

        以下是我觉得关于指针和引用写得很不错的文章,大家可参照看一下,原文出处地址:http://xinklabi.iteye.com/blog/653643 

        从概念上讲。指针从本质上讲就是存放变量地址的一个变量,在逻辑上是独立的,它可以被改变,包括其所指向的地址的改变和其指向的地址中所存放的数据的改变。

        而引用是一个别名,它在逻辑上不是独立的,它的存在具有依附性,所以引用必须在一开始就被初始化,而且其引用的对象在其整个生命周期中是不能被改变的(自始至终只能依附于同一个变量)。

        在C++中,指针和引用经常用于函数的参数传递,然而,指针传递参数和引用传递参数是有本质上的不同的:

        指针传递参数本质上是值传递的方式,它所传递的是一个地址值。值传递过程中,被调函数的形式参数作为被调函数的局部变量处理,即在栈中开辟了内存空间以存放由主调函数放进来的实参的值,从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行,不会影响主调函数的实参变量的值。(这里是在说实参指针本身的地址值不会变)

    而在引用传递过程中,被调函数的形式参数虽然也作为局部变量在栈中开辟了内存空间,但是这时存放的是由主调函数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址,即通过栈中存放的地址访问主调函数中的实参变量。正因为如此,被调函数对形参做的任何操作都影响了主调函数中的实参变量。

        引用传递和指针传递是不同的,虽然它们都是在被调函数栈空间上的一个局部变量,但是任何对于引用参数的处理都会通过一个间接寻址的方式操作到主调函数中的相关变量。而对于指针传递的参数,如果改变被调函数中的指针地址,它将影响不到主调函数的相关变量。如果想通过指针参数传递来改变主调函数中的相关变量,那就得使用指向指针的指针,或者指针引用。

    为了进一步加深大家对指针和引用的区别,下面我从编译的角度来阐述它们之间的区别:

    程序在编译时分别将指针和引用添加到符号表上,符号表上记录的是变量名及变量所对应地址。指针变量在符号表上对应的地址值为指针变量的地址值,而引用在符号表上对应的地址值为引用对象的地址值。符号表生成后就不会再改,因此指针可以改变其指向的对象(指针变量中的值可以改),而引用对象则不能修改。

    最后,总结一下指针和引用的相同点和不同点:

      1)相同点:

    • 都是地址的概念;

    指针指向一块内存,它的内容是所指内存的地址;而引用则是某块内存的别名。

      2)不同点:

    • 指针是一个实体,而引用仅是个别名;
    • 引用只能在定义时被初始化一次,之后不可变;指针可变;引用“从一而终”,指针可以“见异思迁”;
    • 引用没有const,指针有const,const的指针不可变;(具体指没有int& const a这种形式,而const int& a是有     的,  前者指引用本身即别名不可以改变,这是当然的,所以不需要这种形式,后者指引用所指的值不可以改变)
    • 引用不能为空,指针可以为空;
    • “sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身的大小;
    • 指针和引用的自增(++)运算意义不一样;
    • 引用是类型安全的,而指针不是 (引用比指针多了类型检查)
    复制代码
    一、引用的概念
    
    引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似,只是用&代替了*。
    例如: Point pt1(10,10);
    Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义,pt1和pt2表示同一对象。
    需要特别强调的是引用并不产生对象的副本,仅仅是对象的同义词。因此,当下面的语句执行后:
    pt1.offset(22);
    pt1和pt2都具有(1212)的值。
    引用必须在定义时马上被初始化,因为它必须是某个东西的同义词。你不能先定义一个引用后才
    初始化它。例如下面语句是非法的:
    Point &pt3;
    pt3=pt1;
    那么既然引用只是某个东西的同义词,它有什么用途呢?
    下面讨论引用的两个主要用途:作为函数参数以及从函数中返回左值。 
    
    二、引用参数
    
    1、传递可变参数
    传统的c中,函数在调用时参数是通过值来传递的,这就是说函数的参数不具备返回值的能力。
    所以在传统的c中,如果需要函数的参数具有返回值的能力,往往是通过指针来实现的。比如,实现
    两整数变量值交换的c程序如下:
    一、引用的概念
    
    引用引入了对象的一个同义词。定义引用的表示方法与定义指针相似,只是用&代替了*。
    例如: Point pt1(10,10);
    Point &pt2=pt1; 定义了pt2为pt1的引用。通过这样的定义,pt1和pt2表示同一对象。
    需要特别强调的是引用并不产生对象的副本,仅仅是对象的同义词。因此,当下面的语句执行后:
    pt1.offset(2,2);
    pt1和pt2都具有(12,12)的值。
    引用必须在定义时马上被初始化,因为它必须是某个东西的同义词。你不能先定义一个引用后才
    初始化它。例如下面语句是非法的:
    Point &pt3;
    pt3=pt1;
    那么既然引用只是某个东西的同义词,它有什么用途呢?
    下面讨论引用的两个主要用途:作为函数参数以及从函数中返回左值。 
    
    二、引用参数
    
    1、传递可变参数
    传统的c中,函数在调用时参数是通过值来传递的,这就是说函数的参数不具备返回值的能力。
    所以在传统的c中,如果需要函数的参数具有返回值的能力,往往是通过指针来实现的。比如,实现
    两整数变量值交换的c程序如下:
    void swapint(int *a,int *b)
    {
    int temp;
    temp=*a;
    a=*b;
    *b=temp;
    }
    
    使用引用机制后,以上程序的c++版本为:
    void swapint(int &a,int &b)
    {
    int temp;
    temp=a;
    a=b;
    b=temp;
    }
    调用该函数的c++方法为:swapint(x,y); c++自动把x,y的地址作为参数传递给swapint函数。
    
    2、给函数传递大型对象
    当大型对象被传递给函数时,使用引用参数可使参数传递效率得到提高,因为引用并不产生对象的
    副本,也就是参数传递时,对象无须复制。下面的例子定义了一个有限整数集合的类: 
    const maxCard=100; 
    Class Set 
    {
    int elems[maxCard]; // 集和中的元素,maxCard 表示集合中元素个数的最大值。 
    int card; // 集合中元素的个数。 
    public:
    Set () {card=0;} //构造函数
    friend Set operator * (Set ,Set ) ; //重载运算符号*,用于计算集合的交集 用对象作为传值参数
    // friend Set operator * (Set & ,Set & ) 重载运算符号*,用于计算集合的交集 用对象的引用作为传值参数 
    ...
    }
    先考虑集合交集的实现
    Set operator *( Set Set1,Set Set2)
    {
    Set res;
    for(int i=0;i<Set1.card;++i)
    for(int j=0;j>Set2.card;++j)
    if(Set1.elems[i]==Set2.elems[j])
    {
    res.elems[res.card++]=Set1.elems[i];
    break;
    }
    return res;
    }
    由于重载运算符不能对指针单独操作,我们必须把运算数声明为 Set 类型而不是 Set * 。
    每次使用*做交集运算时,整个集合都被复制,这样效率很低。我们可以用引用来避免这种情况。
    Set operator *( Set &Set1,Set &Set2)
    { Set res;
    for(int i=0;i<Set1.card;++i)
    for(int j=0;j>Set2.card;++j)
    if(Set1.elems[i]==Set2.elems[j])
    {
    res.elems[res.card++]=Set1.elems[i];
    break;
    }
    return res;
    }
    
    三、引用返回值
    
    如果一个函数返回了引用,那么该函数的调用也可以被赋值。这里有一函数,它拥有两个引用参数并返回一个双精度数的引用:
    double &max(double &d1,double &d2)
    {
    return d1>d2?d1:d2;
    }
    由于max()函数返回一个对双精度数的引用,那么我们就可以用max() 来对其中较大的双精度数加1:
    max(x,y)+=1.0;

    展开全文
  • 结构作为函数参数三种传递方式

    千次阅读 2019-05-06 22:12:37
    结构作为函数参数三种传递方式 ====================================== - 结构作为函数参数三种方式 1.传递结构成员 2.传递结构 3.传递结构的地址 =================================== //1.传递...

    结构作为函数参数的三种传递方式

    ======================================
    - 结构作为函数参数的三种方式

    • 1.传递结构成员
    • 2.传递结构
    • 3.传递结构的地址
      ===================================
    //1.传递结构成员
    #include <stdio.h>
    #include <stdlib.h>
    
    //花呗还款简单举例
    struct account
    {
        char * bankName;    //银行名称
        char * userName;    //用户名称
        double limit;       //账户当前可用额度
        double max;         //账户总额度
    };
    
    //计算并返回当月应还款数
    double payFor(double m1,double m2)
    {
        return m2-m1;
    }
    
    int main()
    {
        //初始化数据
        struct account BOC;
        BOC.bankName="中国银行";
        BOC.userName="马小云";
        BOC.max=10000;
        BOC.limit=1562;
        double result=payFor(BOC.limit,BOC.max);
        printf("用户应还款%.2lf元,截至下月9日之前不算利息!\n",result);
    }
    
    
    //2.传递结构
    //结构体定义不变,后面照下面修改
    //计算并返回当月应还款数
    double payFor(struct account accounts)
    {
        return accounts.max-accounts.limit;
    }
    
    int main()
    {
        //初始化数据
        struct account BOC;
        BOC.bankName="中国银行";
        BOC.userName="马小云";
        BOC.max=10000;
        BOC.limit=1562;
        double result=payFor(BOC);
    
        printf("用户应还款%.2lf元,截至下月9日之前不算利息!\n",result);
    }
    
    //3.传递结构的地址	
    //计算并返回当月应还款数
    double payFor(const struct account *accounts)    //因为指针指向可以改变,所以此处加上const起保护作用。
    {
        return accounts->max-accounts->limit;
    }
    
    int main()
    {
        //初始化数据
        struct account BOC;
        BOC.bankName="中国银行";
        BOC.userName="马小云";
        BOC.max=10000;
        BOC.limit=1562;
        double result=payFor(&BOC);
    
        printf("用户应还款%.2lf元,截至下月9日之前不算利息!\n",result);
    }
    

    运行结果都如下图:

    在这里插入图片描述

    展开全文
  • C/C++语言中函数参数传递三种方式(x,*x,&x)

    万次阅读 多人点赞 2018-09-08 22:02:45
    先看三种方式实现函数参数传递的实例程序 * 输入描述:两个待交换的整数 * 程序输出:交换后得两个整数 #include<stdio.h> void myswap(int x, int y) { int t; t=x; x=y; y=t; } int main() { int a...

    先看三种方式实现函数中参数传递的实例程序
    * 输入描述:两个待交换的整数
    * 程序输出:交换后得两个整数

    #include<stdio.h>  //C语言中的输入输出库
    void myswap(int x, int y)
    {
        int t;
        t=x;
        x=y;
        y=t;
    }
    int main()
    {
        int a, b;
        printf("请输入待交换的两个整数:");
        scanf("%d %d", &a, &b);
        myswap(a,b);  //作为对比,直接交换两个整数,显然不行
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);
        return 0;
    }
    #include<stdio.h>   //C语言中的输入输出库
    void myswap(int *p1, int *p2)
    {
        int  t;
        t=*p1;
        *p1=*p2;
        *p2=t;
    }
    int main()
    {
        int a, b;
        printf("请输入待交换的两个整数:");
        scanf("%d %d", &a, &b);
        myswap(&a,&b);  //交换变量a和变量b的地址中的内容
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);
        return 0;
    }
    #include<stdio.h>  //C语言中的输入输出库
    void myswap(int &x, int &y) //这里的形参为引用类型,引用与实参进行绑定,作为实参的别名
    {                           //所以,使用引用类型,传入实参后,函数对引用的操作,
        int t;                  //就是对实参的操作,所以实参会发生变化                
        t=x;
        x=y;
        y=t;
    }
    
    int main()
    {
        int a, b;
        printf("请输入待交换的两个整数:");
        scanf("%d %d", &a, &b);
        myswap(a,b);  //直接以变量a和b作为实参交换
        printf("调用交换函数后的结果是:%d 和 %d\n", a, b);
        return 0;
    }

    第一个的运行结果:
    这里写图片描述
    第二个的运行结果:
    这里写图片描述
    第三个的运行结果:
    这里写图片描述

    知识点总结:

    在第一个程序中,传值不成功的原因是指在形参上改变了数值,没有在实参上改变数值。

    在第二个程序中,传地址成功的原因利用指针改变了原来的地址,所以实参就交换了。

    在第三个程序中,引用是直接改变两个实参变量a,b的值,所以就交换了。

          这里的形参为引用类型,引用与实参进行绑定,作为实参的别名。

          所以,使用引用类型,传入实参后,函数对引用的操作,就是对实参的操作,所以实参会发生变化。

    展开全文
  • 函数参数三种传递方式的区别

    千次阅读 2017-01-07 13:47:00
    问题提出:1、当一个类的对象作为实参数传递时,使用值传递和引用传递有什么区别? 比如: DateType ExampleFun(CString &strFileName,…)与 DateType ExampleFun(CString strFileName,…)解答之前,我们先来看2...
  • 函数传递参数三种方式,以及它们的区别 1.按值传递(pass by value) 使用这种方式,调用函数本省不对实参进行操作,也就是说,即使形参的值在函数中发生了变化,实参 的值也完全不会受到影响,仍为...
  • 问题描述:函数参数传递三种表示方式 输入描述:输入两个整数 程序输出:调换位置 #include void myswap(int x, int y) {  int t;  t=x;  x=y;  y=t; } int main() {  int a,
  • 3种函数参数传递方式

    千次阅读 2014-11-23 14:50:54
    3种函数参数传递方式 1. 将变量名作为形参和实参 在这种情况下传给形参的是变量的值。传递是单向的,即如果在执行函数期间形参的值发生变化,并不传回给实参,这就是值传递方式。因为在调用函数期间,形参和实参...
  • 1 函数参数传递的3种方式比较 1 按值传递 #include using namespace std; void swap(int,int); int main() { int a=10,b=20; swap(a,b); cout cout return 0; } //按值传递的只是系统变量中的副本,...
  • 函数参数传递的两种方式——值传递和引用传递

    万次阅读 多人点赞 2018-10-23 15:50:05
    传递包括实实在在的值传递以及指针传递(指针传递参数本质上是值传递方式,它所传递的是一个地址值),传递的都是实参的一个拷贝。 1、实实在在的“值”传递 #include &lt;iostream&gt; #include &...
  • C\C++中函数参数三种传递方式

    千次阅读 2018-07-16 09:07:30
    这种传递方式中,实参和形参是两个不同的地址空间,参数传递的实质是将原函数中变量的值,复制到被调用函数形参所在的存储空间中,这个形参的地址空间在函数执行完毕后,会被回收掉。整个被调用函数对形参的操作,只...
  • 函数参数的两种传递方式

    千次阅读 2020-03-27 19:02:11
    当调用函数时,有两函数传递参数方式: 一、传值调用 该方法把参数的实际值复制给函数的形式参数。在这种情况下,修改函数内的形式参数不会影响实际参数。 默认情况下,C 语言使用传值调用方法来传递参数。...
  • C++中函数调用时的三种参数传递方式详解

    万次阅读 多人点赞 2017-08-31 20:44:51
    原文地址:http://blog.csdn.net/cocohufei/article/details/6143476;  ...   在C++中,参数传递方式是“实虚结合”。 按值传递(pass by value) 地址传递(pass by pointer) 引用传递(pass b...
  • 先看三种方式实现函数参数传递的实例程序 * 输入描述:两个待交换的整数 * 程序输出:交换后得两个整数#include&lt;stdio.h&gt; void myswap(int x, int y) { int t; t=x; x=y; y=t; } int main() {...
  •  在定义函数函数括号中的变量名成为形式参数,简称形参或虚拟参数;在主调函数中调用一个函数时,该函数括号中的参数名称为实际参数,简称实参,实参可以是常量、变量或表达式。 注意:  1、C语言中实参和形参...
  • 1)用寄存器(变量)传递参数, 在参数不多的时候采用这种方式(用的最多)。  附图实现的功能为串口发送ASCII码到上位机。,采用的就是寄存器传递参数方式。 2)用地址表传递参数  在主程序中建立一个地址表...
  • C++函数参数和返回值三种传递方式

    千次阅读 2011-02-21 11:11:00
    C++函数参数和返回值三种传递方式:值传递、指针传递和引用传递 (着重理解) 引用与指针的比较 引用是 C++中的概念,初学者容易把引用和指针混淆一起。一下程序中,n 是m 的 一个引用...
  • C++函数三种传递方式为:值传递、指针传递和引用传递传递:void fun(int x){ x += 5; //修改的只是y在栈中copy x,x只是y的一个副本,在内存中重新开辟的一块临时空间把y的值 送给了x;这样也增加了程序运行的...
  • 指针作为函数参数传递一维数组 C 语言中声明了一个数组TYPE array[n],则数组名称array 就有了两重含义: 第一,它代表整个数组,它的类型是TYPE[n];...因此,指针作为函数参数传递一维数组有4形式: #incl...
  • 64位函数参数传递方式

    万次阅读 2018-03-08 18:54:19
    64位函数传参方式
  • shell 函数传递参数的几种方式

    千次阅读 2019-06-27 19:31:00
    1.最近总结了shell中 function的传递变量的几种方式 1.传递单个变量 2.传递数组变量 #!/bin/bash #trying to pass an variable. function func() { echo "The number of parameters is: ${#}" for ...
  • 那么在脚本内部相当于把 test.sh param1 param2 看成参数出入,所以参数0为$0 (test.sh),参数1为$1 (parm1),参数2为$2 (parm2),也就是把脚本自己的名称看成参数0,参数个数$#还是2,而不是3,这个要注意。
  • php中函数参数传递

    千次阅读 2017-04-29 22:41:52
    php中函数参数传递有形参传递(借用c语言等编程语言的说法)。 即就是把变量的值赋值给函数的参数,对函数参数所做的一切操作都与原始变量无关。
  • Java函数参数传递方式详解

    万次阅读 2012-03-22 15:52:01
    在阅读本文之前,根据自己的经验和理解,大家可以先思考并选择一下Java函数参数传递方式:  A. 是按值传递的?  B. 按引用传递的?  C. 部分按值部分按引用?  此处暂不宣布正确答案,我们通过一个简单的...
  • VBA函数传递参数方式

    万次阅读 2018-03-04 20:58:03
    VBA函数传递参数值时分为...在VBA中,参数传递的默认方式是Byref,因为本质想法是对于相同命名的参数,在系统中采用同一个数值。 '获取非空行 Function GetNotNullRow(ByVal iStartRow, ByRef iRow) Dim Rng As Ran
  • Linux shell 函数传递参数的几种方式

    千次阅读 2019-03-30 12:55:51
    最近总结了 shell 中 function 的传递变量的几种方式 #1.传递单个变量 #2.传递数组变量 #!/bin/bash #trying to pass an variable. function func() { echo 'The number of parameters is: ${#}' for line in '$@' ...
  • python中函数参数传递的几方法

    万次阅读 2011-05-23 10:35:00
    python中函数参数传递的几方法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,176,764
精华内容 470,705
关键字:

函数参数传递的三种方式