函数中实参到形参的传递
2012-06-11 16:41
483 查看
参数的传递就是用实参初始化对应的形参。
非引用形参:
基本的情况:复制实参的值。函数并没有访问调用函数所传递的实参本身,所以不会改变实参的值。
指针形参:此时将复制实参的指针:形参的改变不会引起实参的改变,但是形参指向的内容可以发生变化。
程序中,虽然pa始终指向a,pb始终指向b,但是a与b的值已发生了交换。
const形参:const实参可以传递给非const形参,因为初始化的复制规则:可以用const对象给非const对象复制
当然,使用const实参初始化const形参肯定是没有问题的。
反之,非const对象也可以传递给const形参,只要在程序中不改变形参的值即可:
但是,如果你想在程序中修改形参的值,就会报错:
编译无法通过。
复制实参的不适合的情况:
1.需要在函数中修改实参的值
2.没有办法实现参数的复制(比如数组)
3.当使用大型对象作为参数传递时,复制对象付出的代价太大。
引用形参:
引用形参直接关联到所绑定的对象,而非对象的副本。此时形参只是实参的另一个名字,对形参的修改就意味着对实参的修改。
还有一种用处是返回额外的结果:还是只有一个返回值,但是有时候我们想要更多的结果,可以通过引用来实现:
比如我们要遍历一个容器,希望从中找出值为某个特定值的位置以及出现次数。如果找到该元素,则返回该元素的位置,如果找到不止一个,返回第一次出现的位置;如果没有找到,则返回迭代器的end。
问题就出在这里:如果既返回迭代器的地址,又返回出现次数呢?
const引用:
为什么尽量使用const引用:因为这样的话,可以给函数直接传递一个右值:
比如,当你定义
时,你可以在程序中直接使用字符串来调用函数
而去掉const以后:
就会报错,你只能使用,
来调用函数了。
使用数组形参
数组有两个特点:一是不能直接复制,而是数组名即数组的首地址。所以通常传递数组时,使用指向数组的指针。
比如我们想打印数组的每个元素:
程序中,printVaules假定数组有10个元素,但是如果数组长度不为10,虽然程序能够编译并执行,但是第3个数以后的打印信息却不是我们希望的。
由此可见,非引用数组的形参只会检查实参与形参的数组具有相同的类型,而不会检查数组中的个数是否匹配。
如果使用的是引用数组,则编译器会检查形参中数组的元素个数与实参是否匹配:
这样
就不会通过编译了。
这样做虽然能够避免出现错误的结果,但还是没有真正的解决问题:要想真正做到正确的实现函数的功能,通常有三种做法:
第一,是在数组的结尾加一个特殊的标记来检测数组的结束,比如C风格的字符串就是在结尾加一个NULL。
第二种方法与迭代器的思路类似,传递给函数数组的起始和结束位置。
第三种做法是传递给函数数组的同时,顺便传递给函数数组的大小
非引用形参:
基本的情况:复制实参的值。函数并没有访问调用函数所传递的实参本身,所以不会改变实参的值。
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; }
相关文章推荐
- 函数中实参到形参的传递
- C/C++中二维数组作函数形参时,调用函数时,可传递的实参类型的小结
- 【代码】结构体做函数参数,实现形参向实参传递值
- C/C++中二维数组作函数形参时,调用函数时,可传递的实参类型的小结
- C# 把函数作为实参传递给作为形参的委托
- C语言-实参到函数形参传递的理解
- C/C++函数形参传实参时值传递、指针传递、引用传递的区别
- 指针用于将函数中形参的值传递给实参
- 通过函数分配内存,理解实参,形参之间的传递.
- C语言中函数传递(实参 形参)
- C语言中函数传递(实参 形参)
- 【C++再学习】【03】函数形参实参与值传递引用传递新解
- C/C++函数形参传实参时值传递、指针传递、引用传递的区别
- 函数实参和形参之间的传递
- 函数中实参到形参的传递
- day06 函数 形参实参 函数的嵌套调用
- 也许是你一直没有弄懂的问题系列之<函数的形参和实参特点及区别>
- 函数调用下形参和实参的内存分配
- 二维数组作为函数的实参,定义函数形参的方法
- C++Primer:函数(参数传递-非引用形参)