经典问题解析二

qq_52484093

已于 2024-02-12 16:50:33 修改

阅读量64

点赞数

分类专栏： C++ 文章标签： c++

于 2023-06-28 13:57:40 首次发布

本文链接：https://blog.csdn.net/qq_52484093/article/details/131433231

版权

C++ 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

关于析构的疑问

当程序中存在多个对象的时候，如何确定这些对象的析构顺序？

单个对象创建时构造函数的构造顺序

1、调用父类的构造函数

2、调用成员变量的构造函数 (调用顺序与声明顺序相同)

3、调用类自身的构造函数

析构函数与对应构造函数的调用顺序相反

多个对象析构时

析构顺序与构造顺序相反

对于栈对象和全局对象，类似于入栈与出栈的顺序，最后构造的对象被最先析构

堆对象的析构发生在 delete 的时候，与 delete 的使用顺序相关！！

构造与析构顺序

#include <stdio.h>

class Member
{
    const char* ms;
public:
    Member(const char* s)
    {
        printf("Member(const char* s): %s\n", s);
        
        ms = s;
    }
    ~Member()
    {
        printf("~Member(): %s\n", ms);
    }
};

class Test
{
    Member mA;
    Member mB;
public:
    Test() : mB("mB"), mA("mA")
    {
        printf("Test()\n");
    }
    ~Test()
    {
        printf("~Test()\n");
    }
};

Member gA("gA");

int main()
{
    Test t;
    
    return 0;
}

Test 类中包含了两个 Member 类对象，类中包含其他类对象的时候，会先调用其他类对象的构造函数，再调用自身的构造函数，成员变量的构造顺序与声明顺序相同，与初始化列表的顺序无关，所以会先调用 ma 的构造函数，然后调用 mb 的构造函数，最后调用自身的构造函数

析构顺序和构造顺序相反

程序运行结果如下图所示：

关于 const 对象的疑问？

const 关键字能否修饰类的对象？如果可以，有什么特性？

const 关键字能够修饰对象

const 修饰的对象为只读对象

只读对象的成员变量不允许被改变

只读对象是编译阶段的概念，运行时无效

C++ 中的 const 成员函数

const 对象只能调用 const 成员函数

const 成员函数中只能调用 const 成员函数

const 成员函数中不能直接改写成员变量的值

const 成员函数的定义

Type ClassName::function(Type p) const

类中的函数声明与实际函数定义中都必须带 const 关键字

类的 const 函数初探

#include <stdio.h>

class Test
{
    int mi;
public:
    Test(int i);
    Test(const Test& t);
    int getMi() const;
	void print(); 
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{
    
}
    
int Test::getMi() const
{
    return mi;
}

void Test::print()
{
    printf("mi = %d\n", mi);
}

int main()
{
    const Test t(1);
    
	t.getMi();
	t.print();
	
    return 0;
}

对上面程序进行编译，编译直接报错

第 38 行报错是因为，t 是我们定义的 const 成员变量，const 成员变量只能调用 const 成员函数，getMi() 函数是 const 成员函数，print() 函数不是 const 成员函数，所以编译会报错

关于类成员的疑问

成员函数和成员变量都隶属于具体对象吗？

从面向对象的角度

对象由属性 (成员变量) 和方法 (成员函数) 构成

从程序运行的角度

对象由数据和函数构成
数据可以位于栈，堆和全局数据区
函数只能位于代码段

结论

每一个对象拥有自己独立的属性 (成员变量)

所有对象共享类的方法 (成员函数)

方法能够直接访问对象的属性

方法中的隐藏参数 this 用于指代当前对象

成员函数的秘密

#include <stdio.h>

class Test
{
    int mi;
public:
    int mj;
    Test(int i);
    Test(const Test& t);
    int getMi();
    void print();
};

Test::Test(int i)
{
    mi = i;
}

Test::Test(const Test& t)
{
    mi = t.mi;
}
    
int Test::getMi()
{
    return mi;
}

void Test::print()
{
    printf("this = %p\n", this);
}

int main()
{
    Test t1(1);
    Test t2(2);
    Test t3(3);
    
    printf("t1.getMi() = %d\n", t1.getMi());
    printf("&t1 = %p\n", &t1);
    t1.print();
    
    printf("t2.getMi() = %d\n", t2.getMi());
    printf("&t2 = %p\n", &t2);
    t2.print();
    
    printf("t3.getMi() = %d\n", t3.getMi());
    printf("&t3 = %p\n", &t3);
    t3.print();
    
    return 0;
}

程序运行结果如下图所示：