面向对象的编程：
1、自己创建类
2、自己创建对象
class student
{
srting name;
int age;
}
class student
{
public://外部可读写
srting name;
private://外部看不到 外部不可读写
int age;
}
student Jane;//创建一个 student 类的对象 名字将Jane Jane.name = “xiaohua”;//赋值
不同的函数可以使用一样的名字，但是形成不同
class student
{
public:
srting name;
int age;
bool set (int a);
bool set (srting a);//两函数形参不同
}
//成员函数的定义：
bool set （srting a）
{
name = a;
return true；
}
bool set （int a）
{
age = a;
return true；
}
class student
{
public:
srting name;
int age;
student();//这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
}
student：：student()//构造函数定义，冒号两边一样，没有输入值
{
age = 20;//构造函数里面，可以对全部的成员变量一个默认值
name = "xiaohua";
}
以后我再主函数定义新的变量时，变量就会有一个默认值，就是构造函数里面定义的
class student
{
public:
srting name;
int age;
student();//这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
student(int a, string b);//带参数的构造函数，还是保存和类一样的名字，根据不同的参数进行区别
}
student::student()//构造函数定义，冒号两边一样，没有输入值
{
age = 20;//构造函数里面，可以对全部的成员变量一个默认值
name = "xiaohua";
}
student::student(int a, string b)//构造函数定义，冒号两边一样
{
age = a;//构造函数里面，将输入的值赋值给对象
name = b;
}
int main()
{
student aa;//没有带参数的构造函数默认赋值
student bb(23,"小白");//在定义对象时赋值
return 0;
}
student *p = new student(88,"愚公");//创建一个指针p,指向一个新的对象
delete p;//删除指针
//析构函数,执行删除指针时会调用
student :: ~student ()
{
cout<<"delete object";
}
class student
{
public:
srting name;
int age;
bool set (int i);//普通成员函数声明，又叫方法
bool read() const;//后面加const，表示这个函数只读不写
}
bool student :: read() const//后面加const，表示这个函数只读不写
{
cout<<name;//打印姓名
cout<<age;//打印年龄
return true;
}
int main()
{
student aa;//创建对象
aa.read();//在创建对象后，调用read方法
return 0;
}
//实现上可以不使用const,普通方法也可以读数据，加const只是为了安全起见，防止意外修改数据。
//更加不正规的做法就是直接读取：aa.age,在正规的程序当中还是会使用const来读取。
class student
{
public:
srting name;
int age;
student();//这就是构造函数，没有形参，没有返回值，并且名字和类的名字一致
static int cnt://static 表示静态成员数据，统计有多少个对象
static int count()://static 表示静态成员函数，返回有多少个对象
}
student::student()//构造函数定义，冒号两边一样，没有输入值
{
age = 20;//构造函数里面，可以对全部的成员变量一个默认值
name = "xiaohua";
cnt = cnt + 1;
}
int student ::count()
{
return cnt;//返回静态成员数据，统计有多少个对象
}
int main()
{
student aa;//创建对象
student bb;//创建对象
aa.count();//bb.count();//student ::count();不依赖对象的静态函数
return 0;
}
class student
{
public:
bool set (int i);//普通成员函数声明，又叫方法
bool read() const;//后面加const，表示这个函数只读不写
private:
srting name;
int age;
}
class student
{
public:
bool set (int i);//普通成员函数声明，又叫方法
bool read() const;//后面加const，表示这个函数只读不写
private:
srting name;
int age;
}
class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
public:
srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
}
class postgraduste : public student //研究生类定义，冒号后面表示从student 类公有派生而来
{
public:
srting research;//这个行新增定义一个公开的字符串属性 research，比如研究生的研究方向：芯片设计
}
int main()
{
undergraduate aa;//创建本科生对象
postgraduste bb;//创建研究生对象
aa.set(33);//子类可以调用父类的方法
return 0;
}
> class undergraduate : private student//私有继承，继承所得的public下的内容变为private 下的，不继承private 下的内容
> class undergraduate : protect student//保护继承，继承所得的public下的内容和protect 下的内容都为protect 下的内容
class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
public:
srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
undergraduate();//
undergraduate(int a,string b,string c);//
}
undergraduate :: undergraduate()
{
course = "math"
}
//带参数的构造函数
undergraduate :: undergraduate(int a,string b,string c):st`在这里插入代码片`udent (a,b)
{
course = c;
}
int main()
{
undergraduate aa;//创建本科生对象
postgraduste bb(22,"xiaohua","math");//创建对象，并且赋初值
aa.set(33);//子类可以调用父类的方法
return 0;
}
class student
{
public:
bool set (int i);//普通成员函数声明，又叫方法
bool read() const;//后面加const，表示这个函数只读不写
void study(bool a);
private:
srting name;
int age;
}
void student :: study(bool a)
{
cout<<"好好睡觉"
}
class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
public:
srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
void study(bool a);
}
void undergraduate :: study(int a)
{
cout<<"好好吃饭"
}
int main()
{
student aa;//创建父对象
postgraduste bb;//创建子对象
bb。study(2);//打印好好吃饭
aa.study(ture);//打印好好睡觉
bb。study(ture);//报错,父类方法被隐藏了
return 0;
}
指针
虚函数（virtual）
class student
{
public:
bool set (int i);//普通成员函数声明，又叫方法
bool read() const;//后面加const，表示这个函数只读不写
virtual void study();
private:
srting name;
int age;
}
void student :: study()
{
cout<<"好好学习"
}
class undergraduate : public student //本科生类定义，冒号后面表示从student 类公有派生而来
{
public:
srting course;//这个行新增定义一个公开的字符串属性 course，比如本科生的课程大学物理
virtual void study();
}
void undergraduate :: study()
{
cout<<"好好吃饭"
}
class postgraduste : public student //研究生类定义，冒号后面表示从student 类公有派生而来
{
public:
srting research;//这个行新增定义一个公开的字符串属性 research，比如研究生的研究方向：芯片设计
virtual void study();
}
void postgraduste :: study()
{
cout<<"开开心心"
}
int main()
{
student aa;//创建父对象
postgraduste bb;//创建子对象
undergraduate cc;//创建子对象
student *p;
p = &aa,
p->study();//打印好好学习
p = &bb,
p->study();//打印开开心心
p = &cc,
p->study();//打印好好吃饭
return 0;
}
class student
{
public:
student ();//抽象类也有构造函数
student (int a,string b);//构造函数重载
virtual void study() =0;//声明方法，前面有virtual还有=0,表示纯虚函数,只有声明没有定义
}
int main()
{
student aa;// 报错 不允许创建对象
postgraduste bb;//创建子对象
undergraduate cc;//创建子对象
student *p;
p = &bb,
p->study();//打印开开心心
p = &cc,
p->study();//打印好好吃饭
return 0;
}
#include