C++----类与对象(Base)

最新推荐文章于 2026-02-20 04:37:19 发布

原创最新推荐文章于 2026-02-20 04:37:19 发布 · 1.5k 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

C++ 专栏收录该内容

9 篇文章

订阅专栏

本文介绍了C++中的类与对象概念，包括它们的定义和作用域。讨论了C++如何通过访问限定符实现封装，并阐述了对象模型的存储方式，特别是对象在内存中的布局。此外，还详细解释了this指针的作用及其在成员函数中的应用。

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

类与对象

定义及作用域

C语言中，结构体中只能定义变量，在C++中，结构体还可以定义函数，而且更喜欢用class(默认私有)来代替struct(默认公有)。

class Student {  //声名，class为关键字，Student为类的名字
	char _name[10];  //{}中为类的主体
	void _sex() {  //类内定义
	};
	void _id();  //类内声名  
	//....
};
void Student::_id() {}  //类外定义,类内必须有声名
类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

访问限定符及封装

访问限定符：public，private，protected；作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。

#include<iostream>
using namespace std;
struct B {  //默认公有
	void f() {  
		cout << "B::f()" << endl;
	}
private:  //私有成员
	int _a1;
protected:  //保护成员
	int _a2;
public:  //公有成员
	int _a3;
};
class A {  //默认私有
public:
	void f();
private:
	int _a1;
public:
	int _a2;
protected:
	int _a3;
};
void A::f() {
	cout << "A::f()" << endl;
}
int main() {
	struct B aa;  //兼容C用法
	aa._a3 = 10;
	aa.f();
	//aa._a2 = 10, aa._a1 = 10;  私有和保护成员不可类外访问
	A a;  //A已经是一个类
	a._a2 = 10;
	a.f();
	//a._a2 = 10, a._a1 = 10;  私有和保护成员不可类外访问
	return 0;
}

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。本质上是一种管理：封装类的数据和方法，使用protected和private把成员封装起来，开放一些共有的成员函数对成员合理的访问。

对象模型

存储方式

每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间，所以只保存成员变量，成员函数存放在公共的代码段

类对象大小

#include<iostream>                   
using namespace std;                  //类的大小一定要注意内存对齐，只计算成员变量
class A1 {  //16个字节，以int为对齐
public:
	void f1() {}  //方法不占用类大小，放在公共代码段
	char _n[10];
private:
	int _a;
};
class A2 {  //类中仅有成员函数相当于空类
public:
	void f2() {};
};
class A3 {  //空类
};
class A4 {  //8个字节，vs默认对齐数为8
public:
	void PrintA() {
		cout << _a << endl;
	}
private:
	char _a;
	int _b;
};
int main() {
	cout << sizeof(A1) << sizeof(A2) << sizeof(A3) << sizeof(A4) << endl;
	return 0;
}
一个类的大小，实际就是该类中”成员变量”之和，一定要注意内存对齐;
编译器给空类一个字节来唯一标识这个类。

this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

#include<iostream>
using namespace std;
class Date {
public:
	//void Init(Date* this, int year, int month, int day)
	void Init(int year, int month, int day) {
		this->_year = year;  //等价于 _year = year;
		this->_month = month;  //this只能在“成员函数”的内部使用
		this->_day = day;  ////通过ecx寄存器自动传递
	}
	//void Print(Date* this)  本质是隐含的形参
	void Print() {
		cout << this->_year << "年" << this->_month << "月" << this->_day << "日" << endl;  //可以不加this
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main() {
	Date today;
	Date *p = NULL;  //空指针不能访问类中成员变量，解引用空指针是错误的，但可以访问不需要解引用的数据
	today.Init(2020, 3, 7);
	Date tomorrow;
	tomorrow.Init(2020, 3, 8);
	today.Print();  
	tomorrow.Print();
	return 0;
}