类和对象（初级篇）

最新推荐文章于 2024-09-11 19:54:50 发布
最新推荐文章于 2024-09-11 19:54:50 发布
阅读量41 收藏
点赞数
分类专栏： c++学习 文章标签： 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63082516/article/details/132960401
版权

类和对象

还好有你

一、类和对象（初级篇）

1. 开篇语

在我们引入类和对象时，我们先要对面向过程和面向对象进行初步认识。

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。
C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

2. 类的引入

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

typedef int DataType;
struct Stack
{
 void Init(size_t capacity)
 {
 _array = (DataType*)malloc(sizeof(DataType) * capacity);
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }
 _capacity = capacity;
 _size = 0;
 }
 void Push(const DataType& data)
 {
 // 扩容
 _array[_size] = data;
 ++_size;
 }
 DataType Top()
 {
 return _array[_size - 1];
 }
 void Destroy()
 {
 if (_array)
 {
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
 DataType* _array;
 size_t _capacity;
 size_t _size;
};
int main()
{
 Stack s;
 s.Init(10);
 s.Push(1);
 s.Push(2);
 s.Push(3);
 cout << s.Top() << endl;
 s.Destroy();
 return 0;
}

3. 类的定义

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

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

  1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
  2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名::

成员变量命名规则的建议：

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

// 所以一般都建议这样

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

// 或者这样

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

4. 类的访问限定符及封装

4.1 访问限定符

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

在这里我们的访问限定符分为三种，分别是：

1.public（公有）
2.protected(保护)
3.private(私有)

【访问限定符说明】：

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

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

4.2 封装

面向对象的三大特性：封装、继承、多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
这种方式可以让通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

5. 类的作用域

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

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

6. 类的实例化

用类类型创建对象的过程，称为类的实例化。

  1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；
  2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量；
  3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

7. 类对象模型

7.1 如何计算类对象的大小

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

类中既可以有成员变量，又可以有成员函数，但是当我们计算类的大小时只计算成员变量的大小，因为我们会将成员函数存放在一块公共区域中。

7.2 讨论类存储的方式

如果我们将对象中包含类的各个成员都进行计算，那么它就会因为每个对象中成员变量是不同的，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份代码，相同代码保存多次，浪费空间。

所以，我们采用了只保存成员变量，成员函数存放在公共的代码段的方法。

// 类中既有成员变量，又有成员函数
class A1 {
public:
    void f1(){}
private:
    int _a;
};
// 类中仅有成员函数
class A2 {
public:
   void f2() {}
};
// 类中什么都没有---空类
class A3
{};

在这里插入图片描述

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

7.3 结构体内存对齐规则（与C语言一致）

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

问题：为什么要进行内存对齐？

CPU把内存当成是一块一块的，块的大小可以是2，4，8，16字节大小，因此CPU在读取内存时是一块一块进行读取的。
假设CPU要读取一个int型4字节大小的数据到寄存器中，分两种情况讨论： 1、数据从0字节开始 2、数据从1字节开始
再次假设内存读取粒度为4。 当该数据是从0字节开始时，很CPU只需读取内存一次即可把这4字节的数据完全读取到寄存器中。

当该数据是从1字节开始时，问题变的有些复杂，此时该int型数据不是位于内存读取边界上，这就是一类内存未对齐的数据。

此时CPU先访问一次内存，读取0—3字节的数据进寄存器，并再次读取4—5字节的数据进寄存器，接着把0字节和6，7，8字节的数据剔除，最后合并1，2，3，4字节的数据进寄存器。对一个内存未对齐的数据进行了这么多额外的操作，大大降低了CPU性能。

8. this指针

8.1 this指针的引出

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,1,11);
 d2.Init(2022, 1, 12);
 d1.Print();
 d2.Print();
 return 0;
}

对于上面的代码，有这样的一个问题：
Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

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

如何测试这个this是否存在，可以在成员函数中加入cout<<this<<endl ，然后你就会发现编译器没有报错，说明this存在。

8.2 this指针的特性

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

问题1：
this指针存在哪里？
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并没有解引用而是直接去调用了在公共区域中的Print函数，所以p为空不影响调用。

问题3

class A
{
public:
 void Print()
 {
 cout << "Print()" << endl;
 }
private:
 int _a;
};
int main()
{
 A* p = nullptr;
 (*p).Print();
 return 0;
}

我们主动的让p去解引用会让运行崩溃吗？答案是不会因为我们的编译器会发现在这里解引用p没有丝毫意义，所以会直接去调用Print.

问题4

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

这个代码呢，他最后会报运行崩溃，因为在执行 cout<<_a<<endl;这条语句时他会对p进行解引用，解引用后发现那一片区域为空。这是因为程序尝试从空指针地址中读取数据，而空指针没有对应的内存地址，所以我们找不到对应的变量。

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语言实现时，Stack相关操作函数有以下共性：
1.每个函数的第一个参数都是Stack*
2.函数中必须要对第一个参数检测，因为该参数可能会为NULL函数中都是3.通过Stack*参数操作栈的
4.调用时必须传递Stack结构体变量的地址
结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

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;
 }
 }
private:
 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*的参数了，编译器编译之后该参数会自动还原，即C++中 Stack * 参数是编译器维护的，C语言中需用用户自己维护。

结束语

本期我们的分享就到这里了，我们主要讲了类和对象的定义和它的一些具体内容。

我们下期再见啦！！！
在这里插入图片描述

果辰辰果
关注
专栏目录
Python基础语法篇（三）：类和对象
qq_42871783的博客
10-19 2976
文章目录一、类和对象介绍二、类的定义和创建实例三、类属性定义及其访问四、类中普通方法定义及调用五、私有属性六、构造方法七、析构方法八、常用内置方法九、继承十、类方法和静态方法 一、类和对象介绍 二、类的定义和创建实例 三、类属性定义及其访问 四、类中普通方法定义及调用 五、私有属性 六、构造方法 七、析构方法 八、常用内置方法 九、继承 十、类方法和静态方法 ......
Python 面向对象（初级篇）
weixin_34261739的博客
08-28 1319
51CTO同步发布地址：http://3060674.blog.51cto.com/3050674/1689163 概述 面向过程：根据业务逻辑从上到下写垒代码 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可 面向对象：对函数进行分类和封装，让开发“更快更好更强...” 面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就...
【Python基础】第十五篇 | 面向对象之初级篇
a272329874a的博客
04-25 2620
面向对象 基本的介绍 面向对象是一个编程思想(写代码的套路) 编程思想： 1.面向过程 2.面向对象 以上两种都属于写代码的套路(方法),最终目的都是为了将代码书写出来,只不过过程和思考方法不太一样 面向过程： 关注的是 具体步骤的实现，所有的功能都自己书写 亲力亲为 定义一个个函数，最终按照顺序调用函数 面向对象： 关注的是结果,谁(对象)能帮我做这件事 偷懒 找一个对象(),让对象去做 类和对象 面向对象的核心思想：找一个对象去帮我们处理事情 在程序代码中 对象是由 类 创建的 类和对象，是面向对象编程
Unity编程-初级篇
Never Give Up
11-09 2305
此篇文章会向你介绍有关Unity中编程的基础知识
UML图-类和类图
张姐姐聊编程
09-26 3687
类(Class)封装了数据和行为，是面向对象的重要组成部分，它是具有相同属性、操作、关系的对象集合的总称。
iOS 初级错误和警告汇总
DCSnail-蜗牛
04-13 3369
这是一篇适合初级开发者学习的文章, 总结了一些很初级的错误和警告.
Java工程师学习指南（初级篇）
热门推荐
Java技术江湖
11-01 1万+
Java工程师学习指南 初级篇 最近有很多小伙伴来问我，Java小白如何入门，如何安排学习路线，每一步应该怎么走比较好。原本我以为之前的几篇文章已经可以解决大家的问题了，其实不然，因为我之前写的文章都是站在Java后端的全局上进行思考和总结的，忽略了很多小白们的感受，而很多朋友都需要更加基础，更加详细的学习路线。 所以，今天我们重新开一个新的专题，分别按照四篇文章讲述Java的学习路线（分别...
cytoscape.js初级篇
娃儿回家
09-29 3265
cytoscape.js初级篇系列文章前言cytoscape依赖引用cytoscape扩展依赖引用创建Cytoscape组件创建Cytoscape模板容器创建Cytoscape实例对象配置Cytoscape实例对象样式配置Cytoscape实例对象添加删除动作完整的Cytoscape组件代码Cytoscape组件的使用创建Cytoscape测试模板Cytoscape组件引用Cytoscape测试模板方法完整的Cytoscape测试模板代码完整截图注意事项 很久之前写过一篇cytoscape.js基础篇, 地
Android中的设计模式初级篇
zhukui66的专栏
12-09 1941
前言 设计模式伴随着我们写代码的一生，总是看了又忘，忘了又看，然后依次循环。在这里用实例或者工作心得记录下设计模式的使用，23种太多，本篇只记录用过的模式，不作过多扩展，后续会针对各个设计模式详细分析。 设计模式分类 创建型模式 对象的创建会消耗掉系统的很多资源，所以单独对对象的创建进行研究，从而能够高效地创建对象就是创建型模式要探讨的问题。 结构型模式 在解决了对象的创建问题之后，对象的组成以及对象之间的依赖关系就成了开发人员关注的焦点，因为如何设计对象的结构、继承和依赖关系会影响到后续
面向对象编程其实很简单——Python 面向对象（初级篇）
haoluojie的博客
11-14 6412
出处：http://www.cnblogs.com/wupeiqi/ 概述面向过程：根据业务逻辑从上到下写垒代码函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可面向对象：对函数进行分类和封装，让开发“更快更好更强...”面向过程编程最易被初学者接受，其往往用一长段代码来实现指定功能，开发过程中最常见的操作就是粘贴复制，即：将之前实现的代码块复制到现需功能处。1234567891
python学习之面向对象【入门初级篇】
12-25
前言 ... 面向对象的基本哲学：世界由具有各自运动规律和内部状态的对象组成，对象之间相互作用和通讯构成了世界。 唯一性，世界没有两片相同的树叶，同样的没有相同的对象。 分类性，分类是对现
Access VBA教程初级篇.pdf
10-26
Access VBA教程初级篇主要针对初学者，旨在教授如何使用Visual Basic for Applications (VBA)在Access数据库中进行编程，以实现自动化数据处理、增强功能和定制化用户界面。VBA是Microsoft Office套件中内置的一种...
Python中的类与对象之描述符详解
01-20
在这篇总结中，我会使用新样式类来指代Python版本。 1、假设一个程序中，我们需要对一个对象属性执行严格的类型检查。然而，Python是一种动态语言，所以并不支持类型检查，但是这并不妨碍我们实现自己版本，且较为...
Weblogic Server系列【初级篇】架构和术语.pdf
12-31
3. **Weblogic JNDI**：Java Naming and Directory Interface，是一种查找和引用分布式环境中对象的标准API。Weblogic JNDI 提供了一种机制来查找和引用服务器中的各种资源。 4. **JTA**：Java Transaction API，...
嵌入式鸿蒙系统开发语言与开发方法分析
嵌入式技术开发
09-10 1146
可复用的UI单元，可组合其它组件，如上述被@Component装饰的struct Hello。UI描述:声明式的方法来描述UI的结构，例如build()方法中的代码块。
C++与QML的数据交互
qq_50679120的博客
09-11 461
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 234
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 866
set、map仿STL模拟实现
C语言从头学59——学习头文件math.h（二）
最新发布
m0_72128260的博客
09-11 430
继续学习头文件的数学函数。
JavaScript初级入门与参考教程：对象导向篇
教程强调的是初级内容，避免了复杂高级技术的探讨，如动态定位、动画和特定浏览器特有的API（如document.captureEvent()），目的是保持教程的简洁和通用性。 该教程采用了一种参考式的结构，注重每个主题的独立性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值