类
类是将属性和行为作为个整体，并加以权限控制，与结构体区别是，类可以实现成员私有化
封装
封装的意义是将属性和行为作为个整体，并加以权限控制
在设计类时，将属性和行为写到一起
#include<iostream>
using namespace std;
const double PI = 3.14;
class Circle
{
//访问权限
//公共权限
public:
//属性
//半径
int m_r;
//行为
//获取圆的周长
double calculateZC()
{
return 2 * PI * m_r;
}
};
int main(){
//对圆类创建对象
Circle c1;
//赋值
c1.m_r = 10;
cout<<"圆的周长为: "<<c1.calculateZC()<<end1;
system("pause");
return 0;
}
我们再看看私有化
其中：
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 func1()
{
m_Name = "张三";
m_Car = "拖拉机";
m_Password = 123456;
}
protected:
void func2()
{
m_Name = "李四";
m_Car = "出租车";
m_Password = 123;
}
private:
void func3()
{
m_Name = "王五";
m_Car = "卡车";
m_Password = 456;
}
};
int main(){
//实例化
p1.m_Name = "李四";
p1.m_Car = "奔驰"; //保护内容类外无法访问
p1.m_Password = 123; //私有内容类外无法访问
p1.func1();
p1.func2(); //保护内容无法访问
p1.func3(); //私有内容无法访问
system("pause");
return 0;
}
类的成员私有化可以自己控制读写权限
#include<iostream>
using namespace std;
#include<string>
class Person
{
public:
//设置姓名
void setName(string name)
{
m_Name = name;
}
//获取姓名
string getName()
{
return m_Name;
}
int getAge()
{
m_Age = 0;
return m_Age;
}
void setLover(string lover)
{
m_Lover = lover;
}
private:
string m_Name;
int m_Age;
string m_Lover;
};
int main(){
Person p;
p.setName("张三");
//这里setName()函数是位于类内的，对于私有成员可以进行访问
cout<<"姓名为: "<<p.getName()<<end1;
//可读可写
cout<<"年龄为: "<<p.getAge()<<end1;
//输出0，只读
cout<<"年龄为: "<<p.getAge()<<end1;
p.setLover("xxx");
//只写
system("pause");
return 0;
}
初始化类
对类的值初始化，这样类就比较灵活
#include<iostream>
using namespace std;
#include<string>
class Person
{
public:
//初始化
int m_A;
int m_B;
int m_C;
Person(int a,int b,int c):m_A(a),m_B(b),m_C(c)
{
}
//构造函数名与类名一致
{
m_A = a;
m_B = b;
m_C = c;
}
};
void test01()
{
Person p;
cout<<"m_A= "<<p.m_A<<end1;
cout<<"m_B= "<<p.m_B<<end1;
cout<<"m_C= "<<p.m_C<<end1;
}
int main(){
test01();
system("pause");
return 0;
}
继承
继承公共部分从而减少代码的重复
#include<iostream>
using namespace std;
//公共部分
class BasePage
{
public:
void header()
{
cout<<"首页，公开课，登录，注册.....(公共头部)"<<end1;
}
void footer()
{
cout<<"帮助中心，交流合作，站内地图.....(公共底部)"<<end1;
}
void left()
{
cout<<"Java,Python,C++.....(公共分类列表)"<<end1;
}
};
//Java页面
class Java: public BasePage
{
public:
void content()
{
cout<<"Java学科视频"<<end1;
}
};
//Python页面
class Python: public BasePage
{
public:
void content()
{
cout<<"Python学科视频"<<end1;
}
};
//C++页面
class Cpp: public BasePage
{
public:
void content()
{
cout<<"Cpp学科视频"<<end1;
}
};
void test01()
{
//Java页面
cout<<"Java下载视频页面如下: "<<end1;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout<<"............"<<end1;
//Python页面
cout<<"Python下载视频页面如下: "<<end1;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout<<"............"<<end1;
//C++页面
cout<<"Cpp下载视频页面如下: "<<end1;
Cpp cp;
cp.header();
cp.footer();
cp.left();
cp.content();
cout<<"............"<<end1;
}
int main() {
test01();
system("pause");
return 0;
}
多态
也就是在继承的基础上重写父类函数
#include<iostream>
using namespace std;
class Animal
{
public:
virtual void speak() //重写的虚函数
{
cout<<"动物在说话"<<end1;
}
};
//继承时，重写函数同函数名
class Cat: public Animal
{
public:
void speak()
{
cout<<"小猫在说话"<<end1;
}
};
class Dog: public Animal
{
public:
void speak()
{
cout<<"小猫在说话"<<end1;
}
};
//执行说话函数
void doSpeak(Animal &animal) //地址传值
{
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat); //执行Cat类里面的speak函数
Dog dog;
doSpeak(dog); //执行Dog类里面的speak函数
}
int main() {
test01();
system("pause");
return 0;
}
多态的两个特点，一是有继承，而是对父类函数进行改写
this指针
this指针指向被调用的成员函数对象
#include<iostream>
using namespace std;
class Person
{
public:
Person(int age)//构造函数
{
//this指针指向被调用成员函数
this->age = age;
}
Person& PersonAddAge(Person &p) //这里&作为引用函数
{
this->age + = p.age;
return *this;
}
int age;
};
void test01()
{
Person p1(18);
cout<<"p1的年龄为: "<<p1.age<<end1;
}
void tst02()
{
Person p1(10);
Person p2(10); //此时，this指针重新指向p2
p2.PersonAddAge(p1).p2.PersonAddAge(p1).p2.PersonAddAge(p1);
}
int main(){
test01();
system("pause");
return 0;
}
