一些C++内存分配问题,还有c++中的（.）和(->)求大神看看

超神级

1. //问题1:请问第13行在堆中分配的空间只可以用(->)访问！在桟只可以用(.)访问....
   
2. //以前看一本教C语言的书的时候说(.)(->)几乎是一样！
   
3. //C++中间的(.)与(->)有什么区别！...........
   
4. //我百度了一下结果什么都没搜到..求解...
   
5. #include<iostream>
   
6. using namespace std;
   
7. class A
   
8. {
   
9. private:
   
10. int *x;//（6行）x在这里定义！
    
11. public:
    
12. A(){x=new int; *x=5;}//（8行）在堆中为x分配一个int类型大小的空间
    
13. set(){cout<<"*x的值是:"<<*x<<endl;}
    
14. };
    
15. int main()
    
16. {
    
17. A*a=new A ();//（12行）在堆中为对象a分配内存。
    
18. a->set();//(13行)输出X的值
    
19. A d;//（14行）在桟中为对象d分配内存。
    
20. d.ste();//(15行)输出X的值
    
21. return 0;
    
22. }

复制代码

1. /*问题2:
   
2. 请问第十行的x是那里来的！我并未定义可以运行！我输出了x的地址是8个C
   
3. 我加上这段代码没有同样没有报错误int *x;                x=NULL;*/
   
4. #include<iostream>
   
5. using namespace std;
   
6. class A
   
7. {
   
8. public:
   
9.                 A(){x = new int;*x=5;}
   
10.                 A(const A&a)
    
11.                 {
    
12.                 cout<<"x的地址"<<x<<endl;
    
13.                 x=a.x;//（第10行）
    
14.                 }
    
15. private:
    
16.             int *x;
    
17. };
    
18. int main()
    
19. {
    
20.             A* a=new A();
    
21.             cout<<a<<endl;
    
22.             A b=(*a);
    
23.             return 0;
    
24. }

复制代码

1. //问题3：
   
2. //（14行）传的并不是指针为什么a对象对x的改变！
   
3. //难道在复制过程中发生了改变！使对象b同样改变！
   
4. #include<iostream>
   
5. using namespace std;
   
6. class A
   
7. {
   
8. public:
   
9.         A(){x = new int;*x=5;}
   
10.         ~A(){delete x;x=NULL;}//如果程序结束就调用析构函数释放x的内存!
    
11.         set(int y){*x=y;}
    
12. private:
    
13.         int *x;
    
14. };
    
15. int main()
    
16. {
    
17. A* a=new A();
    
18. A b=(*a);//（14行）初始化构造函数!a对象复制给b！
    
19. a->set(11);
    
20. return 0;
    
21. }

复制代码

1. //这个是完整代码....
   
2. #include<iostream>
   
3. using namespace std;
   
4. class A
   
5. {
   
6. public:
   
7.         A(){x = new int;cout<<"AAAAAA"<<x<<endl;*x=5;}
   
8.         ~A(){delete x;x=NULL;}
   
9.         A(const A&a)
   
10.         {
    
11.         cout<<"复制构造函数在执行！！"<<endl;
    
12.         cout<<"FDD11111111"<<x<<endl;
    
13. 
    
14. x=a.x;
    
15.         cout<<"FDD"<<a.x<<endl;
    
16.         
    
17.         }
    
18.         void print()const{cout<<*x<<endl;}
    
19.         void set(int i){*x=i;}
    
20. private:
    
21.         int *x;
    
22. 
    
23. };
    
24. int main()
    
25. {
    
26. A* a=new A();
    
27. cout<<"a:";
    
28. a->print();
    
29. cout<<a<<endl;
    
30. int c;
    
31. a->print();
    
32. A b=(*a);
    
33. b.print();
    
34. a->set(32);
    
35. b.print();
    
36. delete a;
    
37. return 0;
    
38. }

复制代码

rosynirvana

请不要把问题写进代码框里，看着很累的……

rosynirvana

第一个， 通过指针访问成员的时候用 (->) ，通过对象本身访问的时候用(.)

例如

1. class A{
   
2.   int member;
   
3. };
   
4. 
   
5. int main()
   
6. {
   
7.   A* a1 = new A();
   
8.   A a2;
   
9.   a1 -> member;
   
10.   a2.member;
    
11. }

复制代码

第二个，
x=a.x
前面一个x是当前对象的x，也就是this->x；第二个是你传进来的a的成员x
这两个都是class A的一个实例，class A有个成员x，所以这样不会有问题
（你会不会以为A类的成员是*x所以觉得不对？）

第三个
你没有写assign copy ctor，所以进行bitwise copy，然后a, b两个实例的成员x指向同一个地址……

Teddy

二三两问看楼上的，第一问解释一下
在很多编译器中 (->)被理解为间接寻址， (.)是直接寻址。
所以一般情况下做指针操作使用 (->)

4399APPLE

没抢到地板

超神级

rosynirvana 发表于 2013-10-21 22:52
请不要把问题写进代码框里，看着很累的……

额,...下次注意.......

超神级

Teddy 发表于 2013-10-22 08:07
二三两问看楼上的，第一问解释一下
在很多编译器中 (->)被理解为间接寻址， (.)是直接寻址。
所以一般情况 ...

把这搞混了！谢谢解答！

rosynirvana

Teddy 发表于 2013-10-22 08:07
二三两问看楼上的，第一问解释一下
在很多编译器中 (->)被理解为间接寻址， (.)是直接寻址。
所以一般情况 ...

这和编译器没关系，纯粹是C的语法规定

因为 *a.member会按照 *(a.member)来计算，但是通过指针访问成员又很常用，所以会专门安排一个符号->
用来表示(*a).member