C++ 封装 - 技术栈

1.封装

cpp认为万事万物都可以封装

封装将属性和行为作为一个整体，表现生活中的事物。

将属性和行为加以权限控制。

语法：

class 类名{

访问权限:

属性或者行为

}

cpp 复制代码

//学生类
class Student {
public:
	void setName(string name) {
		m_name = name;
	}
	void setID(int id) {
		m_id = id;
	}

	void showStudent() {
		cout << "name:" << m_name << " ID:" << m_id << endl;
	}
public:
	string m_name;
	int m_id;
};

int main() {

	Student stu;
	stu.setName("德玛西亚");
	stu.setID(250);
	stu.showStudent();

	system("pause");

	return 0;
}

类在设计时，可以将不同的属性和行为放在不同的权限下，加以控制。

在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：

struct 默认权限为公共
class 默认权限为私有

访问权限有三种：

|------------------------|----------------|
| 1.public公共权限，类默认权限 | 类内可以访问，类外可以访问 |
| 2.protected | 类内可以访问，类外不可以访问 |
| 3.private （struct默认权限） | 类内可以访问，类外不可以访问 |

cpp 复制代码

//三种权限
//公共权限  public     类内可以访问  类外可以访问
//保护权限  protected  类内可以访问  类外不可以访问
//私有权限  private    类内可以访问  类外不可以访问

class Person
{
	//姓名  公共权限
public:
	string m_Name;

	//汽车  保护权限
protected:
	string m_Car;

	//银行卡密码  私有权限
private:
	int m_Password;

public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};

int main() {

	Person p;
	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	system("pause");

	return 0;
}

对象的构造函数和析构函数

这两个函数将会被编译器自动调用，完成对象初始化和清理工作

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现。

● 构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。

● 析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

1 . 构造函数，没有返回值也不写void

2 . 函数名称与类名相同

3 . 构造函数可以有参数，因此可以发生重载

4 . 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法： ~类名(){}

1 . 析构函数，没有返回值也不写void

2 . 函数名称与类名相同,在名称前加上符号 ~

3 . 析构函数不可以有参数，因此不可以发生重载

4 . 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

构造函数的分类以及调用

两种分类方式：

按参数分为：有参构造和无参构造

按类型分为：普通构造和拷贝构造

三种调用方式：

括号法

显示法

隐式转换法

cpp 复制代码

//2.1 括号法，常用
Person p1(10);
//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
//Person p2();
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);

拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

● 使用一个已经创建完毕的对象来初始化一个新对象

● 值传递的方式给函数参数传值

● 以值方式返回局部对象

cpp 复制代码

#include<iostream>


using namespace std;


class Person {

public:
    int age;
public:
    Person(){

        cout << "Person类的无参构造函数"<< endl;
    }
    Person(int age){
        this->age=age;
        cout << "Person类的有参构造函数"<< endl;
    }

    Person(const Person &p){
        this->age=p.age;
        cout << "Person类的拷贝构造函数"<< endl;
    }

    ~Person(){
        cout << "Person类的析构函数" <<age<< endl;
    }
};
void test01(){
//  1.使用一个已经创建完毕的对象来初始化一个新对象
    Person p2(10);
    Person p3(p2);
}
void dowork(Person p){
    cout << "dowork" << endl;
}
void test02(){
//  2.值传递的方式给函数参数传值
    Person p;
    dowork(p);
}
Person doWork2(){
    Person p;
    cout << (int*)&p << endl;
    return p;
}
void test03(){
//  3.值方式返回局部对象
    Person p=doWork2();
    cout<< (int*)&p << endl;
}
int main(){
    test01();
    test02();
    test03();
    return 0;
}

构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

● 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

● 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

cpp 复制代码

#include<iostream>
using namespace std;
class Person {
public:
    int age;
public:
//    Person(){
//
//        cout << "Person类的无参构造函数"<< endl;
//    }
//    Person(int age){
//        this->age=age;
//        cout << "Person类的有参构造函数"<< endl;
//    }
    Person(const Person &p){
        this->age=p.age;
        cout << "Person类的拷贝构造函数"<< endl;
    }

    ~Person(){
        cout << "Person类的析构函数" <<age<< endl;
    }
};
void test(){
    Person p(10);
    Person q(p);

}
int main(){
    test();
    return 0;
}

深拷贝和浅拷贝问题

浅拷贝：简单的赋值操作，

深拷贝：在堆区重新申请空间，进行拷贝操作

如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题

这段代码Person p2(p1),如果使用默认的拷贝构造函数，那就是浅拷贝，如下图，只是把

p1height里存放的地址给拷贝过去。

那么在做析构的时候，会出现重复释放堆区内存的问题。

深拷贝能解决这个堆区内存重复释放问题。

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性

语法：构造函数()：属性1(值1),属性2（值2）... {}

cpp 复制代码

//初始化列表方式初始化
 Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
void PrintPerson() {
cout << "mA:" << m_A << endl;
cout << "mB:" << m_B << endl;
cout << "mC:" << m_C << endl;
}

类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

B类中有对象A作为成员，A为对象成员。

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

A构造

B构造

B析构

A析构

cpp 复制代码

#include<iostream>
using namespace std;
class Phone{
public:
    Phone(string name){
        this->name = name;
        cout<<"Phone构造函数"<<endl;
    }
    ~Phone(){
        cout<<"Phone析构函数"<<endl;
    }
    string name;
};
class Person{
public:
    string name;
    Phone mphone;

    Person(string name,string pname):name(name),mphone(pname){
        cout<<"Person构造函数"<<endl;
    }
    ~Person() {
        cout << "Person析构函数" << endl;
    }
};
void test(){
    Person p("张三","苹果");
    cout<<"姓名："<<p.name<<" 手机："<<p.mphone.name<<endl;
}
int main(){
    test();
    return 0;
}

结果：

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

静态成员变量

● 所有对象共享同一份数据

● 在编译阶段分配内存

● 类内声明，类外初始化

静态成员函数

● 所有对象共享同一个函数

● 静态成员函数只能访问静态成员变量

cpp 复制代码

#include<iostream>
using namespace std;
class Person{
public :
    int age;
    static int count;
    static void display(){
        cout<<"静态成员函数："<<count<<endl;
//        cout<<age<<endl;   访问非静态成员变量 报错
    }
};

int Person::count=0;

int main(){
    Person p;
    p.age=10;
    cout<<p.count<<endl;
    p.count=123;
    Person::count=123;
    cout<<p.count<<endl;
    Person::display();
    p.display();
    Person q;
    q.count=5555;
    q.display();
    p.display();
    return 0;
}

this指针

在c++中，类的成员变量和成员函数分开存储

静态成员变量不占对象空间，函数也不占用对象空间，所有函数共享一个函数实例。

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码。

this指针指向被调用的成员函数所属的对象。

this指针的用途：

● 当形参和成员变量同名时，可用this指针来区分

● 在类的非静态成员函数中返回对象本身，可使用return *this

空指针访问成员函数

c++中空指针也可以调用成员函数，但是也要注意有没有用到this指针，如果用到this指针，需要加以判断保证代码的健壮性

cpp 复制代码

//空指针访问成员函数
class Person {
public:
    void ShowClassName() {
        cout << "我是Person类!" << endl;
    }
    void ShowPerson() {
        if (this == NULL) {
            return;
        }
        cout << mAge << endl;
    }
public:
    int mAge;
};
void test01()
{
    Person * p = NULL;
    p->ShowClassName(); //空指针，可以调用成员函数
    p->ShowPerson(); //但是如果成员函数中用到了this指针，就不可以了
}
int main() {
    test01();
    system("pause");
    return 0;
}

const修饰成员函数

常函数：

● 成员函数后加const后我们称为这个函数为**常函数**

● 常函数内不可以修改成员属性

● 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

● 声明对象前加const称该对象为常对象

● 常对象只能调用常函数

cpp 复制代码

#include<iostream>
using namespace std;
class Person{
public :
    int a;
    mutable int m_b;
    Person(int a, int b):a(a),m_b(b){}
    Person(){
    }
    void show() const{
        cout<<a<<endl;
        cout<<m_b<<endl;
        m_b=111;
        cout<<m_b<<endl;
    }
};
int main(){
    Person p(10,20);
    p.show();
    return 0;
}

友元函数

生活中你的家有客厅(Public)，有你的卧室(Private)

客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去

但是呢，你也可以允许你的好闺蜜好基友进去。

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

友元的目的就是让一个函数或者类访问另一个类中私有成员

友元的关键字为 ==friend==

友元的三种实现

● 全局函数做友元

● 类做友元

● 成员函数做友元

全局函数做友元函数

cpp 复制代码

#include<iostream>
using namespace std;
class Building{
//    全局函数做友元函数，可以访问类中的私有成员
    friend void goodGay(Building building);
    public:
    string m_SittingRoom;
    Building(){
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
private:
    string m_BedRoom;

};

void goodGay(Building building) {
    cout << "好基友正在访问：" << building.m_SittingRoom << endl;
    cout << "好基友正在访问：" << building.m_BedRoom << endl;
}
int main(){
    Building b;
    goodGay(b);
    return 0;
}

类做友元：

cpp 复制代码

#include<iostream>
using namespace std;
class Building{
//    类做友元函数，可以访问类中的私有成员
    friend class goodGay;
    public:
    string m_SittingRoom;
    Building(){
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
private:
    string m_BedRoom;
};
class goodGay{
public:
    goodGay(){
        building = new Building;
    }
    void visit(){
        cout << "好基友正在访问：" << building->m_SittingRoom << endl;
        cout << "好基友正在访问：" << building->m_BedRoom << endl;
    }
    Building *building;
};
int main(){
    goodGay gg;
    gg.visit();
    return 0;
}

成员函数做友元函数

cpp 复制代码

#include<iostream>
using namespace std;
class Building;
class goodGay{
public:
    Building *building;
    goodGay();
    void visit();

};
class Building{
//    类做友元函数，可以访问类中的私有成员
    friend void goodGay::visit();
    public:
    string m_SittingRoom;

    Building(){
        m_SittingRoom = "客厅";
        m_BedRoom = "卧室";
    }
private:
    string m_BedRoom;
};
//不知道为甚，这俩函数只能放在类外面
goodGay::goodGay(){
    building = new Building;
}

void goodGay::visit() {
    cout << "好基友正在访问：" << building->m_SittingRoom << endl;
    cout << "好基友正在访问：" << building->m_BedRoom << endl;

}
int main(){
    goodGay gg;
    gg.visit();
    return 0;
}