c++学习小结（10.31 深浅构造函数初始化列表静态成员 this指针）

最新推荐文章于 2023-01-26 22:04:03 发布

殷培文enen

最新推荐文章于 2023-01-26 22:04:03 发布

阅读量157

点赞数

分类专栏： c++ 文章标签：学习 c++

本文链接：https://blog.csdn.net/weixin_66455428/article/details/127610425

版权

c++ 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

构造函数的分类及调用

按照参数分类：有参构造和无参构造（默认构造）

按照类型分类：普通构造和拷贝构造

拷贝构造：把传入人的所有属性，拷贝到我身上

	Person(const Person& p)
	{
		age = p.age;
	}

注意事项：

调用默认函数时，不要加（）。

匿名对象：Person（10）；当前行执行结束后，系统会立即回收掉匿名对象

不要利用一个拷贝构造函数去初始化一个匿名对象

隐式转换发：Person p4 = 10; == Person p4 = Person(10)

拷贝函数的调用时机：

1.使用一个已经创建的对象来初始化一个新对象

2.值传递的方式给函数参数传值

3.值方式返回局部对象

void test()
{
        Person p1(10);
        person p2(p1);
        cout << p2.age << endl; //10
}

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person
{
public:

    //无参默认构造函数
    Person(){
        
    }
    //有参构造函数
    Person(int age,int height){
    
    m_age = age;
    m_height = height;
    }
    //拷贝构造函数
    Person (const Person p){
    //如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区的问题
    m_age = p.m_age;
    m_height = new int(*p.m_height);
    }
    //析构函数
    ~Person(){
        if(m_height != NULL)
        {
            delate m_height;
        }
    }
 
};

初始化列表

利用构造函数给属性赋初值

class Person
{
public:

    Person (int a,int b,int c) :m_a(a),m_b(b),m_c(c) { }

    int m_a;
    int m_b;
    int m_c;
};
void test(){
    Person p(10,20,30);
}

类对象作为类成员：

当类中成员是其他类对象是，我们称该成员为对象成员

构造的顺序是：先调用对象成员的构造，再调用本类构造

析构顺序与构造相反

静态成员

静态成员就是在成员变量和成员函数前加上static，称为静态成员

静态成员分为：

·静态成员变量

所有对象共享一份数据

在编译阶段分配内存

类内声明，类外初始化

class Person
{
    static int m_a;
};

int Person::m_a = 100;
//静态成员变量 不属于某个对象上，所有对象都共享同一份数据
//因此静态成员变量有两种访问方式

//通过对象进行访问
Person p;
cout << p.m_a;
//通过类名进行访问
cout << Person::m_a;

·静态成员函数

所有对象共享一个函数

*静态成员函数只能访问静态成员变量

c++对象模型和this指针

在c++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

空对象占用内存空间为：1

每个空对象都有一个独一无二的地址

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会公用一块代码

那么问题是：这一块代码是如何区分哪个对象调用自己的呢？

c++通过提供的对象指针，this指针，this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针，this指针不需要定义，直接使用即可

this指针的用途：

当形参和成员变量同名时，可以用this值针来区分

class Person
{
public:
    Person(int age)
    {
    //this指针指向的是被调用的成员函数所属的对象 p1 
     this->age = age;
    }

    int age;
};
void()
{
    Person p1(18);
    cout << p1.age << endl; //18
}

在类的非静态成员函数中返回对象本身，可以使用return *this

空指针访问成员函数

可以调用，但是要注意有没有this指针

如果用到this指针，需要加以判断保证代码的健壮性

class
{
public:
    
    void showClassName()
    {
        cout << "this is Person class" << endl;
    }

    void showPersonAge()
    {
        cout << m_age << endl;
    }

    int m_age;
};
void test()
{
    Person *p = NULL;
    p.showClassName();  //对
    p.showPersonAge();  //错  m_age自带this->m_age
}

const修饰成员函数

常函数：

成员函数后加const后我们称这个函数为常函数

常函数内不可以修改成员属性

成员属性声明时加关键字mutable，在常函数中依然可以修改

class
{
public:
    //this指针的本质 是指针常量 指针的指向是不可以修改的
    //  = const Person * const this;
    /在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改
    viod showPerson() const
    {
        this->m_a = 100;  //error    
        this->m_b = 100;  //right
    }

    int m_a;
    mutable int m_b;
};

常对象：

声明对象前加const称该对象为常对象

常对象只能调用常函数