C++：类与对象（一）

最新推荐文章于 2024-11-01 21:21:02 发布

青旋.

最新推荐文章于 2024-11-01 21:21:02 发布

阅读量621

点赞数 24

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2302_79054145/article/details/137075466

版权

C++ 专栏收录该内容

22 篇文章 0 订阅

订阅专栏

本文详细介绍了C++中类的引入、定义、访问控制（封装）、作用域、实例化，以及类的对象模型，重点讲解了this指针的原理和其在成员函数中的使用。

摘要由CSDN通过智能技术生成

类的引入

在C语言中“struct”只能用来定义变量，而在C++中“struct”不但可以用来定义变量还可以定义函数。自此结构体升级成了类，在类中定义的变量叫做成员变量，在类中定义的函数称为成员函数或者成员方法，不过一般C++定义类时更喜欢用“class”关键字。

#include<iostream>
using namespace std;

typedef int DataType;
struct Stack
{
	void Init(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(const DataType& data)
	{
		// 扩容
		_array[_size] = data;
		++_size;
	}
	DataType Top()
	{
			return _array[_size - 1];
	}
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	DataType* _array;
	size_t _capacity;
	size_t _size;
};
int main()
{
	Stack s;
	s.Init(10);
	s.Push(1);
	s.Push(2);
	s.Push(3);
	cout << s.Top() << endl;
	s.Destroy();
	return 0;
}

类的定义

class为定义类的关键字，Name为类的名字，{}中为类的主体，注意类定义结束时后面分号。类中的元素称为类的成员，类中的数据称为类的属性或者成员变量，类中的函数称为类的方法或者成员函数。

类有两种声明：

将类的声明和定义全部放在类中定义
在头文件中放类的声明，在源文件中放类的定义

类的访问限定符

类中内容包括数据（数据成员）和函数（成员函数）
按照访问权限划分：公有、保护、私有

public修饰的成员在类外可以直接被访问
protected和private修饰的成员在类外不能直接被访问(这方面protected和private是类似的)
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
如果后面没有访问限定符，作用域就到} 即类结束。
class的默认访问权限为private，struct为public(因为struct要兼容C语言)

class 类名{
    public：
        公有数据成员;
        公有成员函数;
    protected:
        保护数据成员;
        保护成员函数;
    private:
        私有数据成员;
        私有成员函数;
};

封装

面向对象的三大特性： 封装、继承、多态 。

将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

类的作用域

每个类都定义了自己的作用域，类的成员(成员函数/成员变量)都在类的这个作用域内，成员函数内可任意访问成员变量和其它成员函数。
对象可以通过 . 直接访问公有成员，指向对象的指针通过 -> 也可以直接访问对象的公有成员。
在类体外定义成员，需要使用 :: 作用域解析符指明成员属于哪个类域。

class Person
{
public:
	 void PrintPersonInfo();
private:
	char _name[20];
	 char _gender[3];
	 int _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
	 cout<<_name<<" "_gender<<" "<<_age<<endl;
}

类的实例化

类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。

可以理解为，类就是一个建筑图纸，其规定了一个建筑有哪些房间，房间大小，尺寸等等。但是图纸是不可以住人的，也就是说还不是一个可以使用的屋子，此时就需要实例化，根据图纸把屋子建出来。

class Person
{
public:
	 void PrintPersonInfo();
private:
	 char _name[20];
	 char _gender[3];
	 int _age;
};
void Test()
{
	Person man;
	man._name = "Peter";
	man._age = 10;
	man._sex = "男";
	man.PrintPersonInfo();

}

类的对象模型

一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类（包括没有成员变量的类）的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。（比如如果现在给了C1,C2,C3三个空类，如果不给内存，那就无法区分这3个类）

class A
{
public:
	void TestFunc()
	{}


	int _a;
	char _b;
};

class B
{
public:
	void TestFunc()
	{}
};

// 空类
class C
{};


// 类大小的计算方式：类成员变量加起来 + 内存对齐
// 求结构体大小一模一样

// 空类和没有类成员变量的类的大小为一个字节
int main()
{
	cout << sizeof(A) << endl;
	cout << sizeof(B) << endl;
	cout << sizeof(C) << endl;
	system("pause");
	return 0;
}

this指针

class Date
{ 
public :
 void Display ()
 {
	 cout <<_year<< "-" <<_month << "-"<< _day <<endl;
 }
 
 void SetDate(int year , int month , int day)
 {
	 _year = year;
	 _month = month;
	 _day = day;
 }
private :
	 int _year ; // 年
 	int _month ; // 月
	 int _day ; // 日
};
int main()
{
	 Date d1, d2;
	 d1.SetDate(2018,5,1);
	 d2.SetDate(2018,7,1);
	d1.Display();
 	d2.Display();
 	return 0;
}

对于上述类，有这样的一个问题：
Date类中有SetDate与Display两个成员函数，函数体中没有关于不同对象的区分，那当s1调用SetDate函数时，该函数是如何知道应该设置s1对象，而不是设置s2对象呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

this指针特性

this指针的类型：类类型* const
只能在“成员函数”的内部使用
this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

this指针本质是成员函数形参，自然存放在内存中的栈区中，不同编译器存放的位置不同，vs编译器是通过ecx寄存器存储的

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
	void Show()
	{
		cout << "Show()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	p->Show();
}

调用PrintA函数

调用Show函数

为什么都是空指针调用函数，结果却不一样

调用成员函数的时候会把成员地址也传过去，成员地址就是p指针，把p指针传过去，成员函数会用this指针接受传过来的地址，PrintA函数的this指针接收到的是空指针，然后用this指针去访问成员变量_a，这样就对空指针解引用了，所以会报错，调用Show函数没有对this指针去访问成员变量，只是简单把p传递给了this指针，也就不存在对空指针解引用，所以正常打印（成员函数的地址不在对象中存储，而是存储在公共代码段）。