C++之类（一）

1，封装

1.1  封装的引用

封装是C++面向对象三大特性之一

封装的意义：

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

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

1.1.1  封装意义一：

在设计类的时候，属性和行为写在一起，表现事物

语法：class 类名 {  访问权限：  属性/行为   }；

示例一：

设计一个圆类，求圆的周长

#include<iostream>
using namespace std;
#define PI 3.14
//class 代表设计一个类，类后面紧跟的就是类的名称
class Circle
{//访问权限//公共权限
public://属性//半径int m_r;//行为//获取圆的周长double calculateZC(){return 2 * PI * m_r;}
};int main()
{Circle cl;//通过圆类  创建具体的圆（对象）cl.m_r = 10;//给圆对象 的属性进行赋值cout << "圆的周长为：" << cl.calculateZC() << endl;//2*PI*10=62.8return 0;
}

示例二：设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生和学号

#include<iostream>
using namespace std;
#include<string>
//class 代表设计一个类，类后面紧跟的就是类的名称
class Student
{//访问权限//公共权限
public://类中的属性和行为 我们统称为 成员//属性  成员属性  成员变量//行为  成员函数  成员方法//半径string m_name;//姓名string m_id;//学号//行为//显示姓名和学号void showStudent(){cout << "姓名：" << m_name<<"\t" << "学号:" << m_id << endl;}void setname(string name){m_name = name;}void set_id(string id){m_id = id;}
};int main()
{Student s1;//通过类  创建具体的学生（对象）实例化对象s1.m_name = "张三";s1.m_id = "111111";//给学生对象 的属性进行赋值s1.showStudent();Student s2;//s2.m_id = "222222";//s2.m_name = "李四";s2.setname("“李四");s2.set_id("222222");s2.showStudent();return 0;
}

1.1.2  封装意义二： 

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

访问权限有三种：

1，public  公共权限

2，protected  保护权限

3，private  私有权限

//类的三种权限
//1，public  公共权限  类内可以访问  类外可以访问//2，protected  保护权限  类内可以访问  类外不可以访问  儿子可以访问父亲的保护内容//3，private  私有权限   类内可以访问  类外不可以访问  儿子不能访问父亲的私有内容#include<iostream>
using namespace std;
#include<string>
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 p1;p1.m_Name = "李四";//p1.m_Car="奔驰"//保护权限内容，在类外访问不到//p1.m_Password = 123;//私有权限内容，在类外访问不到system("pause");return 0;
}

1.2  struct和class区别

在c++中，struct和class唯一的区别在于：

默认的访问权限不同

区别：struct默认权限为公共

            class默认权限为私有

#include<iostream>
using namespace std;
#include<string>
//struct默认权限为公共
//class默认权限为私有
class C1
{int m_A;//默认权限为私有
};struct C2
{int m_A;//默认权限为公共
};int main()
{C1 c1;//c1.m_A = 10;//错误，访问权限是私有的C2 c2;c2.m_A = 10;//正确，访问权限是公共system("pause");return 0;
}

1.3 成员属性设置为私有

1.3.1 介绍

优点1：将所有的成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

示例：

//优点1：将所有的成员属性设置为私有，可以自己控制读写权限//优点2：对于写权限，我们可以检测数据的有效性#include<iostream>
using namespace std;//人类
class Person
{
public://设置名字void setName(string name){m_Name = name;}//获取姓名string getName(){return m_Name;}//获取年龄void setAge(int age){if (age < 0 || age>150){cout << "年龄输入有误，请重新输入" << endl;}m_Age = age;}int getAge(){return m_Age;}void setIdol(string Idol){m_Idol= Idol;}private://姓名  可读可写string m_Name;//年龄  只读  也可以写年龄int m_Age=18;//偶像  只写string m_Idol;
};int main()
{Person p;//设置姓名p.setName("张三");//获取姓名cout << "姓名：" << p.getName() << endl;//年龄设置//p.setAge(20);//p.m_Name = 20;//获取年龄p.setAge(160);cout << "年龄：" << p.getAge() << endl;//偶像设置p.setIdol("小明");//cout << "偶像是：" << p.getIdol() << endl;//外界访问不到system("pause");return 0;
}

 1.3.2  案例1：设计立方体类

题目：设计立方体类

求立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等

代码展示：

#include<iostream>
using namespace std;//立方体类的设计
//1，创建立方体类
//2，设计属性
//3，设计行为  获取立方体的面积和体积
//4，分别利用全局函数和成员函数  判断两个立方体是否相同class Cube//立方体类
{
public://设置长void setlong(int l){m_L = l;}//获取长int getlong(){return m_L;}//设置宽void setWidth(int w){m_W = w;}//获取宽int getWidth(){return m_W;}//设置高void setHigh(int h){m_H = h;}//获取高int getHigh(){return m_H;}//获取立方体//获取立方体面积int calculateS(){return 2 * m_L * m_W + 2 * m_L * m_H + 2 * m_W * m_H;}//获取立方体体积int calculateV(){return m_L *m_H * m_W;}//利用成员函数判断两个立方体是否相等bool isSameByClass(Cube &c){if (m_L == c.getlong() && m_W == c.getWidth() && m_H == c.getHigh()){return true;}return false;}
private:int m_L;//长int m_W;//宽int m_H;//高};//利用全局函数判断，两个立方体是否相同
bool isSame(Cube& c1, Cube& c2)
{if (c1.getlong() == c2.getlong() || c1.getWidth() == c2.getWidth() || c1.getHigh() == c2.getHigh()){return true;}return false;
}int main()
{//创建立方体对象Cube c1;c1.setlong(10);c1.setWidth(10);c1.setHigh(10);//600cout << "c1的面积为：" << c1.calculateS() << endl;//1000cout << "c1的体积为：" << c1.calculateV() << endl;//创建第二个立方体Cube c2;c2.setlong(10);c2.setWidth(10);c2.setHigh(10);bool ret = isSame(c1, c2);if (ret){cout << "c1和c2是相等的" << endl;}else{cout << "c1和c2是相等的" << endl;}ret = c1.isSameByClass(c2);if (ret){cout << "成员函数判断：c1和c2是相等的" << endl;}else{cout << "成员函数判断：c1和c2是不相等的" << endl;}system("pause");return 0;
}

1.3.3   案例2：设计圆

设计一个圆类（Circle），和一个点类（Point），计算点和圆的关系

#include<iostream>
using namespace std;class Point
{
public://设置xvoid setX(int x){m_X = x;}//获取xint getX(){return m_X;}//设置yvoid setY(int y){m_Y = y;}//获取yint getY(){return m_Y;}
private:int m_X;int m_Y;
};class Circle
{
public://设置半径void setR(int r){m_R = r;}//获取半径int getR(){return m_R;}//设置圆心void setCenter(Point center){m_Center=center;}//获取圆心Point getCenter(){return m_Center;}
private:int m_R;Point m_Center;
};//判断点和圆的关系
void isInCircle(Circle& c, Point& p)
{//计算两点之间的距离的平方int distance =(c.getCenter().getX() - p.getX()) * (c.getCenter().getX() - p.getX()) +(c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());//计算半径的平方int rDistance = c.getR() * c.getR();//判断关系if (distance == rDistance){cout << "点在圆上" << endl;}else if(distance>rDistance){cout << "点在圆外" << endl;}else{cout << "点在圆内" << endl;}
}int main()
{//创建圆Circle c;c.setR(10);Point center;center.setX(10);center.setY(0);c.setCenter(center);//创建点Point p;p.setX(10);p.setY(10);//判断关系isInCircle(c, p);system("pause");return 0;
}

2，对象的初始化和清理

C++中的面向对象源于生活，每个对象也都会有出厂设置，以及对象的销毁前的清理数据的设置

2.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题
   一个对象或者变量没有初始状态，对其使用后果是未知的
   同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

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

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

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

构造函数语法：类名（）{}

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

2，函数名称与类名相同

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

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

析构函数：~类名（）{}

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

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

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

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

构造函数代码示例：

#include<iostream>
using namespace std;//对象的初始化和清理
//1，构造函数  进行初始化操作class Person
{//1，构造函数，没有返回值也不写void//2，函数名称与类名相同//3，构造函数可以有参数，因此可以发生重载//4，程序在调用对象的时候会自动调用构造，无须手动调用，而且只会调用一次
public:Person(){cout << "Person 构造函数的调用" << endl;}
};void test01()
{Person p;
}int main()
{test01();system("pause");return 0;
}

 析构函数示例：

#include<iostream>
using namespace std;class Person
{//析构函数  进行清理的操作//1，构造函数，没有返回值也不写void//2，函数名称与类名相同，前面加~//3，构造函数不可以有参数，因此不可以发生重载//4，对象在销毁前 会自动调用构造，无须手动调用，而且只会调用一次
public:~Person(){cout << "Person 构造函数的调用" << endl;}
};void test01()
{Person p;
}int main()
{test01();system("pause");return 0;
}

2.2   构造函数的分类及调用

两种分类方式：

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

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

三种调用方法：

     1， 括号法

示例：

#include<iostream>
using namespace std;
//构造函数分类
//按照参数分类分为  有参和无参构造  无参又称为默认构造
//按照类型分类分为   普通构造和拷贝构造class Person
{
public://构造函数//无参构造（默认构造）Person(){cout << "Person 的无参构造函数调用" << endl;}//有参构造Person(int a){cout << "Person 的有参构造函数调用" << endl;}//拷贝构造函数Person(const Person& p){//将传入的人身上的所有属性，拷贝到我身上cout << "Person 的拷贝构造函数调用" << endl;age = p.age;}//析构函数~Person(){cout << "Person 的析构函数调用" << endl;}int age=18;
};//调用
void test01()
{//1,括号法Person p1;//默认构造函数的调用Person p2(10);//有参构造函数Person p3(p2);//拷贝构造函数//注意事项：//调用默认构造函数时候，不要加（）Person p1();//编译器会认为这行代码是一个函数声明cout << "p2的年龄为：" << p2.age << endl;cout << "p2的年龄为：" << p3.age << endl;
}int main()
{test01();system("pause");return 0;}

 

    2，  显示法

#include<iostream>
using namespace std;
//构造函数分类
//按照参数分类分为  有参和无参构造  无参又称为默认构造
//按照类型分类分为   普通构造和拷贝构造class Person
{
public://构造函数//无参构造（默认构造）Person(){cout << "Person 的无参构造函数调用" << endl;}//有参构造Person(int a){cout << "Person 的有参构造函数调用" << endl;}//拷贝构造函数Person(const Person& p){//将传入的人身上的所有属性，拷贝到我身上cout << "Person 的拷贝构造函数调用" << endl;age = p.age;}//析构函数~Person(){cout << "Person 的析构函数调用" << endl;}int age = 18;
};//调用
void test01()
{//2，显示法Person p1;Person p2 = Person(10);//有参构造Person p3 = Person(p2);//拷贝构造cout << endl;Person(10);//匿名对象  特点：当前行执行结束后，系统会立即回收掉匿名对象cout << "aaaaaa" << endl;cout << endl;//注意事项2：//不要利用拷贝构造函数  初始化匿名对象  编译器会认为Person(p3)==Person p3;//Person(p3);
}int main()
{test01();system("pause");return 0;}

 

    3， 隐式转换法

#include<iostream>
using namespace std;
//构造函数分类
//按照参数分类分为  有参和无参构造  无参又称为默认构造
//按照类型分类分为   普通构造和拷贝构造class Person
{
public://构造函数//无参构造（默认构造）Person(){cout << "Person 的无参构造函数调用" << endl;}//有参构造Person(int a){cout << "Person 的有参构造函数调用" << endl;}//拷贝构造函数Person(const Person& p){//将传入的人身上的所有属性，拷贝到我身上cout << "Person 的拷贝构造函数调用" << endl;age = p.age;}//析构函数~Person(){cout << "Person 的析构函数调用" << endl;}int age = 18;
};//调用
void test01()
{//隐式转换法Person p4 = 10;//相当于写了 Person p4=Person(10);Person p5 = p4;//拷贝构造//注意：不能利用拷贝构造函数 初始化匿名对象  编译器认为是对象声明//Person p5(p4)
}int main()
{test01();system("pause");return 0;}

 

2.3  拷贝构造函数调用时机

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

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

示例：

#include<iostream>
using namespace std;
class Person
{
public:Person(){cout << "person默认构造函数调用" << endl;}Person(int age){m_Age = age;}Person(const Person& p){cout << "person有参构造函数调用" << endl;m_Age = p.m_Age;}~Person(){cout << "Person 析构函数的调用" << endl;}int m_Age;  
};
//1,使用一个已经创建完毕的对象来初始化一个新对象
void test02()
{Person p1(20);Person p2(p1);cout << "p2的年龄为：" << p2.m_Age << endl;
}
int main()
{test02();//test03();//test04();system("pause");return 0;
}

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

示例：

#include<iostream>
using namespace std;
class Person
{
public:Person(){cout << "person默认构造函数调用" << endl;}Person(int age){m_Age = age;}Person(const Person& p){cout << "person有参构造函数调用" << endl;m_Age = p.m_Age;}~Person(){cout << "Person 析构函数的调用" << endl;}int m_Age;
};
//2，值传递的方式给函数参数传值
void doWork(Person p)
{}void test03()
{Person p;doWork(p);
}
int main()
{test03();//test04();system("pause");return 0;
}

 

  3， 以值方式返回局部对象

示例：

 

#include<iostream>
using namespace std;
class Person
{
public:Person(){cout << "person默认构造函数调用" << endl;}Person(int age){m_Age = age;}Person(const Person& p){cout << "person有参构造函数调用" << endl;m_Age = p.m_Age;}~Person(){cout << "Person 析构函数的调用" << endl;}int m_Age;
};
//3，值方式返回局部对象
Person doWork2(Person p)
{Person p1;return p1;
}
void test04()
{Person p;doWork2(p);
}
int main()
{test04();system("pause");return 0;
}

2.4 构造函数的调用规则

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

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

2，默认析构函数（无参，函数体为空）

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

构造函数调用规则如下:
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造。

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

示例：

#include<iostream>
using namespace std;
class Person
{
public:Person(){cout << "person默认构造函数调用" << endl;}Person(int age){m_Age = age;cout << "person有参构造函数调用" << endl;}Person(const Person& p){cout << "person拷贝函数调用" << endl;m_Age = p.m_Age;}~Person(){cout << "Person 析构函数的调用" << endl;}int m_Age;
};void test01()
{Person p;p.m_Age = 18;Person p2(p);cout << "p2的年龄为：" << p2.m_Age <<endl;
}int main()
{test01();return 0;
}

2.5 深拷贝和浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑
浅拷贝:简单的赋值拷贝操作
深拷贝:在堆区重新电请空间，进行拷贝操作

#include<iostream>
using namespace std;
class Person
{
public:Person(){cout << "person默认构造函数调用" << endl;}Person(int age,int height){m_Age = age;m_Height = new int(height);cout << "person有参构造函数调用" << endl;}Person(const Person& p){cout << "person拷贝函数调用" << endl;m_Age = p.m_Age;}~Person(){if (m_Height != NULL){delete m_Height;m_Height = NULL;}cout << "Person 析构函数的调用" << endl;}int m_Age;int *m_Height;
};
void test01()
{Person p1(18,160);cout << "p1的年龄为：" << p1.m_Age <<"p1的年龄为："<<p1.m_Height << endl;Person p2(p1);cout << "p2的年龄为：" << p2.m_Age << "p2的年龄为：" << p2.m_Height << endl;}
int main()
{test01();return 0;
}

以上代码会发生错误，原因如下图解释：

 

 

#include<iostream>
using namespace std;
class Person
{
public:Person(){cout << "person默认构造函数调用" << endl;}Person(int age,int height){m_Age = age;m_Height = new int(height);cout << "person有参构造函数调用" << endl;}Person(const Person& p){cout << "person拷贝函数调用" << endl;//如果不利于深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题m_Age = p.m_Age;m_Height = new int(*p.m_Height);}~Person(){cout << "Person 析构函数的调用" << endl;if (m_Height != NULL){delete m_Height;}}
public:int m_Age;int* m_Height;
};void test01()
{Person p1(18,160);cout << "p1的年龄为：" << p1.m_Age <<"p1的年龄为："<<*p1.m_Height << endl;Person p2(p1);cout << "p2的年龄为：" << p2.m_Age << "p2的年龄为：" << *p2.m_Height << endl;}int main()
{test01();return 0;
}

 

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

2.6 初始化列表

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

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

示例：

传统初始化操作：

#include<iostream>
using namespace std;class Person
{
public://传统初始化操作Person(int a, int b, int c){m_A = a;m_B = b;m_C = c;}int m_A;int m_B;int m_C;
};void test()
{Person p(10, 20, 30);cout << "m_A= " << p.m_A << endl;cout << "m_B= " << p.m_B << endl;cout << "m_C= " << p.m_C << endl;
}int main()
{test();system("pause");return 0;}

初始化列表初始化属性： 

#include<iostream>
using namespace std;class Person
{
public://初始化列表Person(int a,int b,int c) :m_A(a), m_B(b), m_C(c){}int m_A;int m_B;int m_C;
};void test()
{Person p(10, 20, 30);cout << "m_A= " << p.m_A << endl;cout << "m_B= " << p.m_B << endl;cout << "m_C= " << p.m_C << endl;
}int main()
{test();system("pause");return 0;}

 

2.7 类对象作为类成员

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

例如：

class A {}

class B

{

   A   a;

}

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

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

#include<iostream>
using namespace std;
//类对象作为类成员//手机类
class Phone
{
public:Phone(){cout << "Phone 的无参构造函数调用" << endl;}//有参构造Phone(int a){cout << "Phone 的有参构造函数调用" << endl;}~Phone(){cout << "Person 析构函数的调用" << endl;}Phone(string pName){m_pName = pName;}string m_pName;
};class Person
{
public://Phone m_Phone = pName  隐式转换法Person(string name,string pName):m_Name(name),m_Phone(pName){cout << "Person 的构造函数调用" << endl;}//姓名string m_Name;//手机Phone m_Phone;
};//当其他类对象作为本类成员，构造时候先构造类对象，再构造自身，析构的顺序与构造的顺序相反
void test()
{Person p("张三", "苹果MAX");cout << p.m_Name << "拿着" << p.m_Phone.m_pName << endl;
}int main()
{test();system("pause");return 0;
}

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

示例一：静态成员变量

#include<iostream>
using namespace std;
class Person
{public://所有对象共享同一份数据//在编译阶段分配内存//类内声明，类外初始化static int m_A;
};int Person::m_A = 100;void test()
{Person p;cout << p.m_A << endl;
}int main()
{test();system("pause");return 0;
}

示例二：

#include<iostream>
using namespace std;
class Person//静态成员变量
{public://所有对象共享同一份数据//在编译阶段分配内存//类内声明，类外初始化static int m_A;int m_C;//静态成员变量static void func(){m_A = 100;//静态成员函数可以访问静态成员变量  //m_C = 200;//静态成员函数 不可以访问  非静态成员变量，因为无法区分是哪个对象的变量cout << "static void func调用" << endl;}private://静态成员变量也是有访问权限static int m_B;};int Person::m_A = 100;
int Person::m_B = 200;void test01()
{Person p;cout << p.m_A << endl;Person p2;p2.m_A = 200;cout << p2.m_A << endl;}void test02()
{//静态成员变量 不属于某个对象上，所有对象都共享同一份数据//因此静态成员变量有两种访问方式//1，通过对象进行访问// Person p;//cout<< p.m_A << endl;//2,通过类名进行访问cout << Person::m_A << endl;//cout << Person::m_B << endl;//类外访问不到私有静态属性成员变量
}
int main()
{test01();system("pause");return 0;
}