[已解决]关于C++构造器和析构器的几个问题求助

丶不离不弃

问题1，如下代码

1. #include <iostream>
   
2. using namespace std;
   
3. class A{
   
4. public:
   
5.     A(){cout<<'x';}
   
6. };
   
7. 
   
8. class B:public A{
   
9. private:
   
10.     int x;
    
11. public:
    
12.     B(int x):A(),x(x){cout<<x<<'t';}
    
13. };
    
14. 
    
15. class C{
    
16. private:
    
17.     A a;
    
18.     B b;
    
19. public:
    
20.     C(int x):b(x){cout<<'r';}
    
21. };
    
22. void f(){
    
23.     A a1;
    
24.     B b1(2);
    
25.     C c1(3);
    
26. 
    
27. }
    
28. int main() {
    
29.     cout<<"bienvenue!\n";
    
30.     f();
    
31.     cout<<"au revoire!\n";
    
32. }

复制代码

输出为：

1. bienvenue!
   
2. xx2txx3trau revoire!
   
3. 
   
4. Process finished with exit code 0

复制代码

我想问对象a1输出x 对象b1输出x2t，对象c1输出xx3tr,我就想问开始的两个“xx”是从哪来的，为啥我自己写的只有一个x呢？

问题2：如下代码

1. #include <iostream>
   
2. using namespace std;
   
3. class A{
   
4. public:
   
5.     A(){cout<<'a';}
   
6.     ~A(){cout<<"b\n";}
   
7. };
   
8. 
   
9. class B:public A{
   
10. private:
    
11.     int x;
    
12. public:
    
13.     B(int x):A(),x(x){cout<<'c'<<x;}
    
14.     ~B(){cout<<"~B"<<x;}
    
15. };
    
16. class C{
    
17. private:
    
18.     A a;
    
19.     B b;
    
20. public:
    
21.     C(int x):b(x){cout<<'d';}
    
22.     ~C(){cout<<'e';}
    
23. };
    
24. void f(){
    
25.     A a1;
    
26.     B b1(2);
    
27.     C c1(3);
    
28. }
    
29. int main() {
    
30.     cout<<"hello\n";
    
31.     f();
    
32.     cout<<"goodbye\n";
    
33. }

复制代码

输出结果为：

1. hello
   
2. aac2aac3de~B3b
   
3. b
   
4. ~B2b
   
5. b
   
6. goodbye
   
7. 
   
8. Process finished with exit code 0

复制代码

我想问我开始写出来的和输出结果完全不一样，请问有大神可以细致讲解下这个每一步的构造和析构过程吗，谢谢~！


问题3：如下代码

1. #include <iostream>
   
2. using namespace std;
   
3. class A{
   
4. public:
   
5.     void f(){cout<<"hello!";}
   
6. };
   
7. 
   
8. int max(int *p,int n){
   
9.     int max=p[0];
   
10.     for(int i=1;i<n;i++){
    
11.         if(max<p[i]){
    
12.             max=p[i];
    
13.         }
    
14.         return max;
    
15.     }
    
16. 
    
17.     void fillMax(int *p,int n){
    
18.         int max=max(*p,n);
    
19.         for(int i=0;i<n;i++){
    
20.             *p++=max;
    
21.         }
    
22.     }
    
23. }
    
24. int main() {
    
25.     A a1;
    
26.     A a2();
    
27.     A *p;
    
28.     const A a3;
    
29.     p=&a1;
    
30.     //p=&a3; illegal, a3 is const;
    
31.     const A *q;
    
32.     q=&a1;
    
33.     //A *const r; r can not change, must be initialized??????????????
    
34.     a1.f();
    
35.     p->f();//(*p).f()
    
36.     (*p).f();
    
37.     //a2.f(); illegal
    
38.     //q->f(); illegal q is a pointer to const, f is not const;
    
39.     return 0;
    
40. }

复制代码

我想问一下A *const r;   const A r;   A const *r;   const A *r; A const r 有啥区别呢，在实现p->f()的时候分别有哪些结果呢？
A *const r; r can not change, must be initialized??????????????这一句为啥要初始化，const A * q; A  const *q就不用初始化呢？

最佳答案

月排行榜 / 总排行榜

人造人

2019-12-5 13:38:21

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f()
   
9.         {
   
10.                 std::cout << "hello!" << std::endl;
    
11.         }
    
12. };
    
13. 
    
14. int main()
    
15. {
    
16.         A a1;
    
17.         A a2;
    
18. 
    
19.         A *const r = &a1;        // 变量r是一个指针，这个const用来限制变量r，r只能在初始化的时候指向一个对象，之后就一直指向这个对象并且不能再指向其他对象
    
20.         r->x = 100;                // 可以
    
21.         r->f();                        // 可以
    
22.         //r = &a2;                // 不可以
    
23. 
    
24.         return 0;
    
25. }

复制代码

跳转到最佳答案楼层

人造人

1. #include <iostream>
   
2. using namespace std;
   
3. class A {
   
4. public:
   
5.         A() { cout << "class A的构造函数被调用" << std::endl; }
   
6. };
   
7. 
   
8. class B:public A {
   
9. private:
   
10.         int x;
    
11. public:
    
12.         B(int x):A(), x(x) { cout << x << " " << "class B的构造函数被调用" << std::endl; }
    
13. };
    
14. 
    
15. class C {
    
16. private:
    
17.         A a;
    
18.         B b;
    
19. public:
    
20.         C(int x):b(x) { cout << "class C的构造函数被调用" << std::endl; }
    
21. };
    
22. void f() {
    
23.         std::cout << "开始创建a1" << std::endl;
    
24.         A a1;
    
25.         std::cout << "a1创建完成，开始创建b1" << std::endl;
    
26.         B b1(2);
    
27.         std::cout << "b1创建完成，开始创建c1" << std::endl;
    
28.         C c1(3);
    
29.         std::cout << "c1创建完成" << std::endl;
    
30. 
    
31. }
    
32. int main() {
    
33.         cout << "bienvenue!\n";
    
34.         f();
    
35.         cout << "au revoire!\n";
    
36. }

复制代码

1. bienvenue!
   
2. 开始创建a1
   
3. class A的构造函数被调用
   
4. a1创建完成，开始创建b1
   
5. class A的构造函数被调用
   
6. 2 class B的构造函数被调用
   
7. b1创建完成，开始创建c1
   
8. class A的构造函数被调用
   
9. class A的构造函数被调用
   
10. 3 class B的构造函数被调用
    
11. class C的构造函数被调用
    
12. c1创建完成
    
13. au revoire!
    
14. 请按任意键继续. . .

复制代码

人造人

问题2和问题1类似，多加几个cout然后再看输出结果，看看能不能看懂

人造人

第3个问题不太好回答

人造人

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f()
   
9.         {
   
10.                 std::cout << "hello!" << std::endl;
    
11.         }
    
12. };
    
13. 
    
14. int main()
    
15. {
    
16.         A a1;
    
17.         A a2;
    
18. 
    
19.         A *const r = &a1;        // 变量r是一个指针，这个const用来限制变量r，r只能在初始化的时候指向一个对象，之后就一直指向这个对象并且不能再指向其他对象
    
20.         r->x = 100;                // 可以
    
21.         r->f();                        // 可以
    
22.         //r = &a2;                // 不可以
    
23. 
    
24.         return 0;
    
25. }

复制代码

人造人

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f()
   
9.         {
   
10.                 std::cout << "hello!" << std::endl;
    
11.         }
    
12. };
    
13. 
    
14. int main()
    
15. {
    
16.         A a1;
    
17.         A a2;
    
18. 
    
19.         // 这两个是一样的
    
20.         // A const r;
    
21.         // const A r;
    
22. 
    
23.         const A r;        // 变量r是一个对象，一个const对象
    
24.         //r.f();        // 不可以，没错，确实是不可以因为函数f不是const的
    
25.         //r.x = 100;        // 不可以
    
26. 
    
27.         return 0;
    
28. }

复制代码

人造人

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f() const                // 这里添加const，指明函数f是const的
   
9.         {
   
10.                 //x = 1;        // 不可以，因为f是const的
    
11.                 std::cout << "hello!" << std::endl;
    
12.         }
    
13. };
    
14. 
    
15. int main()
    
16. {
    
17.         A a1;
    
18.         A a2;
    
19. 
    
20.         // 这两个是一样的
    
21.         // A const r;
    
22.         // const A r;
    
23. 
    
24.         const A r;        // 变量r是一个对象，一个const对象
    
25.         r.f();        // 可以
    
26.         //r.x = 100;        // 不可以
    
27. 
    
28.         return 0;
    
29. }

复制代码

人造人

剩下的晚上回来继续

人造人

还有时间，继续

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f()
   
9.         {
   
10.                 std::cout << "hello!" << std::endl;
    
11.         }
    
12. };
    
13. 
    
14. int main()
    
15. {
    
16.         A a1;
    
17.         A a2;
    
18. 
    
19.         // 下面这两个是一样的
    
20.         //A const *r;
    
21.         //const A *r;
    
22. 
    
23.         // 我比较喜欢写成这样，写成 A const *r;也完全可以
    
24.         const A *r = &a1;        // 变量r是一个指针，这个指针指向的对象是const的
    
25.         //r->f();                // 不可以
    
26.         //r->x = 100;        // 不可以
    
27. 
    
28.         r = &a2;        // 可以
    
29.         //r->f();        // 不可以
    
30.         //r->x = 100;        // 不可以
    
31. 
    
32.         return 0;
    
33. }

复制代码

人造人

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f() const
   
9.         {
   
10.                 std::cout << "hello!" << std::endl;
    
11.         }
    
12. };
    
13. 
    
14. int main()
    
15. {
    
16.         A a1;
    
17.         A a2;
    
18. 
    
19.         // 下面这两个是一样的
    
20.         //A const *r;
    
21.         //const A *r;
    
22. 
    
23.         // 我比较喜欢写成这样，写成 A const *r;也完全可以
    
24.         const A *r = &a1;        // 变量r是一个指针，这个指针指向的对象是const的
    
25.         r->f();                // 可以
    
26.         //r->x = 100;        // 不可以
    
27. 
    
28.         r = &a2;        // 可以
    
29.         r->f();                // 可以
    
30.         //r->x = 100;        // 不可以
    
31. 
    
32.         return 0;
    
33. }

复制代码

人造人

1. #include <iostream>
   
2. 
   
3. class A
   
4. {
   
5. public:
   
6.         int x;
   
7.         A(): x(0) {}
   
8.         void f() const
   
9.         {
   
10.                 std::cout << "hello!" << std::endl;
    
11.         }
    
12. };
    
13. 
    
14. int main()
    
15. {
    
16.         A a1;
    
17.         A a2;
    
18. 
    
19.         // 下面这两个是一样的
    
20.         //A const *r;
    
21.         //const A *r;
    
22. 
    
23.         // 我比较喜欢写成这样，写成 A const *r;也完全可以
    
24.         const A *r;        // 变量r是一个指针，这个指针指向的对象是const的
    
25.         r = &a1;        // 可以在这里初始化
    
26.         r->f();                // 可以
    
27.         //r->x = 100;        // 不可以
    
28. 
    
29.         r = &a2;        // 可以
    
30.         r->f();                // 可以
    
31.         //r->x = 100;        // 不可以
    
32. 
    
33.         return 0;
    
34. }

复制代码

人造人

应该没有错别字了
^_^

丶不离不弃

人造人 发表于 2019-12-5 13:59
应该没有错别字了
^_^

谢谢大神啦~~！我一会去图书馆好好看看呢~！