C++类的封装

1、类的引入

在C语言中，结构体只能定义变量；而在C++中，类不仅可以定义变量，还可以定义函数

我们首先来写一个简单的类

struct student{
 
    char name[10];
    int age;
    int id;
};

是不是和C语言的结构体一模一样？？是的！！！

在C++中，struct跟着升级成为了类

struct 就是类的关键字，student 就是类名

*所以C++可以直接使用类名来定义

int main(void)
{
    struct Student s1;
    Student s2;
 
    strcpy(s1.name,"小明");
    s1.age = 10;
    s1.id = 123;
 
    strcpy(s2.name,"小红");
    s2.age = 12;
    s2.id = 111;
 
    return 0;
}

我们既可以用struct Student s1来定义，也可以用Student s2来定义（通过使用类名直接定义）

在C语言中，只能用struct Student来定义，不能直接用类名定义

在C语言中，我们想要将s1中的变量进行初始化，还得一个个赋值，特别麻烦

但是在C++中，我们不仅可以定义变量，还可以定义函数方法

我们可以定义一个“初始化”函数：
 

struct Student{
 
    //成员变量
    char _name[10];
    int _age;
    int _id;
 
    //成员方法
    void Init(const char* name,int age,int id)
    {
        ...
    }
 
};

我们在C++中，称这些变量为成员变量，称这些函数为成员方法

我们来写一个简单的打印函数，测试一下

#include <iostream>
using namespace std;
 
struct student{
    char _name[10];
    int _age;
    int _id;
 
    void Init(const char* name,int age,int id){
        strcpy(_name,name);
        _id = id;
        _age = age;
    }
 
    void Print(){
        cout<<_name<<" "<<_age<<" "<<_id<<endl;
    }
 
};
 
int main(void)
{
    struct Student s1;
    Student s2;
 
    s1.Init("小明",23,111);
    s1.Print();
 
    s2.Init("小红"，22，123)；
    s2.Print();
 
    return 0;    
}

2、class关键字

我们知道，struct在C++中升级成了类，那么C++属于自己的类是什么呢，就是class

class Student{
    ...
};

类的关键字：class                类名：Student

***最后一定记得加  ;     ！！！   加分号

那我们现在将struct改为class

#include <iostream>
using namespace std;
 
class student{
    char _name[10];
    int _age;
    int _id;
 
    void Init(const char* name,int age,int id){
        strcpy(_name,name);
        _id = id;
        _age = age;
    }
 
    void Print(){
        cout<<_name<<" "<<_age<<" "<<_id<<endl;
    }
 
};
 
int main(void)
{
    struct Student s1;
    Student s2;
 
    s1.Init("小明",23,111);
    s1.Print();
 
    s2.Init("小红"，22，123)；
    s2.Print();
 
    return 0;    
}

我们可以发现它报错了，既然C++中的类是class，那为什么会报错呢

下面我们就来提一下，面向对象的三大特性：封装，继承和多态

3、封装

封装的特点

①数据和方法放一起

②访问限定符

下面我们来聊一聊访问限定符

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

一共有三种访问限定符，分别是public（公有），protected（保护），private（私有）

我们一看名字就能想到public就是可以在类外访问，而protected和private就是不能在类外访问

**我们的class默认访问权限是private，struct默认访问权限是public，所以我们刚刚的程序会报错

所以我们把刚才的程序加一个访问限定符就好了

#include <iostream>
using namespace std;
 
class student{
public:
    char _name[10];
    int _age;
    int _id;
 
    void Init(const char* name,int age,int id){
        strcpy(_name,name);
        _id = id;
        _age = age;
    }
 
    void Print(){
        cout<<_name<<" "<<_age<<" "<<_id<<endl;
    }
 
};
 
int main(void)
{
    struct Student s1;
    Student s2;
 
    s1.Init("小明",23,111);
    s1.Print();
 
    s2.Init("小红"，22，123)；
    s2.Print();
 
    return 0;    
}

那我们继续讨论访问限定符：

①访问权限作用域从该访问限定符出现位置开始，直到下一个访问限定符出现为止

②如果后面没有访问限定符，作用域就到该类结束

什么是封装

封装：将数据和操作方法进行有效结合，隐藏对象的属性和实现细节，仅对外公开接口来实现对象进行交互

①把数据都封装到类中

②可以给你访问的定义为公有，不想给你访问的定义为私有或保护

封装的意义

封装是为了更好的管理，封装的本质就是一种管理

4、类的作用域和实例化

类定义的两种方式

①声明和定义都放在类中

class Student{
public:
    void Init(const char* name,int age,int id)
    {
        strcpy(_name,name);
        _age = age;
        _id = id;
    }
 
    void Print()
    {
        cout<<_name<<""<<_age<<""<<_id<<endl;
    }
 
private:
    char _name[10]；
    int _age;
    int _id;
};

②声明和定义分离

class Student{
    
public:
    void Init(const char* name,int age,int id);
    void Print();
       
private:
    char _name[10];
    int _age;
    int _id;
};
 
void Student::Init(const char* name,int age,int id)
{
    strcpy(_name,name);
    _id = id;
    _age = age;
}
 
void Student::Print()
{
    cout<<_name<<""<<_age<<""<<_id<<endl;
}

类的实例化

类本身是没有存储空间的，只有建立对象（即实例化），才会有实际的存储空间

5、类对象模型

计算类的存储大小

类中既有成员变量，又有成员函数，那么它的大小是多少呢

对象中存了成员变量，是否存了成员函数呢？没存成员函数！！

计算类或类对象的大小只看成员变量！！！

6、this指针

this指针的类型：类类型* const

this指针只能在“成员函数”的内部使用

this指针本质上是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参，所以对象中不存储this指针