[C++核心编程-06]----C++类和对象之对象模型和this指针

一伦明悦

于 2024-05-10 21:41:33 发布

阅读量1k

点赞数 27

分类专栏： C++核心编程学习文章标签： c++ 开发语言 c语言学习方法学习

本文链接：https://blog.csdn.net/m0_59951855/article/details/138681945

版权

C++核心编程学习专栏收录该内容

11 篇文章 0 订阅

订阅专栏

🎩 欢迎来到技术探索的奇幻世界👨‍💻

📜 个人主页：@一伦明悦-CSDN博客

✍🏻 作者简介： C++软件开发、Python机器学习爱好者

🗣️ 互动与支持：💬评论 👍🏻点赞 📂收藏 👀关注+

如果文章有所帮助，欢迎留下您宝贵的评论，点赞加收藏支持我，点击关注，一起进步！

引言

在C++中，类是一种用于描述一类对象的数据结构，而对象则是根据类定义创建的实例。类定义了对象的属性和方法，而对象是类的具体实例化。在C++中，类和对象一起构成了面向对象编程的基础。

在C++中，对象模型是用来描述类和对象之间关系的一种模型。在C++中，每个对象都有自己的一组成员变量和方法，这些成员变量和方法定义在类中。当创建一个对象时，该对象会占用一些内存空间来存储其成员变量，并且会有一个指向类的指针，这个指针指向该对象所属的类。

this指针是一个隐含的指针，它指向当前对象的地址。在类的成员函数中，可以使用this指针来访问当前对象的成员变量和方法。this指针的类型是指向当前类的指针。

正文

01-对象模型和this指针简介

在C++中，对象模型和this指针是面向对象编程的两个重要概念，它们有助于理解类和对象之间的关系以及在类的成员函数中操作对象的方式。

对象模型：

对象模型是用来描述类和对象之间关系的一种模型，它包括了对象的内存布局和对象访问的机制。在C++中，每个对象都有自己的一组成员变量和方法，这些成员变量和方法定义在类中。当创建一个对象时，该对象会占用一些内存空间来存储其成员变量，并且会有一个指向类的指针，这个指针指向该对象所属的类。

this指针：

this指针是一个隐含的指针，它指向当前对象的地址。在类的成员函数中，可以使用this指针来访问当前对象的成员变量和方法。this指针的类型是指向当前类的指针。通过this指针，可以在成员函数中区分当前对象和其他对象。

详细总结：

（1）对象模型：

a、对象模型描述了类和对象之间的关系，包括对象的内存布局和访问机制。

b、每个对象都有自己的一组成员变量和方法，这些成员定义在类中。

c、创建对象时，会为其分配内存空间，并有一个指向类的指针。

（2）this指针：

a、this指针是一个隐含的指针，在类的成员函数中自动被创建。

b、this指针指向当前对象的地址，允许在成员函数中访问当前对象的成员变量和方法。

c、可以用来区分当前对象和其他对象，在处理对象自身的操作时非常有

下面是一个简单的示例，展示了对象模型和this指针的使用：

在上面的示例中，定义了一个名为MyClass的类，该类有一个成员变量value和两个成员函数setValue和printValue。在setValue函数中，使用this指针来设置当前对象的value值，在printValue函数中，使用this指针来打印当前对象的value值。

在main函数中创建了两个MyClass的对象obj1和obj2，分别调用了setValue和printValue函数来设置和打印对象的value值。

通过这个示例，可以看到类和对象之间的关系以及如何使用this指针来操作当前对象的成员变量和方法。

#include <iostream>

class MyClass {
public:
    int value;

    void setValue(int value) {
        this->value = value; // 使用this指针设置当前对象的value值
    }

    void printValue() {
        std::cout << "Value: " << this->value << std::endl; // 使用this指针打印当前对象的value值
    }
};

int main() {
    MyClass obj1;
    MyClass obj2;

    obj1.setValue(10);
    obj2.setValue(20);

    obj1.printValue(); // 打印obj1的value值
    obj2.printValue(); // 打印obj2的value值

    return 0;
}

02-成员变量和成员函数分开存储

在C++中，成员变量和成员函数是分开存储的，这是为了提高内存的利用率和程序的执行效率。成员变量存储在对象的内存空间中，而成员函数则存储在类的代码段中，所有对象共享同一份成员函数的代码。

成员变量存储：

成员变量是属于对象的数据，每个对象都有自己的一份成员变量。当创建一个对象时，系统会为其分配内存空间来存储成员变量，这些成员变量的大小取决于其类型和数量。每个对象的成员变量存储在其所占用的内存空间中，不同对象的成员变量是相互独立的。

成员函数存储：

成员函数是属于类的行为，它们被定义在类的内部，但并不存储在对象的内存空间中。相反，成员函数的代码只存储了一份，它们被存储在类的代码段中。所有属于同一个类的对象共享同一份成员函数的代码，这样可以节省内存空间。

详细解释：

（1）成员变量存储：

a、成员变量是对象的数据，每个对象都有自己的一份成员变量。

b、当创建对象时，系统会为其分配内存空间来存储成员变量。

c、不同对象的成员变量存储在各自的内存空间中，彼此独立。

（1）成员函数存储：

a、成员函数是类的行为，它们被定义在类的内部。

b、成员函数的代码存储在类的代码段中，而不是存储在对象的内存空间中。

c、所有属于同一个类的对象共享同一份成员函数的代码，这样可以节省内存空间。

下面是一个简单的示例，展示了成员变量和成员函数的存储方式：在这个示例中，可以看到成员变量value存储在每个对象的内存空间中，而成员函数setValue和getValue的代码只存储了一份，它们被所有对象共享。

#include <iostream>

class MyClass {
public:
    int value; // 成员变量

    void setValue(int val) { // 成员函数
        value = val; // 访问成员变量
    }

    int getValue() { // 成员函数
        return value; // 返回成员变量的值
    }
};

int main() {
    MyClass obj1, obj2; // 创建两个对象

    obj1.setValue(10); // 设置对象1的值
    obj2.setValue(20); // 设置对象2的值

    std::cout << "Value of obj1: " << obj1.getValue() << std::endl; // 获取并打印对象1的值
    std::cout << "Value of obj2: " << obj2.getValue() << std::endl; // 获取并打印对象2的值

    return 0;
}

下面给出具体的代码进行分析成员变量和成员函数的使用过程：

这个示例展示了C++中成员变量和成员函数分开存储的情况。在这个示例中，定义了一个名为Person的类，其中包括了非静态成员变量m_A，静态成员变量m_B，非静态成员函数func和静态成员函数func1。

在函数test01中创建了一个Person对象p，并使用sizeof操作符来输出对象p所占用的字节数。即使对象p是空的，C++编译器也会分配一个字节的空间来区分空对象的内存位置，确保每个对象都有一个独一无二的内存地址。

在函数test02中再次创建了一个Person对象p，并输出其占用的字节数，结果应该和test01中的一样。

通过这个示例可以看到，在C++中，即使是空对象也会占用一定的内存空间，同时也展示了成员变量和成员函数分开存储的情况。

#include <iostream>
using namespace std;

// 成员变量和成员函数分开存储
class Person
{
	int m_A;   // 非静态成员变量   属于类对象上
	static int m_B;  // 静态 不属于类对象上
	void func() {}  // 非静态成员函数，也不属于类对象上
	static void func1() {}  // 静态成员函数 不属于类对象上
};

void test01()
{
	Person p;
	// 空对象占用字节
	// C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象所占内存的位置
	// 每个空对象也应该有一个独一无二的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}

void test02()
{
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}

int main()
{
	test02();

	system("pause");
	return 0;
}

示例运行结果如下图所示：

03-this指针

在C++中，this指针是一个隐含的指针，它指向当前对象的地址。this指针在类的成员函数中自动被创建，并且可以用来访问当前对象的成员变量和成员函数。通过this指针，可以在成员函数中区分当前对象和其他对象，从而实现对当前对象的操作。

详细解释：

（1）this指针的作用：

a、this指针指向当前对象的地址，允许在成员函数中访问当前对象的成员变量和成员函数。

b、当多个对象同时存在时，this指针可以帮助区分当前对象和其他对象，确保操作的是正确的对象。

（2）this指针的类型：

a、this指针的类型是指向当前类的指针，因此在成员函数中可以直接访问当前类的成员。

b、在成员函数中，可以通过this->成员变量或this->成员函数的方式来访问当前对象的成员变量和成员函数。

（3）this指针的隐含性：

a、在类的成员函数中，this指针是隐含的，不需要显式地声明或传递。

b、当调用成员函数时，编译器会自动将当前对象的地址传递给this指针。

接下来给出具体代码分析展示了this指针的使用：详细解释代码如下：

这段代码演示了如何使用this指针在C++中访问对象的成员变量。在类MyClass中，定义了一个私有成员变量value和两个公有成员函数setValue和getValue。在setValue函数中，使用了this指针来设置当前对象的value值，而在getValue函数中，使用this指针来获取当前对象的value值。

在main函数中，创建了两个MyClass对象obj1和obj2，分别设置了它们的value值为10和20，并通过调用getValue函数获取并打印了它们的value值。

这段代码展示了this指针的隐含性和作用，通过this指针可以在成员函数中准确地访问当前对象的成员变量，确保操作的是正确的对象。

#include <iostream>

class MyClass {
private:
    int value;

public:
    void setValue(int value) {
        this->value = value; // 使用this指针设置当前对象的value值
    }

    int getValue() {
        return this->value; // 使用this指针获取当前对象的value值
    }
};

int main() {
    MyClass obj1, obj2;

    obj1.setValue(10); // 设置obj1的value值
    obj2.setValue(20); // 设置obj2的value值

    std::cout << "Value of obj1: " << obj1.getValue() << std::endl; // 获取并打印obj1的value值
    std::cout << "Value of obj2: " << obj2.getValue() << std::endl; // 获取并打印obj2的value值

    return 0;
}

下面给出具体的代码进行分析this指针的使用过程：这个示例展示了在C++中使用this指针解决名称冲突和返回对象本身的情况。在这个示例中，定义了一个名为Person的类，其中包括了一个构造函数和成员函数PersonAddAge，以及一个整型成员变量age。

解决名称冲突：在函数test01中，创建了一个Person对象p1并初始化其年龄为18，在构造函数中使用了this指针来设置对象的年龄。通过this指针，可以准确地访问当前对象的成员变量，避免与函数参数或局部变量发生冲突。

返回对象本身：在函数test02中，创建了两个Person对象p1和p2，并多次调用PersonAddAge函数来累加p1对象的年龄到p2对象。在PersonAddAge函数中，使用了this指针来访问当前对象的成员变量，同时返回值类型为Person&，表示返回的是当前对象的引用，实现了对同一个对象连续调用多次函数的链式操作。

在test02函数中，通过链式调用的方式，三次调用PersonAddAge函数将p1对象的年龄累加到p2对象中，最终输出了p2对象的年龄。

值得注意的是，在链式调用时需要确保PersonAddAge函数返回的是当前对象的引用(*this)，这样才能保证连续调用的有效性。

通过这个示例，展示了this指针在成员函数中的作用，以及如何使用this指针解决名称冲突和实现返回对象本身的功能。

#include <iostream>
using namespace std;

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

	Person& PersonAddAge(Person &p)
	{
		this->age += p.age;
		return *this;   // this指向的是p2的指针，而*this指向的就是p2这个对象本体
	}

	int age;   // 这里一般会定义的时候，尽量与构造函数传入的参数分辨清楚，或者在构造函数里加入this
};

// 1、解决名称冲突
void test01()
{
	Person p1(18);
	cout << "p1的年龄： " << p1.age << endl;

}


// 2、返回对象本身用 return *this 且返回值类型，为该对象的类，加引用方式返回

void test02()
{
	Person p1(10);

	Person p2(10);

//	p2.PersonAddAge(p1);
	// 若想使用链式的方法多次相加，需要进行成员函数更改
	/* 具体方面如下
	   1、当成员函数PersonAddAge()执行一次之后，返回值是void
	   2、返回值是void，当然不能再对该成员函数进行调用，因此，返回值必须是p2才可以
	   3、而这里说了返回对象本身用 return *this 且返回值类型，为该对象的类，加引用方式返回
	   4、因此改成

	   Person &PersonAddAge(Person &p)
	   {
	        this->age += p.age;
			return *this;
	   }
	*/
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);


	cout << "p2的年龄为：" <<p2.age<< endl;

}

int main()
{
	//test01();
	test02();

	system("pause");
	return 0;
}

示例运行结果如下图所示：

04-空指针访问成员函数

在C++中，空指针访问成员函数是指在一个空指针上调用成员函数的情况。空指针是指未指向任何有效对象的指针，即其存储的地址为0或nullptr。当尝试在空指针上调用成员函数时，由于没有有效对象来执行函数，可能会导致程序崩溃或未定义的行为。

空指针的含义：

空指针是指未指向任何有效对象的指针，通常表示为nullptr（在C++11及以后版本）或0（在较早的C++版本中）。

空指针不指向任何有效的内存地址，因此在其上调用成员函数将导致未定义的行为。

空指针访问成员函数的影响：

当在空指针上调用成员函数时，由于没有有效的对象来执行函数体，程序可能会发生崩溃或产生未定义的行为。

这是因为成员函数通常需要访问对象的成员变量或其他成员函数，而空指针并不指向任何对象，因此无法执行成员函数的操作。

下面是一个简单的示例，演示了空指针访问成员函数的情况：

在这个示例中，创建了一个名为MyClass的类，其中包含一个成员函数printMessage用于打印消息。在main函数中，创建了一个空指针ptr，并尝试在其上调用printMessage成员函数。

然而，由于ptr是一个空指针，它并不指向任何有效的对象，因此在调用printMessage函数时将导致未定义的行为，可能会导致程序崩溃或产生其他意外结果。

#include <iostream>

class MyClass {
public:
    void printMessage() {
        std::cout << "Hello, world!" << std::endl;
    }
};

int main() {
    MyClass* ptr = nullptr; // 创建一个空指针

    ptr->printMessage(); // 尝试在空指针上调用成员函数

    return 0;
}

解决方法：

为了避免空指针访问成员函数导致的问题，可以在调用成员函数之前进行空指针的有效性检查，确保指针不为空才进行调用。例如：通过这样的有效性检查，可以避免空指针访问成员函数带来的潜在问题，增加程序的健壮性和稳定性。

if (ptr != nullptr) {
    ptr->printMessage();
} else {
    // 处理空指针的情况，如输出错误信息或进行其他操作
    std::cerr << "Error: Pointer is null." << std::endl;
}

下面给出具体代吗分析应用：

#include <iostream>
using namespace std;

// 空指针调用成员函数

class Person
{
public:
	
	void showClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		// 这里传入的指针为空，将会报错
		if (this == NULL)   // 这个判断可以防止传入空指针出错
		{
			return;
		}
		cout << "年龄age = " << m_Age << endl;
	}
	int m_Age;
};

void test01()
{
	Person *p = NULL;
	p->showClassName();

	// 这里出错，主要原因如下
	/* 1、cout << "年龄age = " << m_Age << endl;这句代码里m_Age这里默认是this->m_Age
	   2、但是这里定义的对象只是一个空指针，对于一个空指针来说，访问里面的成员是不可能的
	*/
	p->showPersonAge();

}



int main()
{
	test01();
	//test02();

	system("pause");
	return 0;
}

示例运行结果如下图所示：

总结

在C++中，对象模型和this指针是面向对象编程的两个重要概念，它们有助于理解类和对象之间的关系以及在类的成员函数中操作对象的方式。

一伦明悦

关注

27
点赞
踩
21

收藏

觉得还不错? 一键收藏
打赏
2
评论
[C++核心编程-06]----C++类和对象之对象模型和this指针

在C++中，对象模型和this指针是面向对象编程的两个重要概念，它们有助于理解类和对象之间的关系以及在类的成员函数中操作对象的方式。对象模型是用来描述类和对象之间关系的一种模型，它包括了对象的内存布局和对象访问的机制。在C++中，每个对象都有自己的一组成员变量和方法，这些成员变量和方法定义在类中。当创建一个对象时，该对象会占用一些内存空间来存储其成员变量，并且会有一个指向类的指针，这个指针指向该对象所属的类。this指针是一个隐含的指针，它指向当前对象的地址。
复制链接

扫一扫