论坛 › C\C++交流 › 关于C++构造器和析构器的几个问题求助

丶不离不弃 发表于 2019-12-5 10:00:40

关于C++构造器和析构器的几个问题求助

问题1，如下代码
#include <iostream>
using namespace std;
class A{
public:
    A(){cout<<'x';}
};

class B:public A{
private:
    int x;
public:
    B(int x):A(),x(x){cout<<x<<'t';}
};

class C{
private:
    A a;
    B b;
public:
    C(int x):b(x){cout<<'r';}
};
void f(){
    A a1;
    B b1(2);
    C c1(3);

}
int main() {
    cout<<"bienvenue!\n";
    f();
    cout<<"au revoire!\n";
}

输出为：
bienvenue!
xx2txx3trau revoire!

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

问题2：如下代码
#include <iostream>
using namespace std;
class A{
public:
    A(){cout<<'a';}
    ~A(){cout<<"b\n";}
};

class B:public A{
private:
    int x;
public:
    B(int x):A(),x(x){cout<<'c'<<x;}
    ~B(){cout<<"~B"<<x;}
};
class C{
private:
    A a;
    B b;
public:
    C(int x):b(x){cout<<'d';}
    ~C(){cout<<'e';}
};
void f(){
    A a1;
    B b1(2);
    C c1(3);
}
int main() {
    cout<<"hello\n";
    f();
    cout<<"goodbye\n";
}
输出结果为：
hello
aac2aac3de~B3b
b
~B2b
b
goodbye

Process finished with exit code 0

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


问题3：如下代码
#include <iostream>
using namespace std;
class A{
public:
    void f(){cout<<"hello!";}
};

int max(int *p,int n){
    int max=p;
    for(int i=1;i<n;i++){
      if(max<p){
            max=p;
      }
      return max;
    }

    void fillMax(int *p,int n){
      int max=max(*p,n);
      for(int i=0;i<n;i++){
            *p++=max;
      }
    }
}
int main() {
    A a1;
    A a2();
    A *p;
    const A a3;
    p=&a1;
    //p=&a3; illegal, a3 is const;
    const A *q;
    q=&a1;
    //A *const r; r can not change, must be initialized??????????????
    a1.f();
    p->f();//(*p).f()
    (*p).f();
    //a2.f(); illegal
    //q->f(); illegal q is a pointer to const, f is not const;
    return 0;
}

我想问一下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; Aconst *q就不用初始化呢？

人造人 发表于 2019-12-5 13:22:50

#include <iostream>
using namespace std;
class A {
public:
        A() { cout << "class A的构造函数被调用" << std::endl; }
};

class B:public A {
private:
        int x;
public:
        B(int x):A(), x(x) { cout << x << " " << "class B的构造函数被调用" << std::endl; }
};

class C {
private:
        A a;
        B b;
public:
        C(int x):b(x) { cout << "class C的构造函数被调用" << std::endl; }
};
void f() {
        std::cout << "开始创建a1" << std::endl;
        A a1;
        std::cout << "a1创建完成，开始创建b1" << std::endl;
        B b1(2);
        std::cout << "b1创建完成，开始创建c1" << std::endl;
        C c1(3);
        std::cout << "c1创建完成" << std::endl;

}
int main() {
        cout << "bienvenue!\n";
        f();
        cout << "au revoire!\n";
}

bienvenue!
开始创建a1
class A的构造函数被调用
a1创建完成，开始创建b1
class A的构造函数被调用
2 class B的构造函数被调用
b1创建完成，开始创建c1
class A的构造函数被调用
class A的构造函数被调用
3 class B的构造函数被调用
class C的构造函数被调用
c1创建完成
au revoire!
请按任意键继续. . .

人造人 发表于 2019-12-5 13:28:37

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

人造人 发表于 2019-12-5 13:31:08

第3个问题不太好回答

人造人 发表于 2019-12-5 13:38:21

#include <iostream>

class A
{
public:
        int x;
        A(): x(0) {}
        void f()
        {
                std::cout << "hello!" << std::endl;
        }
};

int main()
{
        A a1;
        A a2;

        A *const r = &a1;        // 变量r是一个指针，这个const用来限制变量r，r只能在初始化的时候指向一个对象，之后就一直指向这个对象并且不能再指向其他对象
        r->x = 100;                // 可以
        r->f();                        // 可以
        //r = &a2;                // 不可以

        return 0;
}

人造人 发表于 2019-12-5 13:42:51

#include <iostream>

class A
{
public:
        int x;
        A(): x(0) {}
        void f()
        {
                std::cout << "hello!" << std::endl;
        }
};

int main()
{
        A a1;
        A a2;

        // 这两个是一样的
        // A const r;
        // const A r;

        const A r;        // 变量r是一个对象，一个const对象
        //r.f();        // 不可以，没错，确实是不可以因为函数f不是const的
        //r.x = 100;        // 不可以

        return 0;
}

人造人 发表于 2019-12-5 13:44:36

#include <iostream>

class A
{
public:
        int x;
        A(): x(0) {}
        void f() const                // 这里添加const，指明函数f是const的
        {
                //x = 1;        // 不可以，因为f是const的
                std::cout << "hello!" << std::endl;
        }
};

int main()
{
        A a1;
        A a2;

        // 这两个是一样的
        // A const r;
        // const A r;

        const A r;        // 变量r是一个对象，一个const对象
        r.f();        // 可以
        //r.x = 100;        // 不可以

        return 0;
}

人造人 发表于 2019-12-5 13:45:30

剩下的晚上回来继续

人造人 发表于 2019-12-5 13:51:00

本帖最后由 人造人 于 2019-12-5 13:59 编辑

还有时间，继续

#include <iostream>

class A
{
public:
        int x;
        A(): x(0) {}
        void f()
        {
                std::cout << "hello!" << std::endl;
        }
};

int main()
{
        A a1;
        A a2;

        // 下面这两个是一样的
        //A const *r;
        //const A *r;

        // 我比较喜欢写成这样，写成 A const *r;也完全可以
        const A *r = &a1;        // 变量r是一个指针，这个指针指向的对象是const的
        //r->f();                // 不可以
        //r->x = 100;        // 不可以

        r = &a2;        // 可以
        //r->f();        // 不可以
        //r->x = 100;        // 不可以

        return 0;
}

人造人 发表于 2019-12-5 13:52:03

本帖最后由 人造人 于 2019-12-5 13:58 编辑

#include <iostream>

class A
{
public:
        int x;
        A(): x(0) {}
        void f() const
        {
                std::cout << "hello!" << std::endl;
        }
};

int main()
{
        A a1;
        A a2;

        // 下面这两个是一样的
        //A const *r;
        //const A *r;

        // 我比较喜欢写成这样，写成 A const *r;也完全可以
        const A *r = &a1;        // 变量r是一个指针，这个指针指向的对象是const的
        r->f();                // 可以
        //r->x = 100;        // 不可以

        r = &a2;        // 可以
        r->f();                // 可以
        //r->x = 100;        // 不可以

        return 0;
}

人造人 发表于 2019-12-5 13:52:57

本帖最后由 人造人 于 2019-12-5 13:58 编辑

#include <iostream>

class A
{
public:
        int x;
        A(): x(0) {}
        void f() const
        {
                std::cout << "hello!" << std::endl;
        }
};

int main()
{
        A a1;
        A a2;

        // 下面这两个是一样的
        //A const *r;
        //const A *r;

        // 我比较喜欢写成这样，写成 A const *r;也完全可以
        const A *r;        // 变量r是一个指针，这个指针指向的对象是const的
        r = &a1;        // 可以在这里初始化
        r->f();                // 可以
        //r->x = 100;        // 不可以

        r = &a2;        // 可以
        r->f();                // 可以
        //r->x = 100;        // 不可以

        return 0;
}

人造人 发表于 2019-12-5 13:59:32

应该没有错别字了
^_^

丶不离不弃 发表于 2019-12-5 21:37:39

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

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

查看完整版本: 关于C++构造器和析构器的几个问题求助