c++编程（3）——类和对象（1）、类

最新推荐文章于 2024-07-19 23:11:36 发布

代码小豪

最新推荐文章于 2024-07-19 23:11:36 发布

阅读量702

点赞数 11

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

本文链接：https://blog.csdn.net/2301_77239666/article/details/137634679

版权

c++编程专栏收录该内容

18 篇文章 1 订阅

订阅专栏

欢迎来到博主的专栏——c++编程
博主ID：代码小豪

文章目录

类

c++最初对c语言的扩展就是增加了类的概念，使得c语言在原有的基础之上可以做到信息隐藏和封装。

那么我们先来讲讲“带类的c”与C语言相比有什么改进。

先讲讲类是什么，举个例子，小明男性、身高一米7，体重70kg，小美女性，身高一米6，体重60kg。他们两都是同属一个类的——人类。我们需要在类中定义出对象的行为和属性，那么人类如下：

class human {
	int age;//年龄
	int weight;//体重
	int high;//身高
	const char* gender;//性别
};

对象

用类创建对象的过程，叫做类的实例化。

如果将对象类比为房屋，那么类就是房屋的设计图。
在这里插入图片描述
一个类可以实例化多个对象，这些对象会拥有相同的属性，但是属性的值是多少，则是由程序员决定的。

就好比房子一样，如果使用的设计图一样，那么这些房屋的构造，面积都是一样的，至于内部的不同，则是看房子的主人是如何装修，以及摆放的家具了。

我们回到human的使用上。我们用类“human”实例化出两个对象，一个小明、一个小美，对象之间拥有的属性都是一致的，如：性别、年龄、体重。但是对象之间的属性值是可以有差异的。

class human {
	int age;//年龄
	int weight;//体重
	int high;//身高
	const char* gender;//性别
};
int main()
{
	human xiaoming;//创建对象小明
	human xiaomei;//创建对象小美

	xiaoming.age = 16;//小明的年龄
	xiaoming.gender = "boy";//性别
	xiaoming.high = 170;//身高
	xiaoming.weight = 70;//体重

	xiaomei.age = 17;//小美的年龄
	xiaomei.gender = "girl";//小美的性别
	xiaomei.high = 160;//身高
	xiaomei.weight = 60;//体重
}

熟悉C语言的人就发现了，这c++的类和C语言的结构体没什么区别啊。为什么称为类呢？

前面提到了，类不仅能定义对象的属性，还能定义对象的行为，属性很好理解，就是在类里面定义成员变量呗，C语言的结构体也能定义成员变量，那么对象的行为是什么呢？

在c++的类中，不仅仅能定义成员变量，还能定义成员函数，这在C语言的结构体中是不能实现的。

以定义一个栈为例。

typedef int STDataType;
class stack {
	void Init(int capacity)//栈的初始化
	{
		_stack = (STDataType*)malloc(sizeof(STDataType) * capacity);
		_capacity = capacity;
		_top = 0;
	}

	STDataType Top()//取栈顶元素
	{
		return _stack[_top - 1];
	}

	bool Empty()//判断栈是否为空
	{
		return _top == 0;
	}

	void Pop()//弹出栈顶
	{
		if (Empty())
		{
			cout << "stack is empty" << endl;
			return;
		}
		_top--;
	}

	void Push(STDataType e)//入栈操作
	{
		if (_top == _capacity)//扩容
		{
			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
			STDataType* tmp = (STDataType*)realloc(_stack, sizeof(STDataType) * newcapacity);
			if (tmp == nullptr)
			{
				perror("malloc fail\n");
				return;
			}
			_stack = tmp;
			_capacity = newcapacity;
		}
		_stack[_top++] = e;
	}

	void Destory()
	{
		free(_stack);
		_top = 0;
		_stack = NULL;
		_capacity = 0;
	}

	STDataType* _stack;
	int _top;
	int _capacity;
};

这是一个栈的类。用这个类可以实例化一个栈。调用栈中的函数会对这个对象内的数据进行操作。

如：

int main()
{
	stack s1;//实例化栈s1
	s1.Init(4);//栈s1初始化

	s1.Push(1);//入栈s1
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	s1.Push(5);

	while (!s1.Empty())
	{
		cout << s1.Top() << ' ';//取s1栈顶元素
		s1.Pop();//弹出s1栈顶
	}

	s1.Destory();//销毁栈s1
	return 0;
}

但是如果大家尝试运行这段代码，编译器会报错。
在这里插入图片描述

类的访问权限

类可以完成信息的隐藏，在一个类中，所有的成员的默认权限都是隐藏。如果想要对类中成员的权限进行管理，就要使用访问限定符了。

c++中的访问限定符有3个，public（公开），protect（保护），private（隐藏）。

访问限定符的作用如下：

（1）public是公开成员，public修饰的成员可以在类外直接引用
（2）protect，private修饰的成员在类外不能被引用
（3）访问权限的作用域从该限定符出现的位置，直到下一个限定符出现的位置为止
（4）最后一个限定符的作用域是从该限定符出现的位置，一直到类的结尾（}）为止
（5）类的所有成员的默认状态都是private。

可以看到类stack中，没有成员的权限限定符，因此所有的成员都是private。因此在类外引用成员函数时，编译器会报错。

解决方法就是在类的开头加上限定符public。

typedef int STDataType;
class stack {
public:
     //省略…………
};

但是我们仔细想想，类stack中的所有成员都应该公开吗？

首先是类中的成员函数，这些成员函数时提供外部使用的，因此需要公开。

而类中的成员变量呢？需不需要公开？我们先来想这么一个问题。栈的成员变量能不能被修改。比如将_stack公开之后，我们就能在外部将_stack置为空指针。那么会不会在某个不经意的操作之后，这个_stack就成为了空指针，或者野指针。这当然是可能的。

	s1._stack = nullptr;

通过判断，类stack的成员变量不需要公开。因此类stack的设定应该改为。

typedef int STDataType;
class stack {
public:
	void Init(int capacity)//栈的初始化
	{
		_stack = (STDataType*)malloc(sizeof(STDataType) * capacity);
		_capacity = capacity;
		_top = 0;
	}
	//省略以下成员函数
private:
	STDataType* _stack;
	int _top;
	int _capacity;
};

类中的什么信息需要隐藏，需要公开，都是需要程序员自己判断之后决定的。通常来说，如果某个变量或函数是需要在类的外部使用的，则需要公开这些成员。若是某个变量或函数在外部使用会影响对象的使用的话（比如将stack中的_stack修改会导致程序崩溃），则将这些成员设为private。

类的作用域

类的作用域也称为类域。通常来说，类都是定义在头文件中的，而头文件中的类的成员函数都是声明。定义会放在另外一个包含这个头文件的源文件，这是为了避免出现重复定义的编译错误（想要更深刻了解，可以去学习一下“编译与连接”）。

那么上面说的类stack，那么它在头文件“stack.h”中的定义如下：

typedef int STDataType;
class stack {
public:
	void Init(int capacity);//栈的初始化

	STDataType Top();//取栈顶元素

	bool Empty();//判断栈是否为空

	void Pop();//弹出栈顶

	void Push(STDataType e);//入栈操作

	void Destory();

private:
	STDataType* _stack;
	int _top;
	int _capacity;
};

我们将这些成员函数的定义放在源文件中。

在这里插入图片描述

但是此时编译器就报错了。可以看到整个源文件的报错满满当当。目前，我们了解的c++的域有全局域，局部域，命名空间域。现在我们来了解第四个域，类域。

首先，我们定义在“stack.cpp”中的函数是存在于局部域的。但是类中的定义与变量却是定义在类域当中的。定义在全局域的函数和变量可以在其他域中使用，而类域中的函数不能定义在全局域。若是需要将函数定义在类外就需要使用域限定符。这是c++规定的

因为大家可以设想一下。c++是支持重载函数的。如果我可以在全局域中定义类stack的初始化函数Init。那么我也可以定义一个是用于队列的初始化函数Init，既然这两个函数都能存在，那么当我们调用初始化函数Init时，应该调用哪个函数呢？这个就导致了歧义的存在，因此c++新增了一个类域，定义在域外的成员需要使用域限定符（：：）指明成员属于哪个域。

因此，stack的成员函数的正确定义的方法是在函数名前面加上限定的域（注意，域限定符使用在函数名之前）。

#include"stack.h"

void stack::Init(int capacity)//栈的初始化
{
	_stack = (STDataType*)malloc(sizeof(STDataType) * capacity);
	_capacity = capacity;
	_top = 0;
}

STDataType stack::Top()//取栈顶元素
{
	return _stack[_top - 1];
}

bool stack::Empty()//判断栈是否为空
{
	return _top == 0;
}

void stack::Pop()//弹出栈顶
{
	if (stack::Empty())
	{
		cout << "stack is empty" << endl;
		return;
	}
	_top--;
}

void stack::Push(STDataType e)//入栈操作
{
	if (_top == _capacity)//扩容
	{
		int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
		STDataType* tmp = (STDataType*)realloc(_stack, sizeof(STDataType) * newcapacity);
		if (tmp == nullptr)
		{
			perror("malloc fail\n");
			return;
		}
		_stack = tmp;
		_capacity = newcapacity;
	}
	_stack[_top++] = e;
}

void stack::Destory()
{
	free(_stack);
	_top = 0;
	_stack = NULL;
	_capacity = 0;
}