C++：类和对象（上）

qz_Serene2026-08-15 17:23

1.类的定义

2.实例化
3.this指针
4.类的默认成员函数
5.构造函数

1.类的定义
1.1类定义格式

class是类的关键字，相当于结构体的struct的升级版本，class的后面是类的名字（自己定义），{}内是类的主体，类体内可以有成员变量(类的属性)，还可以拥有成员函数(类的⽅法).

！！！class的{}后面要加上； 这个和结构体一样。但是struct 的成员变量默认是公有的 ，class 的成员变量默认是私有的 。并且定义在类中的函数默认是inline的。

了解类之前我们先了解一下struct在C++和C语言中不同的地方

cpp 复制代码 
// C++兼容C中struct的用法
typedef struct ListNodeC
{
	struct ListNodeC* next;
	int val;
}LTNode;


// 升级成类
struct ListNodeCPP
{
	void Init() {}

	ListNodeCPP* next;
	int val;
};


int main() {
	LTNode n1;
	//ListNodeC n3;报错

	ListNodeCPP n2;
}

C++支持C语言中struct的用法，同时它在struct的基础上又进行了加强，C++不需要struct就可以直接利用类名进行定义变量，而C语言就会直接报错，因为它没有typedef新定义的名字时，在定义变量时就必须加上struct，没有就报错。

1.2访问限定符

1、访问权限作用域从该访问限定符出现的位置 开始直到下一个访问限定符出现时为止 ，如果后面没有访问限定符，作用域就到}即类结束 。

2、class定义成员没有被访问限定符修饰时默认为private ，struct默认为public。

3、C++一种实现封装 的方式，用类将对象的属性和方法结合在一块，通过访问权限选择性地将接口提供给外部的用户使用。

4、public 修饰的成员在类外可以直接被访问 ；protected和private 修饰的成员在类外不能直接被访问 ，protected和private是一样的，以后继承章节才能体现出它们的区别。

5、一般成员变量 都会被限制为private/protected ，需要给别人使用的成员函数会设为public。

看下面栈的类的定义

cpp 复制代码 
class Stack {
	int _x;

public:
	// 成员函数
	void Init(int n = 4) {}
	void Push(int x) {}
	int Top() {
		return _a[_top];
	}
private:
	// 成员变量
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
    Stack s;
	s.Init();
	s.Top();
	//s._x = 1;不支持
	// s._a[s._top - 1]; 不支持

    
    return 0;
}

这里默认_x是私有的，成员函数是公有的，成员变量是私有的。而用这个类定义的变量s在调用时也只能调用成员函数，不能修改成员变量的值，这样不仅可以保护成员变量 ，而且避免了修改一个变量导致修改全部变量的情况。

1.3类域

类内的成员函数如果像要在类外定义函数的时候，要使用**::作用域**限定操作符指明成员属于哪个类域。

类域影响的是编译的查找规则，下面程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪里，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

cpp 复制代码 
class Stack
{
public:
	// 成员函数
	void Init(int n = 4);
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};

// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
	array = (int*)malloc(sizeof(int) * n);
	if (nullptr == array)
	{
		perror("malloc申请空间失败");
		return;
	}
	capacity = n;
	top = 0;
}

这里如果定义时直接void Init(int n) 就会报错，因为它找不到stack，需要**::**用来找到这个函数。

2.实例化
2.1实例化概念

1、用类类型在物理内存空间 中存在的过程叫做实例化过程，称为类实例化出对象 。
2、类是对象进行⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间 ，用类实例化出对象时，才会分配空间 。
3、⼀个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

cpp 复制代码 
class Date
{
public:
	void Init(int year, int month, int day) {
		//Date::year = year; // 不推荐
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这里只是声明，没有开空间
	//int year;
	int _year;
	int _month;
	int _day;
};

int main(){
	// 类实例化对象
	Stack s;
	// s._top = 1;

	// Stack::_top = 1; 不能

	// 今天
	Date d1;
	d1.Init(2026, 8, 5);
	d1.Print();

	// 开学
	Date d2;
	d2.Init(2026, 9, 3);
	d2.Print();

}

这里main中s就是实例化对象，分配了空间，而Date中的成员变量就只有生命，没有分配空间.

2.2对象大小

类实例化出的每个对象，都有独立的数据空间 ，所以对象中肯定包含成员变量，函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)，那么对象中非要存储的话，只能是成员函数的指针。函数指针是不需要存储的，函数指针是⼀个地址，调用函数被编译成汇编指令call 地址，
总结
对象中只存储成员变量，C++规定类实例化的对象也要符合内存对齐的规则。

内存对齐规则
1.第⼀个成员在与结构体偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
3.注意：对齐数 = 编译器默认的⼀个对齐数与该成员大小的较小值。
4.VS中默认的对齐数为8
5.结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
6.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对⻬数（含嵌套结构体的对齐数）的整数倍。
！！！规定没有成员变量的对象大小默认是1

3.this指针

1、上面提到，实例化出了d1,d2,然后进行，调用函数Init()和Print(),那么在调用函数的时候，他是怎么样进行区分，到底是调用的是d1,还是d2呢，那么这里就要看到C++给了一个隐含的this指针解决这里的问题。

2、编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this指针。比如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day)

3、类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this->_year = year;

4、C++规定不能在实参和形参的位置显示的写this指针 (编译时编译器会处理)，但是可以在函数体内显示使用this指针。

cpp 复制代码 
 class Date
{
public:
	// void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day) {
		_year = year;
		_month = month;
		_day = day;
	}

	// 编译器处理
	/*void Print(Date* this)
	{
		cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
	}*/

	void Print()
	{
		//this = nullptr; 不能修改
		cout << this << endl;
		cout << this->_year << "/" << _month << "/" << _day << endl;
	}
private:
	// 这里只是声明，没有开空间
	//int year;
	int _year;
	int _month;
	int _day;
};

int main(){
	// 今天
	Date d1;
	d1.Init(2026, 8, 5);
	d1.Print();
	//d1.Print(&d1); // 编译器处理

	// 开学
	Date d2;
	d2.Init(2026, 9, 3);
	d2.Print();
	//d1.Print(&d2);
}

这里就明确说明了this指针在成员函数中的作用是帮忙区分不同变量调用成员函数，并且这个过程是编译器自己运行，不需要写出来，但可以在成员函数中作用this指针。

下面看两道题

cpp 复制代码 
class A
{
public:
	void Print(int x)
	{
		cout << "A::Print()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print(1);
    return 0;
}

这段代码不仅不会报错，还会正常运行，因为虽然调用时把this指针变成空指针，但调用成员函数时没有调用this指针去调用成员变量，这就导致程序正常进行

接下来看下面这段代码

cpp 复制代码 
class A
{
public:
	void Print(int x)
	{
		cout << "A::Print()" << endl;
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print(1);
    return 0;
}

这段代码就会崩溃，因为成员变量是存储在指针指向的对象中所以这里出现的空指针解引用这就使程序运行崩溃。

总结

函数地址没有存在对象中，编译的时候确定函数地址，而又利用call去调用函数。

4.类的默认成员函数

默认成员函数就是没有显式实现，编译器会自动⽣成的成员函数称为默认成员函数。⼀个类，我 们不写的情况下编译器会默认生成以下6个默认成员函数，

5.构造函数​

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init.
特点

  1. 函数名与类名 相同。
  2. 无返回值 。 (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
  3. 对象实例化时系统会自动调用对应的构造函数。
  4. 构造函数可以重载 。
  5. 如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数 ，⼀旦用户显式定义编译器将不再生成。
  6. 无参构造函数、全缺省构造函数 、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意不要误认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调用的构造就叫默认构造 。
    7 . 我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需用初始化列表才能解决。
cpp 复制代码 
	class Date
{
public:
	/*Date() {
		_year = 1;
		_month = 1;
		_day = 1;
	}*/
       //两个Date构成重载
	Date(int year = 1, int month = 1, int day = 1) {
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};


int main() {
	Date d1;		   // 对象实例化自动调用
	Date d2(2026,9,3); // 对象实例化自动调用
	Date d3(2026); // 对象实例化自动调用


	return 0;
}

这里两个Date就形成重载，如果有一个全缺省的Date，就不用写无参的Date了，因为无参数的对象会自动调用全缺省Date，而有参数的直接用这个参数。而对象在实例化时自动调用构造函数。而在定义对象时，如果没有参数不需要加（），因为这会与函数声明重复，造成无法自动调用构造函数。

再来看下如何定义栈

cpp 复制代码 
class Stack {
public:
	Stack(int n = 4) {
		_a = (int*)malloc(sizeof(int) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};


int main() {
	Stack st1;
	Stack st2(100);

	return 0;
}

这里就运用了一个全缺省的构造函数，当对象没有参数时，就利用n＝4。当对象有参数时，就调用它的参数

接下来我们看下构造函数的优点

cpp 复制代码 
class Stack {
public:
	Stack(int n = 4) {
		_a = (int*)malloc(sizeof(int) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}

private:
	int* _a;
	int _top;
	int _capacity;
};

// 用两个栈实现一个队列
class Myqueue {
private:
	Stack _st1;
	Stack _st2;
};

int main() {

	Myqueue q;

	return 0;
}

这里用两个栈去实现队列，我们写了两个栈的构造函数，没写栈构造成队列的函数，这就会默认生成一个构造函数去实现两个栈实现一个队列

这里自动调用的价值就体现出来了，如果我们没有自动调用，变量的就无法自动初始化。当我们忘记初始化时，它就可以自动调用，避免没初始化。

相关推荐
西安景驰电子1 小时前
《PTP精确时间协议系列》第一篇：从原理到应用，全面解读IEEE 1588
linux·运维·服务器·开发语言·网络·windows·php
ctlover1 小时前
Python文件操作
开发语言·python
luj_17681 小时前
塔防牌：策略与卡牌的智慧碰撞
服务器·c语言·开发语言·经验分享·算法
wuyk5552 小时前
3.链表：用指针串联的动态数据结构
c语言·开发语言·数据结构·链表
郝学胜-神的一滴2 小时前
干货版《算法导论》17：二叉树核心原理、遍历逻辑与高阶实操全解
数据结构·c++·python·算法·计算机·编程
hetao17338372 小时前
2026-08-09~08-14 hetao1733837 的刷题记录
c++·算法
weixin_383196472 小时前
java基础面试题@Autowired和@Resource区别
java·开发语言
言乐63 小时前
Python游戏水平测试辅助系统2
开发语言·windows·python·游戏·django
我不是疯子是傻子3 小时前
Qt 实时曲线卡顿优化：从QPainter到OpenGL的3级加速实战
开发语言·qt
热门推荐
01GitHub 镜像站点02国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）03微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新042026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？05VSCode+CodeX扩展，无法启动06Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费07历年考研数学一、数学二、数学三真题试卷及答案PDF08AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路092026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片10如何新建文件夹？ 电脑新建文件夹的4种方法