c++初阶——类和对象(上)

最新推荐文章于 2024-08-15 05:02:54 发布

一只努力锋

最新推荐文章于 2024-08-15 05:02:54 发布

阅读量1.1k

点赞数 15

分类专栏： c++初阶文章标签： c++ 开发语言 c语言青少年编程数据结构

本文链接：https://blog.csdn.net/LGFaiJC/article/details/137871281

版权

c++初阶专栏收录该内容

5 篇文章 1 订阅

订阅专栏

本文介绍了C++中的类和对象概念，比较了C和C++在类定义上的差异，包括访问限定符、成员变量和函数的使用，以及this指针的作用。还通过实例探讨了类对象的存储方式和栈的C/C++实现对比。

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

大家好我是小锋今天我们来学习类和对象

面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

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

类的引入

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

struct add {
	//成员函数
	//初始化
	void init(int year=1, int month=1, int day=1) {
		_year = year;
		_month = month;
		_day = day;
	}

	void addprintf() {
		cout << "year=" << _year << endl;
		cout << "month=" << _month << endl;
		cout << "day=" << _day << endl;
	}
	//成员变量
	int _year;
	int _month;
	int _day;
};

int main() {
	add ps;
	ps.init();
	ps.addprintf();
	ps.init(1, 2, 3);
	ps.addprintf();


	return 0;
}

与上面的struct类似，c++更喜欢用class来代替。

那我们来看看class定义的类与stack的区别

类的访问限定符

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

【访问限定符说明】

1. public修饰的成员在类外可以直接被访问

2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)

3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

4. 如果后面没有访问限定符，作用域就到 } 即类结束。

5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

我们这里可以把保护和私有当作相同作用它们的区别我们以后会讲解

那让我们回到问题C++中struct和class的区别是什么？

C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。

类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。

类的实例化

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

2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量。

3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

类的定义

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class add {
public:
	void init(int year = 1, int month = 1, int day = 1) {
			_year = year;
			_month = month;
			_day = day;
	}

	void addprintf() {
		cout << "year=" << _year << endl;
		cout << "month=" << _month << endl;
		cout << "day=" << _day << endl;
		cout << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	add p1;
	p1.init();
	p1.addprintf();
	return 0;
}

2，类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

一般情况下，更期望采用第二种方式。

成员变量命名规则的建议：在成员变量前或者后面加_方便区分。

类对象模型

我们思考一个问题既然类可以成员变量和成员函数，那我们应该如何计算类对象的大小，以及类中的内容是如何存储的？

类对象的存储方式猜测

我们有三种想法

1，

成员函数以及成员变量都存储在类中。但这样做有很大的缺陷：每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

2，

将成员函数的代码保存一份，在对象中存储代码的地址

3，只保存成员变量，成员函数保存在公共代码区

我们来验证一下

#include <iostream>
using namespace std;
//有成员函数函数
class s1 {
public:
	void add() {

	}
private:
	int a;
	char b;
};
//没有成员函数
class s2 {
private:
	int a;
	char b;
};
//空类
class s3 {

};
int main() {
	cout << sizeof(s1) << endl;
	cout << sizeof(s2) << endl;
	cout << sizeof(s3) << endl;
	return 0;
}

从上面的例子中我们可以看出类是按照第三种存储方法存储的

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐

注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

结构体内存对齐规则：

1. 第一个成员在与结构体偏移量为0的地址处。

2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。 VS中默认的对齐数为8

3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

this指针

this指针的引出

我们来看看下面这段代码并思考一个问题

class date {
public:
	void init(int year = 1, int month = 1, int day = 1) {
		_year = year;
		_month = month;
		_day = day;
	}
	void dateprintf() {
		cout << "year=" << _year << endl;
		cout << "month=" << _month << endl;
		cout << "day=" << _day << endl;
		cout << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	date d1, d2;
	d1.init(1, 2, 3);
	d1.dateprintf();
	d2.init();
	d2.dateprintf();
	return 0;
}

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

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

this指针的特性

1. this指针的类型：（类类型* const），即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给 this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

大家来看看下面的这段代码的运行结果

大家是否在想我们明明给add赋值为空为什么还能访问到函数Printf呢？

这里就要从两个方面来解释了

首先在有些编译器下只要你没有真正的去访问nullptr，就不会报错程序也不会崩溃。那肯定有朋友要问了，我们这里明明都通过add指针去访问到类的函数了为什么程序没有报错？那就要提到我们的第二个方面了，我们刚刚已经讲过了，类的成员函数的存储是在公共代码区存储的，类本身存储的是成员变量，所以我们这里通过类指针add去找函数，并没访问类，而是在公共代码区找到了。

那我们再来看看下面这段代码

这里我们的程序崩溃了，是因为我们要访问_a的值，而指针add为空我们访问空指针肯定会报错啊

C语言和C++实现Stack的对比

我们本期初学了类，我们运用我们现学的知识可以来写一个栈，来与c语言做对比，大家看看有什么不一样的地方？

c语言实现

# include<stdio.h>
# include<stdlib.h>
# include<string.h>
# include<stdbool.h>
# include<assert.h>

typedef struct stack stack;
typedef int CMMlet;

struct stack {
	CMMlet* a;
	int size;
	int capacity;
};
//初始化
void stackinit(stack* phead) {
	assert(phead);
	phead->a = NULL;
	phead->capacity = 0;
	phead->size = 0;
}
//栈销毁
void stackDetroy(stack* phead) {
	assert(phead);
	free(phead->a);
	phead->a = NULL;
	phead->capacity = 0;
	phead->size = 0;
}
//判断栈为空
bool stackEmpty(stack* phead) {
	assert(phead);
	return phead->size == 0;
}
//入栈
void stackpush(stack* phead, CMMlet x) {
	assert(phead);
	if (phead->capacity == phead->size) {
		int n = phead->a == NULL ? 4 : phead->capacity * 2;
		CMMlet* cur = (CMMlet*)realloc(phead->a, sizeof(CMMlet) * n);
		if (cur == NULL) {
			perror("空间开辟失败\n");
			return;
		}
		phead->a = cur;
		phead->capacity = n;
	}
	phead->a[phead->size] = x;
	phead->size++;
}
//出栈
void stackpop(stack* phead) {
	assert(phead);
	assert(!stackEmpty(phead));
	phead->size--;
}
//获取栈顶数据
CMMlet stacktop(stack* phead) {
	assert(phead);
	assert(!stackEmpty(phead));
	return phead->a[phead->size - 1];
}
//获取栈的元素个数
int stacksize(stack* phead) {
	assert(phead);
	return phead->size;
}
//打印栈中元素
void stackprintf(stack* phead) {
	for (int j = 0; j < phead->size; j++) {
		printf("%d ", phead->a[j]);
	}
	printf("\n");
}


//测试栈
int main() {
	stack phead;
	stackinit(&phead);
	stackpush(&phead, 1);
	stackpush(&phead, 2);
	stackpush(&phead, 3);
	stackpush(&phead, 4);
	stackpush(&phead, 5);
	stackpush(&phead, 6);
	stackprintf(&phead);
	stackpop(&phead);
	stackpop(&phead);
	stackprintf(&phead);
	int n = stacktop(&phead);
	printf("%d \n", n);
	n = stacksize(&phead);
	printf("%d \n", n);
	stackDetroy(&phead);
	return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

每个函数的第一个参数都是Stack*

函数中必须要对第一个参数检测，因为该参数可能会为NULL

函数中都是通过Stack*参数操作栈的

调用时必须传递Stack结构体变量的地址

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

c++实现

# include<assert.h>
# include<iostream>
using namespace std;

class stack {
public:
	//初始化
	void init(int n=4) {
		_a = (int*)malloc(sizeof(int) * n);
		if (_a == nullptr) {
			perror("空间开辟失败");
			return;
		}
		_size = 0;
		_capacity = n;
	}
	//栈销毁
	void detory() {
		if (_a) {
			free(_a);
			_a = nullptr;
			_size = 0;
			_capacity = 0;
		}
	}
	//判断栈为空
	bool empty() {
		return _size == 0;
	}
	//入栈
	void push(int app=0) {
		if (_capacity == _size) {
			int* cur = (int*)realloc(_a, sizeof(int) * _capacity * 2);
			if (cur == nullptr) {
				perror("空间开辟失败");
				return;
			}
			_a = cur;
			_capacity *= 2;
		}
		_a[_size] = app;
		_size++;
	}

	//出栈
	void pop() {
		assert(!empty());
		_size--;
	}
	//获取栈顶元素
	int top() {
		return _a[_size - 1];
	}
	//获取有效元素个数
	int Size() {
		return _size;
	}
	void Printf() {
		for (int j = 0; j < _size; j++) {
			cout << _a[j] << endl;
		}
		cout << endl;
	}
private:
	int *_a;
	int _size;
	int _capacity;
};


int main() {
	stack add;
	add.init();
	add.push(1);
	add.push(2);
	add.push(3);
	add.push(4);
	add.push(5);
	add.Printf();
	add.pop();
	add.pop();
	printf("%d\n", add.top());
	printf("%d\n", add.Size());
	add.detory();
}