[求助]关于引用

yan

在C++中，b是一个类：
void a(string b){}
和
void a(string &b){}
一样么？
还有：
string a(){string b;return b;}
和
string &a(){string b;return b;}
一样么？为什么啊？

Eastsun

原帖由 yan 于 2007-12-3 13:05 发表
在C++中，b是一个类：
void a(string b){}
和
void a(string &b){}
一样么？

不一样。
void a(string b){}
在方法内部得到是参数的一个拷贝。
void a(string &b){}
方法内部的 b与传进去的是同一个对象。

原帖由 yan 于 2007-12-3 13:05 发表
还有：
string a(){string b;return b;}
和
string &a(){string b;return b;}
一样么？为什么啊？

string &a(){string b;return b;}
这个是错的。。
b只是一个方法内部的临时变量。

Eastsun

至于为什么。。
偶可能知道，也可能不知道，但肯定是讲不清楚了:-)

Eastsun

不过基本上，在函数参数这里，
可以把引用看成使用指针的一个快捷方式。

JAY

参数可以有入参(in)和出参(out)。

一般一个函数的执行结果是一个int, float, char等原子级数据类型可以直接返回，如果是比较复杂的结构可以返回一个指针。但这些都有一个问题就在于只能返回"一个"结果。
比如你想写一个swap方法交换a、b两个数，明显用return的方式就不适合。所以就可能用到出参。

其实出参原理很简单就是把a、b的地址发给函数，函数直接修改在该函数之外的a、b变量。所以swap的形式可能是void swap(int *pa, int *pb)。而你在函数内部需要用*解引用才能访问a、b：*pa = xxx......

引用其实和他是同一道理，不过在语法上更为直观，如果用引用的话函数的原型就是void swap(int &ra, int&rb)。而在函数内部则可以直接用ra、rb操纵传进来的参数，而不用再用地址去解析一遍。

其实你可以简单的引用看成解析过的指针

yan

但是这个有怎么解释？

1. #include <stdio.h>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         char *p;
   
7.         char q;
   
8. public:
   
9.         A()
   
10.         {
    
11.                 p = 0;
    
12.                 printf("AAAA\n");
    
13.         }
    
14.         ~A()
    
15.         {
    
16.                 //if (p)
    
17.                 //{
    
18.                 //        delete p;
    
19.                 //        p = 0;
    
20.                 //}
    
21.                 printf("~AAAA\n");
    
22.         }
    
23. };
    
24. 
    
25. void a(A b)
    
26. {
    
27.         *b.p = 56;
    
28.         b.q = 23;
    
29.        
    
30. }
    
31. 
    
32. void c(A &d)
    
33. {
    
34.         *d.p = 90;
    
35.         d.q = 34;
    
36. }
    
37. 
    
38. int main(int argc, int *argv[])
    
39. {
    
40.         A i;
    
41. 
    
42.         i.p = new char(2);
    
43.         i.q = 50;
    
44. 
    
45.         printf("%d %d\n", *i.p,i.q);
    
46.         a(i);
    
47.         printf("%d %d\n", *i.p,i.q);
    
48.         c(i);
    
49.         printf("%d %d\n", *i.p,i.q);
    
50.         return 0;
    
51. }
    
52. /*
    
53. *出现：AAAA
    
54. *      2 50
    
55. *      ~AAAA
    
56. *      56 50
    
57. *      90 34
    
58. *      ~AAAA
    
59. */

复制代码

[ 本帖最后由 yan 于 2007-12-3 22:04 编辑 ]

Eastsun

注意class A中的p是个指针就OK了

Lendy

1. A i           AAAA
   
2. printf()      2 50
   
3. a(i)          ~AAAA    原形a(A b)，把i作为入参时调用的是拷贝构造函数，
   
4.                        拷贝构造函数形如A::A(const A& in)，
   
5.                        所以只有在函数最后销毁入参时产生了~AAAA
   
6. printf()      56 50
   
7. c(i)          无
   
8. printf()      90 34
   
9.               ~AAAA    销毁i

复制代码

yan

像void a(A b){}这种函数一般用在什么地方？（这个函数有可能把实参的数据改变掉）

yan

1. #include <stdio.h>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         char *p;
   
7.         char q;
   
8. public:
   
9.         A()
   
10.         {
    
11.                 p = 0;
    
12.                 printf("AAAA\n");
    
13.         }
    
14.         ~A()
    
15.         {
    
16.                 //if (p)
    
17.                 //{
    
18.                 //        delete p;
    
19.                 //        p = 0;
    
20.                 //}
    
21.                 printf("~AAAA\n");
    
22.         }
    
23. };
    
24. 
    
25. A a(A x)
    
26. {
    
27.         *x.p = 1;
    
28.         x.q = 2;
    
29.         return x;
    
30. }
    
31. 
    
32. A &b(A x)
    
33. {
    
34.         *x.p = 3;
    
35.         x.q = 4;
    
36.         return x;
    
37. }
    
38. 
    
39. A c(A &x)
    
40. {
    
41.         *x.p = 5;
    
42.         x.q = 6;
    
43.         return x;
    
44. }
    
45. 
    
46. A &d(A &x)
    
47. {
    
48.         *x.p = 7;
    
49.         x.q = 8;
    
50.         return x;
    
51. }
    
52. 
    
53. int main(int argc, int *argv[])
    
54. {
    
55.         A i;
    
56.         A k;
    
57. 
    
58.         i.p = new char(2);
    
59.         i.q = 50;
    
60. 
    
61.         k = a(i);
    
62.         printf("%d %d\n", *k.p, k.q);
    
63.         k = b(i);
    
64.         printf("%d %d\n", *k.p, k.q);
    
65.         k = c(i);
    
66.         printf("%d %d\n", *k.p, k.q);
    
67.         k = d(i);
    
68.         printf("%d %d\n", *k.p, k.q);
    
69.         return 0;
    
70. }
    
71. /*
    
72. *出现:  AAAA
    
73. *      AAAA
    
74. *      ~AAAA
    
75. *      ~AAAA
    
76. *      1  2
    
77. *      ~AAAA
    
78. *      3  4
    
79. *      ~AAAA
    
80. *      5  6
    
81. *      7  8
    
82. *      ~AAAA
    
83. *      ~AAAA
    
84. */

复制代码

函数A a(A x);执行赋值语句后要返回x，但是返回前要析构x，那怎么返回x？
执行k = a(i);后要析构？

Eastsun

原帖由 yan 于 2007-12-4 10:33 发表
像void a(A b){}这种函数一般用在什么地方？（这个函数有可能把实参的数据改变掉）

这个其实是你没有提供拷贝函数造成造成的.
默认情况下 A a =b;
会将类b的RAM copy 到类A所在地址,但这样一般是不合理的.

[ 本帖最后由 Eastsun 于 2007-12-4 12:23 编辑 ]

yan

拷贝构造函数是这样么？A::A(A &x){..........}
还有10#的问题呢？

Eastsun

应该是在销毁前,已经赋值给左边那个了..