C++ 封装-编程知识

1.封装

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

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

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

语法：

class 类名{

访问权限:

属性或者行为

}

//学生类
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默认权限）	类内可以访问，类外不可以访问

//三种权限
//公共权限  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 . 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

构造函数的分类以及调用

两种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法

//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++中拷贝构造函数调用时机通常有三种情况
● 使用一个已经创建完毕的对象来初始化一个新对象
● 值传递的方式给函数参数传值
● 以值方式返回局部对象

#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++不会再提供其他构造函数

#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）... {}

//初始化列表方式初始化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析构

#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，称为静态成员
静态成员分为：
静态成员变量
● 所有对象共享同一份数据
● 在编译阶段分配内存
● 类内声明，类外初始化
静态成员函数
● 所有对象共享同一个函数
● 静态成员函数只能访问静态成员变量

#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指针，需要加以判断保证代码的健壮性

//空指针访问成员函数
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称该对象为常对象
● 常对象只能调用常函数

#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==
友元的三种实现
● 全局函数做友元
● 类做友元
● 成员函数做友元

全局函数做友元函数

#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;
}

类做友元：

#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;
}

成员函数做友元函数

#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;
}