面向对象C++类中声明成员属性时，指针和引用的区别和用法？以及如何初始化？

Question

class B;

class A
{
public:
B *mpB;
A &mrA;
int c;
};

class B
{
public:
B(){};
A ma;
A& ra;
A* pa;
};
比如上面这段程序，B中的属性ma，ra，pa要如何在构造函数中初始化？用法有什么区别？
A中的mrA，要如何初始化？引用不初始化的话会报错。
B* p = new B();
这时(*p).ma与p->ma有什么区别？
我发现->可以连用好几个但是.不行，即可以p->pa->mpB->pa->c，但是要在构造函数中实例指针的对象。这两种用法有什么区别？

这里好乱，一塌糊涂，感谢大牛解答！！！！

Answer 1

class B
{
public:
    B(A& a):ra(a){
        //A ma这个可以不用初始化了，可以直接用
        //A& ra; 这个需要在初始化列表中初始化 ra(a)
        pa = NULL;//一般直接初始化为NULL，你也可以通过构造方法给传进来个参数
    }
    A ma;            
    A& ra;
    A* pa;

 

A中的mrA，要如何初始化？

和B中的A& ra的初始化方法一样，都是使用初始化列表初始化，然后就不报错了

 

这时(*p).ma与p->ma有什么区别？

这个在最终的用途上是没有区别的，都是调用对象的ma成员变量，只是写法不一样

(*p) 这个表示的是一个对象，所以 后面是  (*p).ma

p 是个指向对象的指针 所以是p->ma

 

我发现->可以连用好几个但是.不行，即可以p->pa->mpB->pa->c，但是要在构造函数中实例指针的对

 

这个没看明白呀！(指针在使用前，一定要初始化，让它指向一个真实的对象，不让程序就崩溃了)

 

引用：

是给一个对象起一个别名，在声明的时候就得定义，明确它所指向的对象，而且以后就不可以更改了，所有对引用的操作，都会影响原来的对象。使用时直接使用  a.function();即可

指针：

指向在对象所在的地址，声明时可以不定义，而后，还可以更改其所指向的地址，改为指向其他对象，可以变化，这个引用不行

追问

。。。写错了写道评论里去了。。。。。

感谢看了这么多问题！我的意思是，p->pa->c就可以访问到c，但是(*p).pa.c就不行。但是后来试验了一下发现原来(*((*p).pa)).c就可以。。。 还有就是class A中的A &mrA; 应该怎么初始化？闹不好在初始化的时候就死循环了。。。 就是说 我有一个类A，定义其中的某个成员变量为 另一个A类的对象 的引用，应该怎么办？

追答

p->pa->c 这个可以

(*p).pa->c 也可以，(*((*p).pa)).c 因为 (*p).pa 这个变量是个对象指针，而不是一个对象变量

(*((*p).pa)) 把 (*p).pa 从一个对象指针变成了一个对象

 

用初始化列表初始化类A中的成员 如下。

引用不会创建一个对象，而是引用一个已经存在的对象，所以不会引起初始化死循环，但用起来怎么着也是挺别扭的，可以这样使，但是这么用我感觉挺糟糕的，感觉和死循环差不多了

class A{
public:  
 A(A& a):mrA(a){
 }                
 A &mrA;              
};
int main(int argc, char* argv[])
{
 A* a = NULL;
 A *b = new A(*a);
 return 0;
}

追问

非常感谢！
那是不是说尽量不要用A &mrA; 的形式？
我想知道，A &mrA; A mA; A* pA; 这三种定义的形式，分别适用于什么情况下？请问？
在什么情况下定义为指针？什么情况下定义为引用？什么情况直接定义对象？有什么好处坏处？

追答

不是说不要用 A &mrA 这种形式，引用是一个很好用的东西，而是说你不要在定义类A的时候，又在其中定义了一个A对象的引用，这样很糟糕，就是下面这样，通常也没有什么实际意义

class A{
public:  
A(A& a):mrA(a){
}                
A &mrA;              
};

A mA;

如果你需要定义一个新对象，并且想要把对象放在栈上，就这样定义。

A*  pA = new A();

如果你需要定义一个新对象，并且想要把对象放在堆上，就这样定义。

 

引用最根本的就是对一个对象起一个别名，然后我们可以直接用这个别名去操作对象。

引用的使用一般分两种情况：

1，为了书写代码的方便

2，在函数传递参数的时候，使用引用传递

指针的用途比较多，也可以分为两种情况

1 一个指针可以指向多个对象，你可以随时更改其指向的地址

2 在函数传递参数的时候，使用地址传递

 

引用传递和地址传递使你可以从函数内部去更改外部变量的值

#include <stdlib.h>
#include <stdio.h>
class A{
public:
 A(char *n){
  name = n;
 }
 void fun(){
  printf("I am %s\n", name);
 }
 char* name;
};
//引用传递
void fun_ref(A&a){
 a.fun();
}
//地址传递
void fun_p(A* a){
 a->fun();
}
//我们的参数传进来一个指针变量，当我不想用指针的方式去调用类的变量或方法
void RefOne(A *a){
 A& b = *a;
 b.fun();
 //a->fun(); //不想使用指针的方式
}
void main(){
 A a("Object a");
 A *b = new A("Object b");
 fun_ref(a);
 fun_p(&a);
 A*c = NULL;
 c = &a;
 c->fun();
 c = b;
 c->fun();
 delete b; b = NULL;