我与C++的爱恋:类与对象(一)
🔥个人主页:guoguoqiang. 🔥专栏:我与C++的爱恋
C语言是面向过程的,关注的是过程,分析出求解问题的步骤,通过函数调用逐步解决问题。
C++是基于面向对象的,关注的是对象,将一件事情拆分成不同的对象,靠对象之间的交互完成。
一、类的引入
C语言结构体中只能定义变量,在C++中,结构体内不仅可以定义变量,也可以定义函数。
C语言方式实现的栈,结构体中只能定义变量;现在以C++方式实现,会发现struct中也可以定义函数。
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相关操作函数有以下共性:
每个函数的第一个参数都是Stack*
函数中必须要对第一个参数检测,因为该参数可能会为NULL
函数中都是通过Stack*参数操作栈的
调用时必须传递Stack结构体变量的地址
结构体中只能定义存放数据的结构,操作数据的方法不能放在结构体中,即数据和操作数据的方式是分离开的,而且实现上相当复杂一点,涉及到大量指针操作,稍不注意可能就会出错
1.数据和操作数据的方式是分离开的。
2.数据访问控制是自由的不受控制的。
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语言中需用用户自己维护。
1.C++中通过类可以将数据以及操作数据的方法进行完美结合,通过1访问权限可以控制那些方法在类外可以被调用,即封装。
2.控制访问方式愿意给你访问的为公有,不愿意给你访问的为私有。
在C++中更喜欢用class来代替
二、类的定义
class className { // 类体:由成员函数和成员变量组成 }; // 一定要注意后面的分号
class为定义类的关键字,ClassName为类的名字,{}中为类的主体,注意类定义结束时后面分号不能省略。
类体中内容称为类的成员:类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。
类的两种定义方式:
-
声明和定义全部放在类体中,需注意:成员函数如果在类中定义,编译器可能会将其当成内
联函数处理。
-
类声明放在.h文件中,成员函数定义放在.cpp文件中,注意:成员函数名前需要加类名::
在我们日常使用时尽量使用第二种。
成员变量命名规则的建议:
// 我们看看这个函数,是不是很僵硬? class Date { public: void Init(int year) { // 这里的year到底是成员变量,还是函数形参? year = year;//形参一般建议 _year mYear year_ } private: int year; };
三、类的访问限定符及封装
1.访问限定符
C++实现封装的方式:用类将对象的属性与方法结合在一块,让对象更加完善,通过访问权限选择性的将其接口提供给外部的用户使用。
【访问限定符说明】
- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
- 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
- 如果后面没有访问限定符,作用域就到 } 即类结束。
- class的默认访问权限为private,struct为public(因为struct要兼容C)
访问限定符只在编译时有用,当数据映射到内存后,没有任何访问限定符上的区别
class Date { public: void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; int main() { Date d; d.Init(2024, 4, 4); return 0; }
2.封装
面向对象的三大特性:封装、继承、多态。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。
封装本质上是一种管理,让用户更方便使用类。
在C++语言中实现封装,可以通过类将数据以及操作数据的方法进行有机结合,通过访问权限来隐藏对象内部实现细节,控制哪些方法可以在类外部直接被使用。(想让你看到的就是public,不想让你看到的就是 private)。
四、类的作用域
类定义了一个新的作用域,类的所有成员都在类的作用域中。在类体外定义成员时,需要使用 ::作用域操作符指明成员属于哪个类域。
class Person { public: void PrintPersonInfo(); private: char _name[20]; char _gender[3]; int _age; }; // 这里需要指定PrintPersonInfo是属于Person这个类域 void Person::PrintPersonInfo() { cout Person._age = 100; // 编译失败:error C2059: 语法错误:“.” return 0; } public: void PrintA() { cout public: void f1(){} private: int _a; }; // 类中仅有成员函数 class A2 { public: void f2() {}//大小为1,不存储有效数据,占位,标识对象被实例化定义出来了。 }; // 类中什么都没有---空类 class A3 {};//大小为1,不存储有效数据,占位,标识对象被实例化定义出来了。 public: void Init(int year, int month, int day) { _year = year; _month = month; _day = day; } void Print() { cout Date d1, d2; d1.Init(2022,1,11); d2.Init(2022, 1, 12); d1.Print(); d2.Print(); return 0; } public: void Print() { cout A* p = nullptr; p-Print();//正常运行因为没有访问任何对象的成员变量,这里不需要访问通过this指针指示的内存地址。 return 0; } // 1.下面程序编译运行结果是? A、编译报错 B、运行崩溃 C、正常运行//B class A { public: void PrintA() { cout A* p = nullptr; p-PrintA();//这里发生了报错,因为这里访问a是通过this-a来实现的 return 0; }