C++中传值参数和引用参数怎样区别?

怎样理解他们的作用?什么情况用传值,什么情况用引用?我是新手哈,麻烦将细点谢谢... 怎样理解他们的作用?
什么情况用传值,什么情况用引用?
我是新手哈,麻烦将细点
谢谢
展开
 我来答
汤灵杉eX
2009-11-29 · TA获得超过2193个赞
知道小有建树答主
回答量:352
采纳率:50%
帮助的人:228万
展开全部
你问的这个话题太大。关于指针和引用要讲的东西很多。
我的理解:
指针: 其实指针这个概念在谭浩强的<C程序设计>这本书上是这样说的,指针就是地址,指针值就是地址值。指针变量就是存放指针的

变量,所以一定不要将指针与指针变量搞混淆了。指针仅仅是一个地址值,而指针变量就是存放指针(也就是地址的变量)

指针的定义:
例如整型指针: int *p;p是一个指向int类型数据的指针变量。里面存放的地址(也就是指针)是一个int类型变量的地址。指针变量时

有类型的,例如p的类型就是int *表示p是一个指向int类型的指针变量。如何知道一个指针变量的类型呢,最简单的方法就是去掉变

量定义语句中的变量名,剩下的部分就是其类型,这种方法适用于所有的变量定义,例如int a;a的类型是int 。 int b[10];b的类

型是int[]表示是一个数组(关于数组类型这里不谈,因为这个问题很微妙,其实在c、c++中没有数组类型这个概念,包括函数类型也

是一样的),int *c;c的类型是int *。int ** d;d的类型就是int **;所以通过这种方法来判断一个变量的类型是很方便的。

说道指针变量,我们必须说到得有几个方面。

1.指针类型。

这个很重要,一个指针是有类型的,也就是一个地址是有类型的。具体说是某一个地址会指向不同类型的数据,这是不一样的,例如

int *p;p是指向int型数据。 double*p1;p1是指向double型数据。但是p和p1本身在内存中占用的空间是4个字节(对于32位的系统来说

),如果是在TC中编译c程序,应该是2个字节了(dos操作系统是16位的)。有人说地址不就是一个值吗,类似于0xfffdddcc这样的地址

数值,为什么还分什么类型呢,我要说的是这个关系很大。我们知道指针是有运算的,int *p=&a;那么p++到底加了多少呢,不要以为

是将p里面的地址值加了1,这是完全想当然。实际上加了sizeof(int)这么多个字节。也就是说加了一个int元素应该占用的字节,这

样在数组中我们可以通过这种方式从上一个元素很方便的让指针变量指向下一个元素。p+5的话实际上是加了p+sizeof(int)*5这么多

个字节。 另外一点事指针的类型决定了当指针解引用的时候其所以指向的内存单元中的二进制数据如何解释的问题。例如int *p=&a;

那么(*p)取得的数字就是一个整型数据,如果(*((char *)p))得到的就是一个字符型数据了。p本来指向的是int型数据(有4个字节)的

首地址,如果将其强制转换为一个指向char类型的指针变量,那么在解引用的时候只取第一个字节的数据,并将其解释为一个ascii码

代表的字符。 还有如果是一个指向函数的指针变量,我们可以通过此指针变量直接调用函数。例如int(*function)(int);此时

function指向一个函数,此函数具有一个int参数,返回一个int值。那么通过指针可以这样调用该类型的函数了int a=function

(100); 或者int a=(*function)(100);其实要不要解引用都是可以的。不过以前是需要解引用的,现在c标准规定这两种方法都可以。

总的来说指针的类型很重要。

2.指针与数组。

我们向一个函数传递数组的时候一般是传递数组名,我们知道数组名是一个代表数组中第一个元素的地址并且数组名是不可以当左值

的。其实你又没有想过数组名到底是什么呢。有人说其实数组名就是一个指针常量,是一个不可以改变的指针常量。例如:int a[10]

={1,2,3,4,5,6,7,8,9,10}; 那么a可能的类型是int * const a;注意const的位置(关于指针常量和常量指针,这个以后说),那么这种

说法到底对不对呢。我们可以通过sizeof运算符来计算某一种数据类型占用的存储空间。例如 sizeof(10)的值为4,注意这里我都假

设在32位的操作系统上面编译。其实sizeof(10)和sizeof(int)是一样的,仅仅是求这种类型的数据占用多少内存空间,而不是说具体

的某个数据占用的空间,因为对于10这个文字常量来说根本不会占用内存空间的,其实随着程序直接编码到源程序中的,不存在分配

内存的问题。那么我们这样计算sizeof(a);是不是如我们所愿得到的是4呢。 结果可能会有意外,因为其值是sizeof(int)*10也就是

40个字节,显然这个字节数是整个数组占用的字节数。而不是int *类型的指针变量占用的字节数,我们知道一个地址只占用4个字节

那么这说明数组名绝对不是简单的int*类型。但是数组确实具有int*的特性。例如int*p=a;这是不会报错的。而且在函数之间传递的

时候也是采用这样的方式:
void print(int b[10]){}
调用函数:
print(a);
或者:
print(&a[0]);
都是一样的。

注意在某一个函数内对形参进行sizeof:
void print(int c[100])
{
sizeof(c); // 此时表达式的结果是4,而不是100。因为这里int c[100]与int *c是一样的,c不是数组名(数组名是不能作为左值

的)
}

3. 指针与函数

一个指针可以指向一个函数,指针可以作为函数参数,函数可以返回一个指针类型的数据。

指向函数的指针: 指向函数的指针,实际上此指针就是函数代码的入口地址。我们可以通过这样的方式调用函数。例如:

void print1(int x)
{
cout<<"hello "<<x<<endl;
}

void print2(int y)
{
cout<<"hello "<<y<<endl;
}

那么在main函数中可以这样写:

void (*p)(int)=print1;//函数名代表函数入口地址值,和数组一样,print1不仅仅是一个地址。

p(10);

p=print2;

p(20);

这都是可以的,另外我们可以通过一个指针数组存放指向函数的指针:

void (*aa[2])(int)={print1,print2};

for(int i=0;i<2;i++)
{
aa[i](i); //通过函数指针循环调用里面的函数
}

关于各种指向函数指针的声明,请自己查阅有关资料。

引用:

引用相当于别名,其实你直接将其当做一个别名就可以了。引用与指针的区别: 引用必须初始化,而且初始化之后不可更改,指针

却可以。
renjianke
推荐于2017-10-11 · TA获得超过2932个赞
知道小有建树答主
回答量:580
采纳率:0%
帮助的人:657万
展开全部
旧事重提,看以下例子:
#include<iostream>
using namespace std;
void swap(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
}
main()
{
int a=3,b=5;
cout<< "before ‘swap’:a="<<a<<",b="<<b<<endl;
swap(a,b);
cout<<"after ‘swap’:a="<<a<<",b="<<b<<endl;
}
这个例子是传值调用, 意思就是 形参 的 改变不会影响 实参的值。
你运行一下可知 主函数调用了swap函数后 a,b的值并没有发生交换。
原因是,调用swap函数时 编译器为 swap(int a,int b) 中的形参 a , b单独分配内存空间,并接受主函数传递来的值,这块内存空间和 main()函数中的 a ,b 不是同一内存空间。 所以在swap(int a,int b) 中 a , b发生了交换,但main函数中a , b没发生交换。即主调函数与被调函数的操作对象各不相同,参数仅在调用时由实参向形参传递,而不可由形参向实参传递。

要使a ,b发生交换 需要使用传址调用。程序改为如下:
#include<iostream>
using namespace std;
void swap(int & a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
cout<<"in ‘swap’:a="<<a<<",b="<<b<<endl;
}
main()
{
int a=3,b=5;
cout<< "before ‘swap’:a="<<a<<",b="<<b<<endl;

swap(a,b);
cout<<"after ‘swap’:a="<<a<<",b="<<b<<endl;
}

引用可以看作是一个变量的别名,使用 引用 时 ,对于void swap(int a,int b) 编译器并没有给形参a,b分配新的内存空间,只是使 形参a,b指向了main函数中实参a,b的内存空间,他们共享同一内空间,即把地址给了形参。所以在void swap(int a,int b)函数中对这块内存的改变也就改变了实参的值。
除了使用引用,也可以使用指针。

指针方式和引用方式都属于传址调用。
本回答被提问者采纳
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
discovery522
推荐于2017-09-13 · TA获得超过4714个赞
知道大有可为答主
回答量:2308
采纳率:71%
帮助的人:1509万
展开全部
先看一个例子:

#include<iostream>
using namespace std;
void swap(int a,int b)
{
int temp;
temp=a;
a=b;
b=temp;
}
main()
{
int a=3,b=5;
cout<< "before ‘swap’:a="<<a<<",b="<<b<<endl;
swap(a,b);
cout<<"after ‘swap’:a="<<a<<",b="<<b<<endl;
}

这个例子是传值调用, 意思就是 形参 的 改变不会影响 实参的值。
运行一下可知,主函数调用了swap函数后 a,b的值并没有发生交换。
原因是,调用swap函数时 编译器为 swap(int a,int b) 中的形参 a , b单独分配内存空间,并接受主函数传递来的值,这块内存空间和 main()函数中的 a ,b 不是同一内存空间。 所以在swap(int a,int b) 中 a , b发生了交换,但main函数中a , b没发生交换。即主调函数与被调函数的操作对象各不相同,参数仅在调用时由实参向形参传递,而不可由形参向实参传递。

要使a ,b发生交换 需要使用传址调用。程序改为如下:
#include<iostream>
using namespace std;
void swap(int & a,int &b)
{
int temp;
temp=a;
a=b;
b=temp;
cout<<"in ‘swap’:a="<<a<<",b="<<b<<endl;
}
main()
{
int a=3,b=5;
cout<< "before ‘swap’:a="<<a<<",b="<<b<<endl;

swap(a,b);
cout<<"after ‘swap’:a="<<a<<",b="<<b<<endl;
}
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
gift925
2009-11-29 · TA获得超过557个赞
知道小有建树答主
回答量:659
采纳率:0%
帮助的人:502万
展开全部
从函数声明中区别。
例如 void f1(int a){a--;}是传值。void f2(int& a){a--;}是引用。
区别在于,如:
int x=3;
f1(x);//这个函数运行完了之后x还是3.因为只是传值进去,而函数自己创建了一个int a的局部变量复制了x的值。函数只是改变了它体内的局部变量a的值,对外部的x没有影响。
f2(x);//运行完之后x变成了2.它是一个别名。相当于直接操作x。它比较安全,不像指针一样会存在内存泄露的隐患。
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
戴半斯烁
2019-11-12 · TA获得超过3万个赞
知道大有可为答主
回答量:1.1万
采纳率:26%
帮助的人:821万
展开全部
旧事重提,看以下例子:
#include<iostream>
using
namespace
std;
void
swap(int
a,int
b)
{
int
temp;
temp=a;
a=b;
b=temp;
}
main()
{
int
a=3,b=5;
cout<<
"before
‘swap’:a="<<a<<",b="<<b<<endl;
swap(a,b);
cout<<"after
‘swap’:a="<<a<<",b="<<b<<endl;
}
这个例子是传值调用,
意思就是
形参

改变不会影响
实参的值。
你运行一下可知
主函数调用了swap函数后
a,b的值并没有发生交换。
原因是,调用swap函数时
编译器为
swap(int
a,int
b)
中的形参
a

b单独分配内存空间,并接受主函数传递来的值,这块内存空间和
main()函数中的
a
,b
不是同一内存空间。
所以在swap(int
a,int
b)

a

b发生了交换,但main函数中a

b没发生交换。即主调函数与被调函数的操作对象各不相同,参数仅在调用时由实参向形参传递,而不可由形参向实参传递。
要使a
,b发生交换
需要使用传址调用。程序改为如下:
#include<iostream>
using
namespace
std;
void
swap(int
&
a,int
&b)
{
int
temp;
temp=a;
a=b;
b=temp;
cout<<"in
‘swap’:a="<<a<<",b="<<b<<endl;
}
main()
{
int
a=3,b=5;
cout<<
"before
‘swap’:a="<<a<<",b="<<b<<endl;
swap(a,b);
cout<<"after
‘swap’:a="<<a<<",b="<<b<<endl;
}
引用可以看作是一个变量的别名,使用
引用

,对于void
swap(int
a,int
b)
编译器并没有给形参a,b分配新的内存空间,只是使
形参a,b指向了main函数中实参a,b的内存空间,他们共享同一内空间,即把地址给了形参。所以在void
swap(int
a,int
b)函数中对这块内存的改变也就改变了实参的值。
除了使用引用,也可以使用指针。
指针方式和引用方式都属于传址调用。
已赞过 已踩过<
你对这个回答的评价是?
评论 收起
收起 更多回答(4)
推荐律师服务: 若未解决您的问题,请您详细描述您的问题,通过百度律临进行免费专业咨询

为你推荐:

下载百度知道APP,抢鲜体验
使用百度知道APP,立即抢鲜体验。你的手机镜头里或许有别人想知道的答案。
扫描二维码下载
×

类别

我们会通过消息、邮箱等方式尽快将举报结果通知您。

说明

0/200

提交
取消

辅 助

模 式