函数中实参到形参的传递

参数的传递就是用实参初始化对应的形参。
非引用形参：
基本的情况：复制实参的值。函数并没有访问调用函数所传递的实参本身，所以不会改变实参的值。

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;  
}