作者：@小萌新
专栏：@C++初阶
作者简介：大二学生希望能和大家一起进步
内容简介：本文会简单的介绍C++中类和对象的一部分内容

学习本身就是一件很快乐的事情

C++ 类和对象上

一. 面向对象和面向过程
- 面向过程
- 面向对象
二. C++中类的引入
三. 类的定义
四. 类的访问限定符和封装
五. 类的作用域
六. 类的实例化
七. 类对象的模板
八. this指针
总结

一. 面向对象和面向过程

我们在学习计算机的过程中经常会听到xxx是一门面向对象的语言 xxx是一门面向过程的语言

那么到底什么是面向对象什么是面向过程呢？

简单介绍下

面向过程

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

比如说就拿洗衣服

我们关注的是洗衣服这个过程

就像这样子

在这里插入图片描述

面向对象

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

还是以洗衣服这个动作来说

在这里插入图片描述

二. C++中类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：
之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，
会发现struct中也可以定义函数。

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;

typedef int Datetype;


struct Stack
{
	// 定义变量类型
	Datetype* _arr;
	int _top;
	int _capacity;


	// 定义函数
	void StackInit(size_t capacity)
	{
		_arr = (Datetype*)malloc(sizeof(Datetype) * capacity);
		if (_arr == nullptr)
		{
			perror("Init malloc fail");
		}

		_capacity = capacity;
		_top = 0;
	}


	void StackPush(Datetype x)
	{
		// assert
		assert(_capacity > _top);

		_arr[_top] = x;
		_top++;
	}


	Datetype StackTop()
	{
		return _arr[_top - 1];
	}

	void StackDestroy()
	{
		_top = _capacity = 0;
		free(_arr);
		_arr = nullptr;
	}


};


int main()
{
	Stack s;
	s.StackInit(20);
	s.StackPush(10);
	s.StackPush(10);
	s.StackPush(10);
	s.StackPush(10);
	s.StackPush(20);
	cout << s.StackTop() << endl;
	s.StackPush(30);
	cout << s.StackTop() << endl;
	return 0;
}

在这里插入图片描述
我们定义了一个类然后使用这个类创建了一个对象之后使用这个类的对象使用一些方法

在Stack这个类中里面的变量是_arr _top _capacity
然后里面的这些方法 StackPush() StackInit() StackTop() 可以调用这些变量
此外类里面的函数和变量的上下关系是随意的

事实上在C++当中这里并不是结构体的定义这是类的封装

在C语言的结构体中，不会有函数这样的成员变量，因为C语言是面向过程的，其操作方式是与成员直接分开的；

而C++是是面向对象的，一个对象就是包括了自身属性和动作。

一个对象中有很多的方法方法就是函数

当我们使用一个类去定义的时候我们就能够得到一个对象当我们想要对这个对象进行操作的时候我们

就可以直接用内部的方法进行操作

上面结构体的定义，在C++中更喜欢用class来代替。

三. 类的定义

我们会使用这样子的结构来定义一个类

class className
{
// 类体：由成员函数和成员变量组成
};  // 一定要注意后面的分号

其中class是一个关键字

classname是类名

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

那么我现在问你成员变量是什么？

是不是就是类中的变量

成员函数是什么？

是不是就是类的函数

类的两种定义方式

1. 直接在函数内部定义

就像这样子
在这里插入图片描述

不过要注意的是成员函数在类的内部定义有可能会被当成内链函数

2. 在函数外部定义

就像这样子
在这里插入图片描述

命名建议

我们先来看看这种命名方式

// 我们看看这个函数，是不是很僵硬？
class Date
{
public:
 void Init(int year)
 {
 // 这里的year到底是成员变量，还是函数形参？
 year = year;
 }
private:
 int year;
};

所以说我们的建议都是这样子的

class Date
{
public:
 void Init(int year)
 {
 mYear = year;
 }
private:
 int mYear;
};

加个m在前面或者是加个_在前面是不是清晰多了

四. 类的访问限定符和封装

4.1 访问限定符

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

这里分别由三种权限分别是公有保护还有私有

（目前阶段将保护还有私有认为是一致的就可以）
在这里插入图片描述
听名字也很好理解是吧

公有是大家都能使用的保护和私有是限制访问的

还是一样我们来看代码

在这里插入图片描述
我们 struct 变成 class之后就报错了

这是为什么呢？

刚刚不是说struct和class都可以定义类嘛

这是因为c++的一条语法规则

class的默认访问权限为private，struct为public （这是为什么呢？）

因为struct要兼容c的语法所以只能这么设计了

如果我们想要解决这个错误也很简单直接public一下就好了

在这里插入图片描述

是不是错误就全部消失了

访问操作符的权限如下

1 public修饰的成员在类外可以直接被访问
2 protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4 如果后面没有访问限定符，作用域就到 } 即类结束。
5 class的默认访问权限为private，struct为public(因为struct要兼容C)

4.2 关于域操作符的问题

我们的先来看几段有意思的代码
在这里插入图片描述

咦我们发现到这里就会报错了

在这里插入图片描述
这是因为对于结构体中的变量它实际上是没有初始化的

对于类来说它是不是形式上类似于一个结构体呀

结构体内部的变量是不是没有实例化

所以说我们使用未实例化的变量是不是会报错啊

这里说了这么一大堆要表达的东西是什么呢？

总结来说一句话

不能使用类名访问成员变量

面试题

C++中struct和class的区别是什么？

答案：
因为要兼容c语言的原因
struct可以定义结构体
class不可以

还是因为要兼容c语言的原因
struct默认访问限定符是public
class默认访问限定符是private

4.3 封装

【面试题】
面向对象的三大特性：封装、继承、多态。
在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用
户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日
常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如
何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计
算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以
及键盘插孔等，让用户可以与计算机进行交互即可。
在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来
隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

五. 类的作用域

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

这个也很好理解嘛其实我们回过头去看看那些大括号基本上都是定义了一个新的作用域

class Person
{
public:
 void PrintPersonInfo();
private:
 char _name[20];
 char _gender[3];
 int  _age;
};
// 这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo()
{
 cout << _name << " "<< _gender << " " << _age << endl;

六. 类的实例化

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

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

比如说：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

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

我们来看以下代码

在这里插入图片描述
这里直接用类调用成员会报错

必须要先创建一个实例

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

在这里插入图片描述

七. 类对象的模板

7.1 如何计算类对象大小

class A
{
public:
void PrintA()
{
   cout<<_a<<endl;
}
private:
char _a;
};

7.2 对于类内存的推测

因为类实际上就是一个结构体嘛

肯定要符合结构体内存对齐的规则

char的大小是一这里大家肯定都没有疑惑

一般函数在使用的时候一般是以地址的形式存在的所以说我们假设这里是4个字节（32位运行环境）

所以说如果符合预期这里的大小就是8

那么我们打印出来看看

在这里插入图片描述
我们发现这里的大小是1

7.3 实际存储方式

在这里插入图片描述

我们的类成员函数都放在一个公共代码区

我们建立的每个对象都只有成员变量

我们来看以下代码

// 类中既有成员变量，又有成员函数
class A1 {
public:
    void f1(){}
private:
    int _a;
};

// 类中仅有成员函数
class A2 {
public:
   void f2() {}
};
// 类中什么都没有---空类
class A3
{};
sizeof(A1) : ______ sizeof(A2) : ______ sizeof(A3) : ______

这一看很简单是吧 4 0 0啊这还能有什么

但实际上不是这样子的

我们创造一个对象出来一定会占用空间

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

八. this指针

8.1 this指针的引出

我们这里先定义一个日期类 Date

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	
	void Print()
	{
		cout << _year << "_" << _month << "_" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1, d2;
	d1.Init(2022, 11, 1);
	d2.Init(2022, 11, 2);
	d1.Print();
	d2.Print();
	return 0;
}

我们这里分别用d1 d2两个对象来调用成员函数

那么这里我们就有一个疑问了

当我们调用d1指针的时候函数是怎么知道我们是调用的是d1而不是d2呢？

这里c++给出的解决方案就是this指针

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

8.2 this指针的特性

这里有四点

1. this指针的类型：类类型 const，即成员函数中，不能给this指针赋值。
2. 只能在“成员函数”的内部使用
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给
this形参。所以对象中不存储this指针。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传
递，不需要用户传递*

不能给this指针赋值很好理解它要指向我们的成员变量的嘛

第二点语法规定了这个关键字只能这么做

第三点记住了它是个形参下面会用到

面试题

this指针存在哪里？
this指针可以为空吗？

对于第一个问题回答是这样子的

还记不得我上面让大家记住的关键语句

this是一个形参形式参数放在哪里啊？是不是栈区

所以说答案是这样

大部分情况下是放在栈区的

为什么说大部分情况呢我们来看看反汇编代码

在这里插入图片描述

我们发现这里它是不是将一个参数（实际上就是this指针）

放进去了啊

所以说也有可能放在寄存器里面

标准答案如下

大部分情况下因为this是一个形式参数所以说放在栈区
但是比如说在VS上由于this要经常使用所以说编译器就将它优化到寄存器上去了

那么对于问题2 我们给出以下两段代码

/ 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
void Print()
{
    cout << "Print()" << endl;
}
private:
int _a;
};
int main()
{
    A* p = nullptr;
    p->Print();
    return 0;
}

这里程序会不会报错呢？

我们这里简单分析下

p是个空指针 this作为一个形参将空指针传递进去了但是print函数的调用跟是不是空指针有关系嘛？

没有啊

所以说这一题选择正常运行

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
    void PrintA()
    {
        cout<<_a<<endl;
    }
    private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA();
    return 0;
}

那么第二个呢

传递进去的是空指针但是是不是对对象里参数调用了啊空指针怎么能调用东西呢

所以说这里会运行崩溃

所以说这里得出结论 this指针可以为空

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

c语言

typedef int DataType;
typedef struct Stack
{
    DataType* array;
    int capacity;
    int size;
}Stack;
void StackInit(Stack* ps)
{
    assert(ps);
    ps->array = (DataType*)malloc(sizeof(DataType) * 3);
    if (NULL == ps->array)
    {
        assert(0);
        return;
    }
    ps->capacity = 3;
    ps->size = 0;
}
void StackDestroy(Stack* ps)
{
    assert(ps);
    if (ps->array)
    {
        free(ps->array);
        ps->array = NULL;
        ps->capacity = 0;
        ps->size = 0;
    }
}
void CheckCapacity(Stack* ps)
{
    if (ps->size == ps->capacity)
    {
        int newcapacity = ps->capacity * 2;
        DataType* temp = (DataType*)realloc(ps->array,
                          newcapacity*sizeof(DataType));
        if (temp == NULL)
        {
            perror("realloc申请空间失败!!!");
            return;
        }
        ps->array = temp;
        ps->capacity = newcapacity;
    }
}
void StackPush(Stack* ps, DataType data)
{
    assert(ps);
    CheckCapacity(ps);
    ps->array[ps->size] = data;
    ps->size++;
}
int StackEmpty(Stack* ps)
{
    assert(ps);
    return 0 == ps->size;
}
void StackPop(Stack* ps)
{
    if (StackEmpty(ps))
        return;
    ps->size--;
}
DataType StackTop(Stack* ps)
{
    assert(!StackEmpty(ps));
    return ps->array[ps->size - 1];    
}
int StackSize(Stack* ps)
{
    assert(ps);
    return ps->size;
}
int main()
{
    Stack s;
    StackInit(&s);
    StackPush(&s, 1);
    StackPush(&s, 2);
    StackPush(&s, 3);
    StackPush(&s, 4);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackPop(&s);
    StackPop(&s);
    printf("%d\n", StackTop(&s));
    printf("%d\n", StackSize(&s));
    StackDestroy(&s);
    return 0;
}

c++

typedef int DataType;
class Stack
{
public:
    void Init()
    {
        _array = (DataType*)malloc(sizeof(DataType) * 3);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }
        _capacity = 3;
        _size = 0;
    }
    void Push(DataType data)
    {
        CheckCapacity();
        _array[_size] = data;
        _size++;
    }
    void Pop()
    {
        if (Empty())
            return;
        _size--;
    }
    DataType Top(){ return _array[_size - 1];}
    int Empty() { return 0 == _size;}
    int Size(){ return _size;}
    void Destroy()
    {
        if (_array)
        {
            free(_array);
            _array = NULL;
            _capacity = 0;
            _size = 0;
        }
    }
    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            int newcapacity = _capacity * 2;
            DataType* temp = (DataType*)realloc(_array, newcapacity *
                              sizeof(DataType));
            if (temp == NULL)
            {
                perror("realloc申请空间失败!!!");
                return;
            }
            _array = temp;
            _capacity = newcapacity;
        }
    }
private:
    DataType* _array;
    int _capacity;
    int _size;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Pop();
    s.Pop();
    printf("%d\n", s.Top());
    printf("%d\n", s.Size());
    s.Destroy();
    return 0;
}

经过对比我们可以发现

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

每个函数的第一个参数都是Stack*
函数中必须要对第一个参数检测，因为该参数可能会为NULL
函数中都是通过Stack*参数操作栈的
调用时必须传递Stack结构体变量的地址

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

C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在
类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。
而且每个方法不需要传递Stack*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack *
参数是编译器维护的，C语言中需用用户自己维护。

总结

在这里插入图片描述

这是萌新最近一个月来写的时间最长的博客了

较为详细的介绍了类和对象的一部分内容
由于博主水平有限错误在所难免希望大佬看到之后能够不吝赐教
最后如果这篇博客有帮助到大家别忘了一键三连啊哇酷哇酷！

本文含有隐藏内容，请开通VIP 后查看

C++ 类和对象（上）

C++ 类和对象上

一. 面向对象和面向过程

面向过程

面向对象

二. C++中类的引入

三. 类的定义

类的两种定义方式

1. 直接在函数内部定义

2. 在函数外部定义

命名建议

四. 类的访问限定符和封装

4.1 访问限定符

4.2 关于域操作符的问题

面试题

4.3 封装

五. 类的作用域

六. 类的实例化

七. 类对象的模板

7.1 如何计算类对象大小

7.2 对于类内存的推测

7.3 实际存储方式

八. this指针

8.1 this指针的引出

8.2 this指针的特性

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

总结

网站公告

今日签到

热门文章

最新发布

C++ 类和对象 （上）

C++ 类和对象 上

一. 面向对象和面向过程

面向过程

面向对象

二. C++中类的引入

三. 类的定义

类的两种定义方式

1. 直接在函数内部定义

2. 在函数外部定义

命名建议

四. 类的访问限定符和封装

4.1 访问限定符

4.2 关于域操作符的问题

面试题

4.3 封装

五. 类的作用域

六. 类的实例化

七. 类对象的模板

7.1 如何计算类对象大小

7.2 对于类内存的推测

7.3 实际存储方式

八. this指针

8.1 this指针的引出

8.2 this指针的特性

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

总结

网站公告

今日签到

热门文章

最新发布

C++ 类和对象（上）

C++ 类和对象上