网站建设后期修改,鹤山市住房和城乡建设局网站,网站建设奕网情深,中国旅游网官网首页1#xff0c;封装
1.1 封装的引用
封装是C面向对象三大特性之一
封装的意义#xff1a; 将属性和行为作为一个整体#xff0c;表现生活中的事物 将属性和行为加以权限控制
1.1.1 封装意义一#xff1a;
在设计类的时候#xff0c;属性和行为写在一起#xff0c;表…1封装
1.1 封装的引用
封装是C面向对象三大特性之一
封装的意义 将属性和行为作为一个整体表现生活中的事物 将属性和行为加以权限控制
1.1.1 封装意义一
在设计类的时候属性和行为写在一起表现事物
语法class 类名 { 访问权限 属性/行为 }
示例一
设计一个圆类求圆的周长
#includeiostream
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*1062.8return 0;
} 示例二设计一个学生类属性有姓名和学号可以给姓名和学号赋值可以显示学生和学号
#includeiostream
using namespace std;
#includestring
//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 封装意义二
类在设计时可以把行为和属性放在不同的权限下加以控制
访问权限有三种
1public 公共权限
2protected 保护权限
3private 私有权限
//类的三种权限
//1public 公共权限 类内可以访问 类外可以访问//2protected 保护权限 类内可以访问 类外不可以访问 儿子可以访问父亲的保护内容//3private 私有权限 类内可以访问 类外不可以访问 儿子不能访问父亲的私有内容#includeiostream
using namespace std;
#includestring
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默认权限为私有
#includeiostream
using namespace std;
#includestring
//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对于写权限我们可以检测数据的有效性#includeiostream
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 || age150){cout 年龄输入有误请重新输入 endl;}m_Age age;}int getAge(){return m_Age;}void setIdol(string Idol){m_Idol Idol;}private://姓名 可读可写string m_Name;//年龄 只读 也可以写年龄int m_Age18;//偶像 只写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设计立方体类
题目设计立方体类
求立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等 代码展示
#includeiostream
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计算点和圆的关系 #includeiostream
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_Centercenter;}//获取圆心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(distancerDistance){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程序在对象销毁前会自动调节析构无须手动调用而且只会调用一次 构造函数代码示例
#includeiostream
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;
} 析构函数示例
#includeiostream
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 括号法
示例
#includeiostream
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 age18;
};//调用
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 显示法
#includeiostream
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 隐式转换法
#includeiostream
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 p4Person(10);Person p5 p4;//拷贝构造//注意不能利用拷贝构造函数 初始化匿名对象 编译器认为是对象声明//Person p5(p4)
}int main()
{test01();system(pause);return 0;} 2.3 拷贝构造函数调用时机
C中拷贝构造函数调用时机通常由三种情况 使用一个已经创建完毕的对象来初始化一个新对象
示例
#includeiostream
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;
} 值传递的方式给函数参数传值
示例
#includeiostream
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 以值方式返回局部对象
示例 #includeiostream
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不会再提供其他构造函数
示例
#includeiostream
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 深拷贝和浅拷贝
深浅拷贝是面试经典问题也是常见的一个坑 浅拷贝:简单的赋值拷贝操作 深拷贝:在堆区重新电请空间进行拷贝操作
#includeiostream
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;
}
以上代码会发生错误原因如下图解释 #includeiostream
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...{}
示例
传统初始化操作
#includeiostream
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;} 初始化列表初始化属性
#includeiostream
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的构造和析构的顺序是谁先谁后
#includeiostream
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;
} 函数只能访问静态成员变量
示例一静态成员变量
#includeiostream
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;
} 示例二
#includeiostream
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;
}
