C++面向对象编程之四：成员变量和成员函数分开存储、this指针、const修饰成员和对象

微尘8

已于 2023-03-11 18:46:01 修改

阅读量685

点赞数 3

分类专栏： C/C++程序设计教程文章标签： c++ 开发语言算法 Powered by 金山文档

于 2023-03-09 14:36:05 首次发布

本文链接：https://blog.csdn.net/d704791892/article/details/129413923

版权

C/C++程序设计教程专栏收录该内容

17 篇文章 1 订阅

订阅专栏

在C++中，成员变量和成员函数是分开存储的，只有非静态成员变量才存储在类中或类的对象上。通过该类创建的所有对象都共享同一个函数

#include <iostream>
using namespace std;

class Monster
{
    public:
    //成员函数不占对象空间，所有对象共享同一个函数
    Monster():m_monsterId(0)
    {

    }
    //成员函数不占对象空间，所有对象共享同一个函数
    Monster(const int monsterId):m_monsterId(monsterId)
    {

    }
    //成员函数不占对象空间，所有对象共享同一个函数
    Monster(const Monster &m)
    {
        m_monsterId = m.m_monsterId;
    }
    //成员函数不占对象空间，所有对象共享同一个函数
    ~Monster()
    {

    }

    //静态成员函数存储在全局静态区，不占对象空间
    static void setMonsterCounter(const int counter)
    {
        ms_counter = counter;
    }

    //静态成员函数存储在全局静态区，不占对象空间
    static int getMonsterCounter()
    {
        return ms_counter;
    }

    private:
    //静态成员变量存储在全局静态区，不占对象空间
    static int ms_counter; //计数

    //非静态成员变量，占对象空间
    int m_monsterId; //怪物id
};

int Monster::ms_counter = 0;

int main(int argc, char *argv[])
{
    cout << "sizeof(Monster) = " << sizeof(Monster) << endl;
    Monster m;
    cout << "sizeof(m) = " << sizeof(m) << endl;

    return 0;
}

在C++中，空类占用内存大小为一个字节，因为即使是一个空对象，也要分配存储空间来识别这个空对象，所以C++分配了一个字节大小的空间给每一个空对象。

#include <iostream>
using namespace std;

class Monster
{

};

int main(int argc, char *argv[])
{
    Monster m;

    cout << "空类占用内存大小为：" << sizeof(Monster) << endl;
    cout << "空对象占用内存大小为：" << sizeof(m) << endl;

    return 0;
}

C++中成员变量和成员函数是分开存储的，只有非静态成员变量才存储在类中或类的对象上。不管通过该类创建了多少对象，该类的每一个非静态成员函数只有一份，所有对象都同享非静态成员函数，那么这些非静态成员函数是如何区分是哪个对象调用自己的呢？C++通过this指针，解决这个问题。

this指针的特点：

this指针隐含在每一个非静态成员函数内，每一个非静态成员函数都隐含有一个this指针。当对象调用非静态成员函数时，this指针指向该对象。

this指针是是在非静态成员函数的开始前构造，并在非静态成员函数的结束后清除的，不需要声明，直接使用即可。

this指针的本质是指针常量，存储了调用该非静态成员函数的对象的地址，所以this指针的指向是不可以修改的。

注意：这里我们一直强调：每一个非静态成员函数都隐含有一个this指针，静态成员函数是没有this指针的，所以静态成员函数的函数体内只能访问静态成员变量和静态成员函数，不能访问非静态成员变量和非静态成员函数。

this指针的作用：

在类的非静态成员函数中，形参和成员变量同名时，可以通过this指针来指明是对象的成员，还是形参名。

在类的非静态成员函数中需要返回该对象时，通过使用：return *this; 返回该对象自身。

#include <iostream>
using namespace std;

class Monster
{
    public:
    Monster():monsterId(0)
    {

    }
    
    //这里通过对象初始化列表的方式，是可以区分:monsterId是成员变量，(monsterId)是形参的
    //而且对象初始化列表中不能用:this->monsterId(monsterId)
    Monster(const int monsterId):monsterId(monsterId)
    {

    }
    Monster(const Monster &m):monsterId(m.monsterId)
    {

    }

    ~Monster()
    {

    }

    Monster& getSelf()
    {
        return *this; //返回对象本身
    }

    // static Monster& getSelfByStatic()
    // {
    //     return *this; //错误：非静态成员函数没有this指针
    // }

    void setMonsterId(const int monsterId)
    {
        this->monsterId = monsterId; //形参和成员变量同名，所以需要用this指针区分，不然编译器不知道monsterId是成员变量还是形参
    }

    int getMonsterId()
    {
        return monsterId;
    }

    private:
    int monsterId;
};

int main(int argc, char *argv[])
{
    Monster m(10001);
    cout << "怪物id = " << m.getMonsterId() << endl;
    m.setMonsterId(10002);
    cout << "怪物id = " << m.getSelf().getMonsterId() << endl;

    return 0;
}

注意：通过对象初始化列表的方式，是可以区分:monsterId是成员变量，(monsterId)是形参的，而且对象初始化列表中不能用:this->monsterId(monsterId)，编译器会报错的

//这里通过对象初始化列表的方式，是可以区分:monsterId是成员变量，(monsterId)是形参的
//而且对象初始化列表中不能用:this->monsterId(monsterId)，编译器会报错的
Monster(const int monsterId):monsterId(monsterId)
{

}

C++中是允许空指针调用成员函数的，这时this = NULL；所以在非静态成员函数中，如果用到this指针，应该在用到this指针前，加以判断this指针是否为NULL。但是在程序设计的过程中，我们应该尽量禁用用空指针调用成员函数，稍微不注意，可能会导致我们的程序出现崩掉的情况。

const修饰的类成员

常量成员变量：在成员变量前，用const修饰该的成员变量（eg：const int m_monsterId;）。常量成员变量只能在构造函数中用初始化列表进行初始化，并且初始化后不能再修改。

常量成员函数：在成员函数后加上const修饰的成员函数（eg：void getMonsterId() const），也叫常函数。常量成员函数不能修改普通的成员属性，但常量成员函数可以对有mutable修饰的成员属性进行修改。

常对象

const修饰的对象叫常对象，常对象只能调用常函数

#include <iostream>
using namespace std;

class Monster
{
    public:
    Monster():m_monsterId(0), m_name("怪物"), m_blood(500)
    {

    }
    Monster(const int monsterId, const string name, const int blood):m_monsterId(monsterId), 
                                                                     m_name(name), m_blood(blood)
    {

    }
    Monster(const Monster &m):m_monsterId(m.m_monsterId), m_name(m.m_name), m_blood(m.m_blood)
    {
        //m_name = m.m_name; //错误：常量成员属性只能用初始化列表进行初始化，这句调用编译器会报错
    }
    ~Monster()
    {

    }

    void setMonsterId(const int monsterId)
    {
        m_monsterId = monsterId;
    }
    int getMonsterId() const
    {
        //m_monsterId = 0; //错误：常函数不能修改普通成员变量的值
        return m_monsterId;
    }

    void setName(const string name)
    {
        //m_name = name; //错误：m_name是常量成员属性，不能修改
    }
    string getName() const
    {
        return m_name;
    }

    void setBlood(const int blood) const
    {
        m_blood = blood; //正确：常函数可以修改用mutable修饰的成员属性
    }
    int getBlood()
    {
        return m_blood;
    }

    int getCounter()
    {
        return ms_counter;
    }

    private:
    int m_monsterId; //怪物id
    const string m_name; //怪物名字  常量成员属性
    mutable int m_blood; //血量

    static int ms_counter;
};
int Monster::ms_counter = 0;

int main(int argc, char *argv[])
{
    Monster m1(10001, "雪女", 10000);
    cout << "怪物id = " << m1.getMonsterId() << "，怪物名字 = " << m1.getName() << "，怪物血量 = " << m1.getBlood() << endl;

    const Monster m2(20001, "紫衣仙子", 20000);
    cout << "怪物id = " << m2.getMonsterId() << endl; //正确：常对象可以调用常函数
    //m2.setMonsterId(20002); //错误：常对象不可以调用普通成员函数
    //m2.getCounter(); //错误：常对象不可以调用静态成员函数
    return 0;
}

类的静态(static)成员和常量(const)成员是两个不同的概念，我们不应该混淆

类的静态成员

static成员变量

所有对象共享一份数据

在编译阶段分配内存

类内声明，类外初始化

有（public，protected，private）访问权限

static成员函数（在成员函数前加 static）

所有对象共享一个函数

静态成员函数的函数体内只能访问静态成员变量或静态成员函数，不能访问非静态成员变量和非静态成员函数

有（public，protected，private）权限

微尘8

关注

3
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
C++面向对象编程之四：成员变量和成员函数分开存储、this指针、const修饰成员和对象

在C++中，成员变量和成员函数是分开存储的，只有非静态成员变量才存储在类中或类的对象上。通过该类创建的所有对象都共享同一个函数。在C++中，空类占用内存大小为一个字节。this指针隐含在每一个非静态成员函数内，每一个非静态成员函数都隐含有一个this指针。当对象调用非静态成员函数时，this指针指向该对象。const成员函数（常函数）不能修改普通的成员属性，但常量成员函数（常函数）可以对有mutable修饰的成员属性进行修改。const修饰的对象叫常对象，常对象只能调用常函数。
复制链接

扫一扫