欢迎来到博主的专栏——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;
}
