类和对象(上)

黎相思

于 2024-08-07 21:18:53 发布

阅读量708

点赞数 13

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/m0_74271757/article/details/140964708

版权

C++ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1. 类的定义

1.1 类定义格式

class为定义类的关键字,Stack为类的名字,{}中为类的主体,注意类定义结束时后面分号不能省略。类体中内容称为类的成员:类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。
为了区分成员变量,一般习惯上成员变量会加一个特殊的标识,如成员变量前面或后面加_或者m开头,注意C++中这个并不是强制的,只是一些惯例,具体看公司要求。
C++中struct也可以定义类,C++兼容C中struct的用法,同时struct升级成了类,明显的变化是struct中可以定义函数m,一般情况下还是推荐用class定义类。
定义在类里面的成员函数默认为inline。

#include <iostream>
#include <assert.h>
using namespace std;
//栈
class Stack
{
public://访问限定符号 - 公有
	void Init(int capacity = 4)
	{
		_array = (int*)malloc(sizeof(int) * capacity);
		if (nullptr == _array)
		{
			perror("malloc error!\n");
			return;
		}
		_capacity = capacity;
		_top = 0;
	}
	/*
	这里不一样的是之前写的函数是全局的,命名通常都是STInit,STPush,
	现在就不用那样写了,因为init和pus函数都是写在类里面的,受类域
	的限制,所以init和push肯定是这个栈的,以前写全局Init前面加东西是
	为了区分,假设还有队列呢,
	*/
	void Push(int x)
	{
		//判读空间是否足够 - 扩容

		_array[_top++] = x;
	}
	int Top()
	{
		assert(_top > 0);
		return _array[_top - 1];
	}
	void Destroy()
	{
		free(_array);
		_array = nullptr;
		_top = _capacity = 0;
	}
private://访问限定符 - 私有
	//成员变量
	//member - 成员
	//成员变量前面或后面加_或者m开头,用于和形参区分,当然不加也可以
	int* _array;
	size_t _capacity;
	size_t _top;
};

int main()
{
	//类名就是类型,不像结构体前面还要加struct,特别的麻烦
	Stack st1;
	//初始化栈
	st1.Init();
	//插入数据
	st1.Push(1);
	st1.Push(2);
	st1.Push(3);
	st1.Push(4);
	//取栈顶元素
	cout << st1.Top() << endl;
	//销毁栈
	st1.Destroy();
	return 0;
}
/*
类跟结构体不同的地方
1.类里面可以定义函数,这是最大的不同
2.用法上面前面不需要加class,直接用类名(类型),用类型定义对象,
而结构体需要加struct，
*/
/*
一个类,一般情况下,成员变量都是私有的,成员函数大部分都是公有的,
因为类的设计的时候不期望随便访问修改我的数据,调用方法就可以,其他不用管
*/
/*
类里面有成员变量,也有成员函数,不想直接在类外面访问的就定义成私有的
访问限定符限制的是类外面的访问,类的内部是不受影响的,

*/

/*
C++中struct也可以定义类,C++兼容C中的struct的用法,同时升级成了类,明显的
变化是struct中可以定义函数,一般情况下还是推荐用class类
*/
struct Person
{
public:
	void Init(const char* name, int age, const char* tel)
	{
		strcpy(_name, name);
		_age = age;
		strcpy(_tel, tel);
	}
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "年龄:" << _age << endl;
		cout << "电话:" << _tel << endl;
	}
//一般情况下成员变量不期望在外面直接访问,看自己
private:
	char _name[10];
	int _age;
	char _tel[12];
};

//C++中兼容C中struct的用法,********************************
//定义个队列
typedef struct QueueNode
{
	struct QueueNode* next;
	int val;
}QNode;
typedef struct Queue
{
	QNode* head;
	QNode* tail;
	int size;
}Qu;
/*
struct在C++中有两套用法,一套就是像C++中这样,定义类,另一套就是像
C语言那样,定义结构体。这样用C写出的代码,C++也可以编译
*/
//****************************************************************

void QueueInit(Qu* q)
{
	q->head = nullptr;
	q->tail = nullptr;
	q->size = 0;
}

int main()
{
	//类名就是类型
	Person p1;
	p1.Init("王浩", 21, "17309339946");
	p1.Print();

	//队列
	Qu qu;
	QueueInit(&qu);

	return 0;
}
/*
我们会发现用struct定义类的时候和用class定义类的时候是一摸一样的,
这就是C++对struct进行了升级,升级成了类,class可以的struct都可以
*/

1.2 访问限定符

C++一种实现封装的方式,用类将对象的属性和方法结合在一块,让对象更加完善,通过访问权限选择性的将其接口提供给外部的程序使用。
public修饰的成员在类外可以直接被访问,protected和private修饰的成员在类外不能直接被访问,protected和private是一样的,以后继承章节才能体现出他们的区别。
访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现的位置为止,如果后面没有访问限定符,作用域就到}即类结束。
class定义成员没有被访问限定符修饰时默认为private，struct默认为public。
一般成员变量都会被限制为private/protected,需要给别人使用的成员函数会放为public。

1.3 类域

类定义了一个新的作用域,类的所有成员都在类的作用域中,在类体外定义成员时,需要使用::作用域操作符指明成员属于哪个类域。
类域影响的是编译的查找规则,下面程序中Init如果不指定类域Stack,那么编译器就把Init当成全局函数,那么编译时,找不到array等成员的声明/定义在哪里,就会报错。指定类域Stack,就是直到Init是成员函数,当前域找不到的array等成员,就会到类域中去查找。

函数在类里面定义,默认就是内联,那么除了在类里面定义函数,也可以在类外面定义函数。

短小的函数在类里面定义,默认是内联,如果是长函数,那么就不在类里面定义,做声明和定义分离。

一般都是.h声明,.cpp定义。

Stack.h

#pragma once
#include<iostream>//vs上一般情况下C++中iostream这个头文件会间接的
//包含stdio,stdlib等头文件
#include<assert.h>
using namespace std;
class Stack
{
public:
	void Init(int n = 4);
private:
	int* _arr;
	int _top;
	int _capacity;
};

Stack.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include "Stack.h"
//1.缺省参数只能在声明的时候给,定义的时候就不给了
//2.指定类域,要不然不知道Init函数是哪里的,全局局部都找不到的话
//就会去Stack类中去找
void Stack::Init(int n)
{
	_arr = (int*)malloc(sizeof(int) * n);
	if (_arr == nullptr)
	{
		perror("malloc error!\n");
		return;
	}
	_capacity = n;
	_top = 0;
}

main.cpp

#include"Stack.h"
int main()
{
	Stack st;
	st.Init();
	return 0;
}

比较标准一点的声明和定义分离,.h放类的声明,成员变量,成员函数的声明,.cpp放类的定义指定类域,这样的话类和类之间有同名的变量,函数的话就不会冲突了,天然就是一个隔离。

2. 实例化

2.1 实例化概念

用类类型在物理内存中创建对象的过程,称为类实例化出对象。
类是对象进行一种抽象描述,是一个模型一样的额东西,限定了类有哪些成员,这些成员变量只是声明,没有分配空间,用类实例化出对象时,才会分配空间。
一个类可以实例化出多个对象,实例化出的对象占用实际的物理空间,存储类成员变量。打个比方:在类实例化出对象就像现实中使用建筑设计图建造出房子,类就像是设计图,设计图规划了有多少个房间,房间大小功能等,但是并没有实体的建筑存在,也不能住人,用设计图修建出房子才能住人。同样类就像设计图一样,不能存储数据,实例化出的对象分配物理内存存储数据。

#include <iostream>
using namespace std;
class Date
{
public:
	void Init(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Printf()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	//这里是声明,没有开空间,这些变量是随着对象整体定义的
	int _year;
	int _month;
	int _day;
};
//定义
int year;
//声明和定义不能用初始化去区分,声明和定义的特征就是有没有开空间
int main()
{
	//类实例化出对象
	Date d1;
	Date d2;
	//调用方法
	d1.Init(2024, 8, 7);
	d2.Init(2024, 8, 8);

	d1.Printf();
	d2.Printf();
	return 0;
}
/*
类和对象的关系是1对N,一个类可以实例化出N个对象
类就像一个房子的图纸一样,类里面不能存数据,就像
图纸里面不能住人,那么什么时候可以住人呢?用图纸
建造出很多房子就可以住人,一个图纸可以建造N栋房
子,那么我可以用一个类实例化出N个对象,类就像图
纸一样不能住人,但是这个类规定这个类实例化的对
象到底有哪些数据,有哪些方法,而图纸规定了到底是
几室几厅等。
*/

2.2 对象大小

分析一下类和对象中哪些成员呢?类实例化出的每个对象,都有独立的数据空间,所有对象中肯定包含成员变量,那么成员函数是否包含呢?

那么我们先来看看结果。

我们看到,结果是12,说明实例化的对象里面只存了成员变量,没有存成员函数,d1的年月日和d2的年月日不一样,d1有自己的数据,d2也有自己的数据,但是d1调的Print函数和d2调的Print函数是同一个函数,既然是一样的,那么就没有必要把Print的指针存储到对象里面,函数被编译完成是一句指针,那么第一句指令的地址就是这个函数的额地址,年月日要存到对象里面是因为d1和d2有不同的年月日,Print和Init不需要存到里面是因为他们调用的都是相同的,存在对象里面就冗余了。

没有必要存到类里面,所有我们可以把它存到公共的区域里面。其实函数指针是不需要存储的,函数指针是⼀个地址,调⽤函数被编译成汇编指令[call 地址],其实编译器在编译链接时,就要找到函数的地址,不是在运⾏时找,只有动态多态是在运⾏时找,就需要存储函数地址。

类计算大小的时候,只考虑成员变量,不考虑成员函数。

上面我们分析了对象中只存储成员变量,C++规定类实例化的对象也要符合内存对齐的规则。

内存对齐规则

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
注意:对齐数=编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8。
结构体总大小为:最大对齐数(所有变量类型最大者与默认对齐参数取最小)的整数倍。
如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

3. this指针

Date类中有Init与Print两个成员函数,函数体中没有关于不同对象的区分,那当d1调用Init和Print函数时,该函数是如何知道应该访问的是d1对象还是d2对象呢?那么这里就要看到C++给了一个隐含的this指针解决这里的问题。
编译器编译后,类的成员函数默认都会在形参第一个位置,增加一个当前类类型的指针,叫做this指针。比如Date类的Init的真实原型为:
```
void Init(Date* const this,int year, int month, int day)
```
类额成员函数中访问成员变量,本质都是通过this指针访问的,如Init函数中给_year赋值:
```
this->_year = year;
```
C++规定不能在实参和形参的位置现实的写this指针(编译时编译器会处理),但可以在函数体内显示使用this指针。

选择题:

4. C++和C语言实现Stack对比

面向对象三大特征:封装,继承,多态,下面的对比我们可以初步了解一下封装。

通过下面两份代码的对比,我们发现C++实现Stack形态上还是发生了挺多的变化,底层逻辑上没啥变化。

C++中数据和函数都放到了类里面,通过访问限定符进行了限制,不能再随意通过对象直接修改数据,这是C++封装的一种体现,这个是最重要的变化。这里的封装的额本质是一种更严格规范的管理,避免出现乱访问修改的问题。当然封装不仅仅是这样的,我们后面还需要不断的去学习。
C++中有一些相对方便的语法,比如Init给的缺省参数会方便很多,成员函数每次不需要传对象地址,因为this指针隐含的传递了,方便了很多,使用类型不再需要typedef用类名就很方便。

C语言实现Stack代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	// 满了，扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool STEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	ps->top--;
}
STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));
	return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
int main()
{
	ST s;
	STInit(&s);
	STPush(&s, 1);
	STPush(&s, 2);
	STPush(&s, 3);
	STPush(&s, 4);
	while (!STEmpty(&s))
	{
		printf("%d\n", STTop(&s));
		STPop(&s);
	}
	STDestroy(&s);
	return 0;
}

C++实现Stack代码

#include<iostream>
#include<assert.h>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	// 成员函数
		void Init(int n = 4)
	    {
		    _a = (STDataType*)malloc(sizeof(STDataType) * n);
		    if (nullptr == _a)
		    {
			    perror("malloc申请空间失败");
				    return;
		    }
		    _capacity = n;
		    _top = 0;
	    }
        void Push(STDataType x)
        {
            if (_top == _capacity)
            {
                int newcapacity = _capacity * 2;
                STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
                    sizeof(STDataType));
                if (tmp == NULL)
                {
                    perror("realloc fail");
                    return;
                }
                _a = tmp;
                _capacity = newcapacity;
            }
            _a[_top++] = x;
        }
        void Pop()
        {
            assert(_top > 0);
            --_top;
        }
        bool Empty()
        {
            return _top == 0;
        }
        int Top()
        {
            assert(_top > 0);
            return _a[_top - 1];
        }
        void Destroy()
        {
            free(_a);
            _a = nullptr;
            _top = _capacity = 0;
        }
private:
    //成员变量
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    while (!s.Empty())
    {
        printf("%d\n", s.Top());
        s.Pop();
    }
    s.Destroy();
    return 0;
}

黎相思

关注

13
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
类和对象(上)

class为定义类的关键字,Stack为类的名字,{}中为类的主体,注意类定义结束时后面分号不能省略。类体中内容称为类的成员:类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。为了区分成员变量,一般习惯上成员变量会加一个特殊的标识,如成员变量前面或后面加_或者m开头,注意C++中这个并不是强制的,只是一些惯例,具体看公司要求。
复制链接

扫一扫

专栏目录