实参到形参的传递

研究问题:

  1. 函数调用时,实参传递到形参时的转换问题?

要点:
  • 参数的传递就是用实参初始化对应的形参。
    非引用形参:
    基本的情况:复制实参的值。函数并没有访问调用函数所传递的实参本身,所以不会改变实参的值。
    void swap(int x, int y)  
    {  
        int tmp;  
        tmp = x;  
        x = y;  
        y = tmp;  
    }  

    int main()  
    {  
        int a = 1,b = 2;  
        cout<<"a = "<<a<<"\t"<<"b = "<<b<<endl;  
        int* pa = &a;  
        int* pb = &b;  
        swap(a,b);  
        cout<<"a = "<<a<<"\t"<<"b = "<<b<<endl;  
        return 0;  
} 
  • 指针形参:此时将复制实参的指针:形参的改变不会引起实参的改变,但是形参指向的内容可以发生变化。
void swap(int *px, int *py)  
    {  
        int tmp;  
        tmp = *px;  
        *px = *py;  
        *py = tmp;  
    }  

    int main()  
    {  
        int a = 1,b = 2;  
        cout<<"a = "<<a<<"\t"<<"b = "<<b<<endl;  
        int *pa = &a;  
        int *pb = &b;  
        swap(pa,pb);  
        cout<<"a = "<<a<<"\t"<<"b = "<<b<<endl;  
        return 0;  
} 

  程序中,虽然pa始终指向a,pb始终指向b,但是a与b的值已发生了交换。
  

  • const形参:const实参可以传递给非const形参,因为初始化的复制规则:可以用const对象给非const对象复制。
    int plus(int x,int y)  
    {  
        return x+y;  
    }  
    int main()  
    {  
        const int a = 1;  
        const int b = 2;  
        int c = plus(a,b);  
        cout<<a<<"+"<<b<<"结果为"<<c<<endl;  
        return 0;  
}

   当然,使用const实参初始化const形参肯定是没有问题的。

    int plus(const int x,const int y)  
    {  
        return x+y;  
    }  
    int main()  
    {  
        const int a = 1;  
        const int b = 2;  
        int c = plus(a,b);  
        cout<<a<<"+"<<b<<"结果为"<<c<<endl;  
        return 0;  
} 
  • 反之,非const对象也可以传递给const形参,只要在程序中不改变形参的值即可:
    int plus(const int x,const int y)  
    {  
        return x+y;  
    }  
    int main()  
    {  
        int a = 1;  
        int b = 2;  
        int c = plus(a,b);  
        cout<<a<<"+"<<b<<"结果为"<<c<<endl;  
        return 0;  
}

   但是,如果你想在程序中修改形参的值,就会报错:

    int plus(const int x,const int y)  
    {  
        return (++x)+(++y);  
    }  
//  编译无法通过。

复制实参的不适合的情况:
1.需要在函数中修改实参的值
2.没有办法实现参数的复制(比如数组)
3.当使用大型对象作为参数传递时,复制对象付出的代价太大。

  • 引用形参:
    引用形参直接关联到所绑定的对象,而非对象的副本。此时形参只是实参的另一个名字,对形参的修改就意味着对实参的修改。
    void swap(int &x,int &y)  
    {  
        int tmp = x;  
        x = y;  
        y = tmp;  
    }  
    int main()  
    {  
        int a = 1,b = 2;  
        cout<<"a = "<<a<<"\t"<<"b = "<<b<<endl;  
        int* pa = &a;  
        int* pb = &b;  
        swap(a,b);  
        cout<<"a = "<<a<<"\t"<<"b = "<<b<<endl;  
        return 0;  

}
  • 还有一种用处是返回额外的结果:还是只有一个返回值,但是有时候我们想要更多的结果,可以通过引用来实现:
    比如我们要遍历一个容器,希望从中找出值为某个特定值的位置以及出现次数。如果找到该元素,则返回该元素的位置,如果找到不止一个,返回第一次出现的位置;如果没有找到,则返回迭代器的end。
    问题就出在这里:如果既返回迭代器的地址,又返回出现次数呢?
    #include <iostream>  
    #include <vector>  

    using namespace std;  

    vector<int>::const_iterator find_value(vector<int>::const_iterator beg, //起始位置  
                        vector<int>::const_iterator end,//结束为止  
                        int value,          //要寻找的值  
                        vector<int>::size_type &occurs)   //出现次数  
    {  
        vector<int>::const_iterator res_iter = end;  
        occurs = 0;  
        for(;beg != end;++beg)  
        {  
            if( *beg == value)  
            {  
                if(res_iter != end)  
                {  
                    res_iter = beg;  
                }  
                ++occurs;  
            }  
        }  
        return res_iter;  
    }  

    int main()  
    {  
        //给容器输入几个值  
        vector<int> val;  
        val.push_back(1);  
        val.push_back(2);  
        val.push_back(3);  
        val.push_back(1);  
        val.push_back(3);  
        val.push_back(4);  
        val.push_back(3);  

        int testVaule = 3;  
        vector<int>::size_type times = 0;  

        vector<int>::const_iterator fristTime = find_value(val.begin(),val.end(),testVaule,times);  

        cout<<testVaule<<"一共出现了"<<times<<"次"<<endl;  
        return 0;  

}
  • const引用:
    为什么尽量使用const引用:因为这样的话,可以给函数直接传递一个右值:
    比如,当你定义
    bool findChar(const string  &s, const char c)  
    {  
        string::size_type i = 0;  
        while(i != s.size() && s[i] != c)  
            ++i;  
        return i;  
} 

时,你可以在程序中直接使用字符串来调用函数

    int main()  
    {  
        bool flag = findChar("thefutureisours",'a');  
        if(flag == false)  
            cout<<"YES!"<<endl;  
        else  
            cout<<"NO!"<<endl;  
        return 0;  

}

而去掉const以后:

    bool findChar( string  &s,  char c)  
    {  
        string::size_type i = 0;  
        while(i != s.size() && s[i] != c)  
            ++i;  
        return i;  
    }  
    bool flag = findChar("thefutureisours",'a');  

就会报错,你只能使用,
string word = “thefutureisours”;
bool flag = findChar(word,’a’);
来调用函数了。


  • 使用数组形参
    数组有两个特点:一是不能直接复制,而是数组名即数组的首地址。所以通常传递数组时,使用指向数组的指针。
    比如我们想打印数组的每个元素:
    void printVaules(const int a[10])  
    {  
        for(size_t i = 0;i != 10;i++)  
            cout<<a[i]<<endl;  
    }  

    int main()  
    {  
        int value[3] = {1,2,3};  
        printVaules(value);  
        return 0;  
}

  程序中,printVaules假定数组有10个元素,但是如果数组长度不为10,虽然程序能够编译并执行,但是第3个数以后的打印信息却不是我们希望的。
  由此可见,非引用数组的形参只会检查实参与形参的数组具有相同的类型,而不会检查数组中的个数是否匹配。
  如果使用的是引用数组,则编译器会检查形参中数组的元素个数与实参是否匹配:

    void printVaules(const int (&a)[10])  
    {  
        for(size_t i = 0;i != 10;i++)  
            cout<<a[i]<<endl;  
    }  

这样
int value[3] = {1,2,3};
printVaules(value);
就不会通过编译了。

  这样做虽然能够避免出现错误的结果,但还是没有真正的解决问题:要想真正做到正确的实现函数的功能,通常有三种做法:
  第一,是在数组的结尾加一个特殊的标记来检测数组的结束,比如C风格的字符串就是在结尾加一个NULL。
  第二种方法与迭代器的思路类似,传递给函数数组的起始和结束位置。

    void printVaules(const int *beg,const int *end)  
    {  
        while(beg != end)  
            cout<<*beg++<<endl;  
    }  

    int main()  
    {  
        int value[3] = {1,2,3};  
        printVaules(value,value+3);  
        return 0;  
} 

  第三种做法是传递给函数数组的同时,顺便传递给函数数组的大小

    void printVaules(const int a[],const size_t size)  
    {  
        for(size_t i = 0; i != size;++i)  
            cout<<a[i]<<endl;  
    }  

    int main()  
    {  
        int value[3] = {1,2,3};  
        printVaules(value,3);  
        return 0;  
} 

截图展示区:

  1. 这里写图片描述

  2. 这里写图片描述
  3. 3.
    #include<stdio.h> 

    void f(double x,double y)
    {
        printf("双精度参数被传递:%lf,%lf",x,y); 
    }

    void f(int a,int b)
    {
        printf("整型参数被传递:%d,%d",a,b); 
    } 

    int main()
    {
        f(3.5,4); 
    }

  此时函数调用会产生二义性!!!

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值