【C++初阶】—— 类和对象 (上）

@TOC

---

前言：在前面几节我们为正式进入C++做足了铺垫，现在我们有了足够的基础让我们进入C++，让我们来进入类和对象来真正了解C++！

本篇主要内容： 类的相关知识 this指针

---

1. 初步认识C++

1. 我们知道之前学习的C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

2. C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成

举个例子，就像我们洗衣服，在C语言中我们需要一步一步按过程操作来手洗，而C++则是有了很多对象，对象间相互交互来完成洗衣服！

---

2. 类的引入

C语言结构体中只能定义变量，不可以定义函数，但是在C++中，结构体内不仅可以定义变量，也可以定义函数。

登录后复制

struct pxt
{
	char b[100] = { "hello world!" };

	int a = 2024;

	void test()
	{
		cout << "hello world!" << endl;
	}

};
int main()
{
	pxt xyyj;
	xyyj.test();
	cout << xyyj.b << endl;
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.

上面结构体的定义就是类，但在C++中更喜欢用class来代替

---

3. 类的定义

登录后复制

// C++中更喜欢用class
class className
{
	// 类体：由成员函数和成员变量组成
};  
// 一定要注意后面的分号

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.

• class为定义类的关键字，className为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略
• 类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数

类的两种定义方式：

• 声明和定义全部放在类体中
• 声明和定义分开存放

---

声明和定义全部放在类体中

登录后复制

class pxt
{
	int a = 2024;
	char b[100] = { "hello world!" };
	int c = 666;
	void test()
	{
		cout << b << " " << a << " " << c << endl;
	}
};
int main()
{
	pxt xyyj;
	xyyj.test();
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.

注意： 成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

声明和定义分开存放

登录后复制

// func.h
class pxt
{
	int a = 2024;

	char b[100] = { "hello world!" };

	int c = 666;

	void test();
};
// func.cpp
void test()
{
	cout << b << " " << a << " " << c << endl;
}
// test.c
int main()
{
	pxt xyyj;
	xyyj.test();
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.

如果这样声明和定义那么将无法完成编译！

test在func.cpp中找不到pxt类中的成员变量

登录后复制

// 因此我们应该指明在pxt中寻找，否则可能以为定义一个新函数
void pxt::test()
{
	cout << b << " " << a << " " << c << endl;
}

• 1.
• 2.
• 3.
• 4.
• 5.

---

4. 类的访问限定符

访问限定符说明：

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

登录后复制

class pxt
{
public:
	void test()
	{
		cout << b << " " << a << " " << c << endl;
	}
private:
	int a;
	char b[100] = { "hello world!" };
	int c;
};
int main()
{
	pxt xyyj;
	xyyj.test();
	//cout << xyyj.b << endl; // 无法运行
	//cout << xyyj.a << endl; // 无法运行
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.

public修饰的成员是共有的,类外可以访问 private修饰的的成员是私有的类外不能访问

注意：成员函数不管成员变量是私有还是公有，它都能直接访问，因为它们都属于这个类

---

5. 类的实例化

用类类型创建对象的过程，称为类的实例化

• 类是对对象进行描述的，定义出一个类并没有分配实际的内存空间来存储它
• 实例化出的对象 占用实际的物理空间，存储类成员变量

登录后复制

// 在没有实例化之前并不会占用实际物理空间
class pxt
{
public:
	......
private:
	int a;
};

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.

类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图

---

6. 类对象模型

如何计算类对象的大小

登录后复制

class pxt
{
public:
	void test()
	{
		cout << b << " " << a << endl;
	}
private:
	int a;
	char b;
};
class xyyj
{
public:
	int a;
	char b;
};
int main()
{
	cout << "pxt -> sizeof: " << sizeof(pxt) << endl;
	cout << "xyyj -> sizeof: " << sizeof(xyyj) << endl;
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.

在学C语言结构体的时候我们讲过结构体内存对齐规则，那么C++中多了个函数该怎么计算呢，我们先来看看结果

初步结论：

• 类的成员函数不算在类的大小中
• 类的大小遵守结构体内存对齐规则

---

类对象的存储方式

好家伙，两个类结果居然是一样的，这到底是什么情况？为啥类中的成员函数不占空间?

这其实和类对象的存储方式有关——只保存成员变量，成员函数存放在公共的代码段

每个对象虽然实例化的值不一样，但是调用的函数是相同的，将函数单独放在一个区域能节省空间

综上所述：

• 类的成员函数不算在类的大小中
• 类的大小遵守结构体内存对齐规则
• 空类的大小是一个字节，用来唯一标识这个类的对象

忘了结构体内存对齐的可以复习一下：  结构体内存对齐

---

7. this指针

我们先来定义一个日期类：

登录后复制

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;
	d1.Init(2024, 5, 20);
	d2.Init(2024, 5, 21);
	d1.Print();
	d2.Print();
	return 0;
}

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.

那么Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

• C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问

---

this指针的特性

this指针的特性：

• this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
• 只能在“成员函数”的内部使用
• this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
• this指针是“成员函数”第一个隐含的指针形参，不需要用户传递

虽然我们知道成员函数中存在this指针，但是我们传参不能传this指针

登录后复制

public:
	// 绝对不能这么定义
	void Init(Date*this, int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	} // false

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.

使用this指针将对象的地址传入函数中函数体就可以区分不同对象了

---

8. 总结

本章是类和对象的第一课，我们简单了解了类的基本概念和特性和this指针，this指针对后面用处很大，类在C++是很重要的希望大家能打好基础！

谢谢大家支持本篇到这里就结束了

原创作者: u_16979453 转载于: https://blog.51cto.com/u_16979453/11854491