C++学习 --类和对象之封装

目录

1， 什么是封装

2， 创建类

3， 权限控制

3-1， public权限

3-2， private权限

3-3， protected权限

3-4， 类外访问私有属性

4， 构造函数

4-2，创建构造函数

4-2-1， 无参构造函数

4-2-2， 有参构造函数

4-3， 调用构造函数

4-3-1， 括号法调用

4-3-2， 显示法调用

4-3-3， 无参构造函数调用

5， 初始化列表

6， 拷贝构造函数

6-1， 创建拷贝构造函数

6-2， 调用拷贝构造函数

6-2-1， 括号法调用

6-2-2， 显示法调用

7， 析构函数

8， 结构体与类的区别

9， 拆分类到不同文件中

9-1， 创建类的头文件

9-2， 创建类的源文件

9-3， 在主函数中调用

9-4， 构造函数调用规则

10， 深拷贝与浅拷贝

10-1， 浅拷贝

10-2， 深拷贝

11， 类可作为类的成员

12， 静态成员

12-1， 静态成员变量

12-1-1， 静态成员变量访问

12-1-1-1， 类内访问

12-1-1-2， 类外访问

12-1-2， 静态成员变量修改

12-1-2-1， 类内修改

12-1-2-2， 类外修改

12-2， 静态成员函数

12-2-1， 静态成员函数访问

13， 成员函数和成员变量分开存储

14， this指针

14-1， this指针处理同名

14-2， this实现链式编程

14-3， this指向

15， const修饰成员属性

15-1， 常函数

15-2， 常对象

---

1， 什么是封装

将对象的数据属性和行为属性封装到一个类中，并加以权限控制， 就叫封装

2， 创建类

通过class 类名{权限：属性}， 可创建一个类

class Person
{
public://定义数据属性int m_a;//定义行为属性void func(){}
};

3， 权限控制

权限分为public， private， private三种， 若没有指定权限关键字，则默认为private权限

3-1， public权限

public表示公共权限， 类内外均可访问public权限的属性， 子类可访问父类的public的属性

public:int m_age;

3-2， private权限

private表示私有权限， 仅类内可访问，类外不能访问， 子类不可访问父类的private的属性

private:int m_age;

3-3， protected权限

protected表示保护权限， 仅类内可访问，类外不能访问， 子类可访问父类的protected属性

protected:int m_age;

3-4， 类外访问私有属性

若要访问类的私有权限， 可通过在类中设置public的方法， 在类外调用public方法进行访问

4， 构造函数

通过构造函数给类的实例初始化， 构造函数是与类同名， 无数据类型

4-2，创建构造函数

4-2-1， 无参构造函数

 通过类名 () {语句块}， 可创建无参构造函数

class Person
{
public:Person(){		cout << "这是一个无参构造函数" << endl;}
};

4-2-2， 有参构造函数

 通过类名 (行参1, ..., 形参n) {语句块}， 可创建有参构造函数

public:Person(string name, string sex, int age){m_name = name;m_sex = sex;m_age = age;cout << "这是一个有参构造函数" << endl;}string m_name;string m_sex;int m_age;

4-3， 调用构造函数

4-3-1， 括号法调用

通过类名 对象名(实参1, ..., 实参n)的方式调用

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(string name, string sex, int age){	m_name = name;m_sex = sex;m_age = age;cout << "m_name:" << m_name << endl;cout << "m_sex:"  << m_sex  << endl;cout << "m_age:"  << m_age  << endl;}string m_name;string m_sex;int m_age;
};void test()
{Person p("张三", "男", 25);
}int main()
{test();system("pause");return 0;
}
-------------------------------------------------------------------
输出结果：
m_name:张三
m_sex:男
m_age:25

4-3-2， 显示法调用

通过类名 对象名 = 类名(实参1, ..., 实参n)的方式调用

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(string name, string sex, int age){	m_name = name;m_sex = sex;m_age = age;cout << "m_name:" << m_name << endl;cout << "m_sex:"  << m_sex  << endl;cout << "m_age:"  << m_age  << endl;}string m_name;string m_sex;int m_age;
};void test()
{Person p = Person("张三", "男", 25);
}int main()
{test();system("pause");return 0;
}
-------------------------------------------------------------------
输出结果：
m_name:张三
m_sex:男
m_age:25

4-3-3， 无参构造函数调用

通过类名 对象名， 可进行无参构造函数调用

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(){	cout << "这是一个无参构造函数" << endl;}
};void test()
{//无参构造函数调用， 注意没有括号， 因为Person p()会当着一个函数声明Person p;
}int main()
{test();system("pause");return 0;
}
-----------------------------------------------------------------------
输出结果：
这是一个无参构造函数

5， 初始化列表

通过构造函数(数据类型 变量1, ..., 数据类型 变量n):属性1(变量1)...属性n(变量n){}的方式， 可初始化对象的属性

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(string name, string sex, int age):m_name(name),m_sex(sex),m_age(age){		cout << "m_name:" << m_name << endl;cout << "m_sex:"  << m_sex  << endl;cout << "m_age:"  << m_age  << endl;}string m_name;string m_sex;int m_age;
};void test()
{Person p("张三", "男", 25);
}int main()
{test();system("pause");return 0;
}
------------------------------------------------------------------
输出结果：
m_name:张三
m_age：25
m_sex:男

6， 拷贝构造函数

若用户没有自定义拷贝构造函数， 编译器会自动创建一个拷贝构造函数(具有属性拷贝功能)， 拷贝构造与类同名， 无数据类型

6-1， 创建拷贝构造函数

通过类名(const 类名 &对象)方式， 可创建一个拷贝构造函数， 传递的参数为类对象

class Person
{
public://因为拷贝构造的数据来源与构造函数， 所以必须先定义构造函数Person(){}//拷贝构造函数：形参需要是一个常量引用Person(const Person& p){cout << "Person类拷贝参构造函数调用" << endl;}
};

6-2， 调用拷贝构造函数

6-2-1， 括号法调用

通过类名 实例(实例1)方式， 可调用拷贝构造函数

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(string name, string sex, int age):m_name(name), m_sex(sex), m_age(age){}Person(const Person& p){m_name = p.m_name;m_sex = p.m_sex;m_age = p.m_age;}string m_name;string m_sex;int m_age;
};void test()
{//拷贝构造参数为对象， 所以先要创建对象Person p2("张三", "男", 25);//拷贝构造函数调用, 在拷贝构造函数里面通过p2进行赋值Person p3(p2);cout << "m_name:" <<  p3.m_name << endl;cout << "m_age：" << p3.m_age << endl;cout << "m_sex:" << p3.m_sex << endl;//编译器会当着Person p3进行处理， 与Person p3(p2)冲突， 重复定义p3//Person(p3);
}int main()
{test();system("pause");return 0;
}
------------------------------------------------------------------
输出结果：
m_name:张三
m_age：25
m_sex:男

6-2-2， 显示法调用

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(string name, string sex, int age):m_name(name), m_sex(sex), m_age(age){}Person(const Person& p){m_name = p.m_name;m_sex = p.m_sex;m_age = p.m_age;}string m_name;string m_sex;int m_age;
};void test()
{//拷贝构造参数为对象， 所以先要创建对象Person p2("张三", "男", 25);//拷贝构造函数调用, 在拷贝构造函数里面通过p2进行赋值Person p3 = Person(p2);cout << "m_name:" <<  p3.m_name << endl;cout << "m_age：" << p3.m_age << endl;cout << "m_sex:" << p3.m_sex << endl;//编译器会当着Person p3进行处理， 与Person p3(p2)冲突， 重复定义p3//Person(p3);
}int main()
{test();system("pause");return 0;
}
------------------------------------------------------------------
输出结果：
m_name:张三
m_age：25
m_sex:男

 类对象当着函数参数传递时，会调用拷贝构造函数

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(int a){cout << "调用Person类有参构造函数" << endl;}Person(const Person& p){cout << "调用Person类拷贝构造函数" << endl;}
};void func(Person p)
{cout << "func调用" << endl;
}int main()
{Person p1(10);//函数参数为类对象， 调用下面的函数会自动调用拷贝构造函数func(p1);system("pause");return 0;
}
---------------------------------------------------------------
输出结果：
调用Person类有参构造函数
调用Person类拷贝构造函数
func调用

7， 析构函数

通过~类名 () {代码块}， 可创建一个析构函数， 其作用是清理对象的数据， 

#include <iostream>
#include <string>using namespace std;class Person
{
public://析构函数名与是~类名， 在对象释放时，由编译器调用//析构函数没有参数~Person(){cout << "Person类构造函数调用" << endl;}
};int main()
{//创建对象p， 编译器会自动调用构造函数//main函数运行完后释放p， 则调用析构函数Person p;system("pause");return 0;
}
----------------------------------------------------
输出结果：
请按任意键继续. . .
Person类构造函数调用

8， 结构体与类的区别

结构体属性权限默认为公共权限， 类的属性权限默认为私有权限

struct Student
{//默认为公共权限string m_name;
};
class Student
{//默认为私有权限privatestring m_name;
};

9， 拆分类到不同文件中

类的声明和定义可拆分到不同的文件中， 声明放在一个头文件中， 类定义放在一个源文件中

9-1， 创建类的头文件

在头文件中，实现类以及其属性声明

在项目的头文件夹中， 创建person.h

#pragma once
#include <iostream>
#include <string>using namespace std;class Person
{
public:void func1();void func2();string func3();string func4();protected:void func5();private:string m_name = "张三";string m_sex = "男";void func6();
};

9-2， 创建类的源文件

在源文件中，实现方法的定义

在项目的源文件夹中， 创建person.cpp源文件

#include <iostream>
#include <string>
#include "person.h"using namespace std;//Person::func1()， 表示申明func1在Person类中
void Person::func1()
{return func5();
}void Person::func2()
{return func6();
}string Person::func3()
{return m_name;
}string Person::func4()
{return m_sex;
}void Person::func5()
{cout << "类保护属性访问" << endl;
}void Person::func6()
{cout << "类私有属性访问" << endl;
}

9-3， 在主函数中调用

#include <iostream>
#include <string>
#include "person.h"using namespace std;void test()
{Person p;p.func1();p.func2();cout << "获取类的私有属性：" << p.func3() << endl;cout << "获取类的保护属性：" << p.func4() << endl;
}int main()
{	test();system("pause");return 0;
}

9-4， 构造函数调用规则

默认情况下， 创建一个类， 编译器会自动创建默认构造函数(空实现)， 默认析构函数(空实现)， 拷贝构造函数(具有属性拷贝功能)

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(int age){m_age = age;cout << "Person类有参构造调用" << endl;}int m_age;
};int main()
{Person p1(10);//虽然Person类没有定义拷贝构造函数， 但是会默认提供一个//所以下面能正常打印Person p2(p1);cout << "p2的年龄：" << p2.m_age << endl;system("pause");return 0;
}
----------------------------------------------------------------
输出结果：
Person类有参构造调用
p2的年龄：10

说明：

1， 若在类中只定义有参构造函数， 则编译器不会自动提供默认构造函数

2， 若在类中只定义拷贝构造函数， 则编译器不会自动提供默认和有参构造函数

10， 深拷贝与浅拷贝

10-1， 浅拷贝

没有在堆区重新申请空间的赋值拷贝， 为浅拷贝

10-2， 深拷贝

在堆区重新申请空间的赋值拷贝， 为深拷贝

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(int age, int height){m_age = age;//在堆区创建一块内存m_height = new int(height);cout << "Person类有参构造调用" << endl;}//拷贝构造函数的作用是用户可自定义在堆区创建一块内存给p3使用//防止p2释放内存后，p3再次释放就放报错的问题//若使用编译器提供的拷贝构造函数， 就会出现上面说的问题Person(const Person& p){m_age = p.m_age;m_height = new int(*p.m_height);}~Person(){cout << "析构函数调用" << endl;//在堆区释放内存时，要注意是否会存在多次释放的情况if (m_height != NULL){delete m_height;m_height = NULL;}}int m_age;int* m_height;
};int main()
{Person p1(10, 160);Person p2(p1);cout << "p2的年龄：" << p2.m_age << endl;system("pause");return 0;
}
-----------------------------------------------------------
输出结果：
Person类有参构造调用
p2的年龄：10
请按任意键继续. . .
析构函数调用
析构函数调用

说明：在堆区释放内存时，要注意是否会存在多次释放的情况

11， 类可作为类的成员

#include <iostream>
#include <string>using namespace std;class Phone
{
public:Phone(string pname, int tel) :m_pname(pname), m_ptel(tel) {};string m_pname;int m_ptel;
};class Person
{
public:Person(string name, Phone phone):m_name(name), m_phone(phone.m_pname, phone.m_ptel){}string m_name;//类成员作为成员属性Phone m_phone;
};int main()
{	Phone phone("苹果", 123456789);Person p1("张三", phone);cout << "姓名：" << p1.m_name << endl;cout << "机型：" << p1.m_phone.m_pname << endl;cout << "号码：" << p1.m_phone.m_ptel << endl;system("pause");return 0;
}

12， 静态成员

静态成员分为静态成员变量和静态成员函数

12-1， 静态成员变量

在类中， 通过static 数据类型 变量， 可定义一个静态成员变量， 所有的对象共享， 静态成员只能在类外定义

class Person
{
public://类内声明static int m_a;
};//类外定义， Person::m_a：表示m_a是属于Person中
int Person::m_a = 100;

12-1-1， 静态成员变量访问

分为类内访问和类外访问两种

12-1-1-1， 类内访问

通过变量名进行访问

cout << "m_a:" << m_a << endl;

12-1-1-2， 类外访问

 通过实例.静态成员变量或者类名::静态成员变量

cout << p1.m_a << endl;
cout << Person::m_a << endl;

12-1-2， 静态成员变量修改

12-1-2-1， 类内修改

通过类内的方法进行修改

class Person
{
public:static int m_a;void func(){//修改静态变量的值m_a = 1000;cout << "m_a:" << m_a << endl;}
};

12-1-2-2， 类外修改

通过实例.静态成员变量 = 值或者类名::静态成员变量 = 值进行修改

#include <iostream>
#include <string>using namespace std;class Person
{
public:static int m_a;
};//m_a是静态成员变量， 需要在类外定义
int Person::m_a = 100;void test()
{Person p1;Person p2;cout << "p1.m_a:" << p1.m_a << endl;cout << "p2.m_a:" << p2.m_a << endl;//因为所有对象共享一份数据，任意对象将属性修改，都会映射到其他对象p1.m_a = 200;cout << "p1.m_a:" << p1.m_a << endl;cout << "p2.m_a:" << p2.m_a << endl;
}int main()
{	test();system("pause");return 0;
}
-----------------------------------------------------
输出结果：
p1.m_a:100
p2.m_a:100
p1.m_a:200
p2.m_a:200

12-2， 静态成员函数

所有对象共享同一个函数， 静态成员函数只能访问静态成员变量， 不能在静态成员变量中访问非静态成员变量

12-2-1， 静态成员函数访问

通过实例.成员函数()或者类::成员函数()， 可访问静态成员函数

#include <iostream>
#include <string>using namespace std;class Person
{
public:static void func(){//m_a是静态成员变量， 静态成员函数可以访问m_a = 100;//由于m_b不是静态成员变量， 所以m_b = 200是非法的//m_b = 200;cout << "static void func调用" << endl;}static int m_a;int m_b;
};int Person::m_a = 100;void test()
{Person p1;cout << "通过对象访问静态成员函数：" << endl;p1.func();cout << "通过类名访问静态成员函数：" << endl;Person::func();
}int main()
{	test();system("pause");return 0;
}

13， 成员函数和成员变量分开存储

类中的成员函数和成员变量是分开存储的，只有非静态成员变量与类存储在一起，成员函数、静态成员函数、静态成员变量都不存储在类上， 所以类占用内存空间的大小由非静态成员变量决定

#include <iostream>
#include <string>using namespace std;class Person
{//只有非静态成员变量与类在一块内存空间int m_a;  //下面的三种都不在类的内存空间void func() {};static int m_b;static void func1() {};
};void test()
{Person p;cout << "sizeof of p:" << sizeof(p) << endl;
}int main()
{test();system("pause");return 0;
}
------------------------------------------------------------
sizeof of p:4

说明：若类是一个空对象，则分配1个字节空间

14， this指针

this指针是类中所有成员属性自带的指针， 不用显示给出

m_age = age;
等价于
this->m_age = age;

14-1， this指针处理同名

当形成与成员属性同名时， 可通过this进行区分

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(int age){//若出现下面这种形参和成员属性同名的情况， 左右值都表示形参//age = age;//通过this->age， 才能表示成员属性agethis->age = age;};int age;
};void test()
{Person p(10);cout << "age:" << p.age << endl;
}int main()
{test();system("pause");return 0;
}
--------------------------------------------------------------
输出结果：
age:10

14-2， this实现链式编程

通过*this， 返回对象的本身， 若要实现链式编程， 则需要以引用的方式返回， 因为引用的修改会映射到原对象

#include <iostream>
#include <string>using namespace std;class Person
{
public:Person(int age){m_age = age;};//注意返回的是引用Person& func(int age){m_age += age;//通过*this返回对象本身return *this;}int m_age;
};void test()
{Person p(10);//链式编程p.func(10).func(10).func(10);cout << "age:" << p.m_age << endl;
}
int main()
{test();system("pause");return 0;
}
------------------------------------------------------------
输出结果：
age:40

14-3， this指向

this指向的是调用成员函数的对象

#include <iostream>
#include <string>using namespace std;class Person
{
public:void func_1(){cout << "函数调用func！" << endl;};void func_2(int age){//防止报错if (this == NULL){return;}//编译器会当着this->m_a = age， 但是p又指向空指针，所以报错， 通过上面的if防止报错m_age = age;};int m_age;
};void test()
{Person* p = NULL;//下面这部没有使用到this， 所以正常执行p->func_1();//this指向的调用属性的对象， 这里就指向p， p是空指针p->func_2(10);
}int main()
{test();system("pause");return 0;
}

15， const修饰成员属性

15-1， 常函数

在类中， 通过const修饰的成员函数， 叫着常函数， 常函数中不能修改成员属性， 但是可修改mutable修饰的成员变量

class Person
{
public://通过const修饰的函数为常函数void func_1() const{//因为func_1是常函数，不能修改成员属性，所以下面的操作非法//m_age = 100;//因为m_name使用了关键字mutable， 所以能够修改m_name = "张三";};int m_age;//mutable的作用，在常函数中能够修改的变量 mutable string m_name;
};

15-2， 常对象

通过在对象前加const， 则该对象就是常对象， 常对象只能调用常函数

#include <iostream>
#include <string>using namespace std;class Person
{
public://通过const修饰的函数为常函数void func_1() const{cout << "func_1调用" << endl;};void func_2(){};
};void test()
{//通过const修饰的对象为常对象， 常对象只能调用常函数const Person p;//p是常对象， func_2不是常函数，所以下面的操作非法//p.func_2()//func_1是常函数，可以调用p.func_1();
}int main()
{test();system("pause");return 0;
}
-----------------------------------------------------------------
输出结果：
func_1调用