c++简略笔记

什么是类，什么是对象

class student{
string name;
int age;
}

student aa; //创建一个student类对象
aa.age=20;

**成员函数的重载：**不同函数的函数名可以相同，通过不同的输入参数来识别它们

class student{
public:
string name;
int age;
bool set(int a);
bool set(string a);
}

aa.set(10); 给age赋值10
aa.set(“张三”); 给name赋值”张三”

**构造函数 ：**本质即对象初始化

构造函数的名字必须和类的名字一样

class student{
public:
string name;
int age;
student();
student(int a , string b);
}

student::student(int a, string b){
age = a;
name = b;
}

student aa; 调用无参数的构造函数
student bb (10, “张三”);

析构函数： 释放对象所占用的内存

这里插入一个高级的创建对象并删除对象的方法：
student *p = new student(10, “张三”);
delete p;

构造函数的写法：
student:: ~ student
{cout<<”delete object”}

常成员函数 const : 只读不写

class student{
public:
string name;
int age;
bool set(int a);
bool read() const; 后面加了const，表示只读不写
}

bool student::read() const{
cout<<name;
cout<<age;
return true;
}

student aa;
aa.read;

静态成员static 与对象无关的数据，调用静态成员数据的方法叫静态成员函数

class student{
public:
string name;
int age;
student();
static int cnt;
static int count();
};

student:: student(){
age=20;
name=”张三”;
cnt=cnt+1;
}

int student::count(){
return cnt;
}

student aa;
student bb;
aa.count(); 由于count()和对象没关系，所以aa.count()和bb.count()都返回2，因为创建了两个对象
bb.count();
student::count(); 和aa.count()的效果一样

public和private 只能通过共有的方法调用私有的方法

class student{
public:
void printf_age_public();
private:
void printf_age_private();
}

void student:: printf_age_public()
{ printf_age_private();}

void student:: printf_age_private()
{cout<<20;}

student aa;
aa. printf_age_public()； 通过公有函数调用私有函数
aa. printf_age_private(); 这里出错，不允许直接调用私有方法

正规程序类的定义 “属性”放在private里，“方法”放在public中

class student{
public:
bool set(int a);
bool set(string b);
bool read() const;
student();
student(int a, string b);
private:
int age;
string name;
}

类的派生继承

sudent类派生出undergraduate类:

class undergraduate: public student
{
public:
string course;
}

子类自动继承父类的属性和方法，包括构造函数和析构函数

undergraduate bb; bb对象已经有age和name的初值，从父类student继承来的
bb.set(25);

不同类别的继承

公有继承：
父类student, public内容A，private内容B, 子类公有继承，则只有内容A，且在public
父类student, public内容A，protect内容B, 子类公有继承，则子类有public内容A和protect内容B

私有继承：
父类student, public内容A，private内容B，子类私有继承，则子类只有内容A，且为private

保护继承
父类student, public内容A，protect内容B, 子类保护继承，则子类有内容A和B，且都为protect

子类的构造函数
不管子类有没有构造函数，创建子类对象时，父类构造函数都将被调用。

class undergraduate: public student
{
public:
string course;
undergraduate();
undergraduate(int a, string b, string c);
}

undergraduate::undergraduate()
{
course = “physics”;
}

undergraduate::undergraduate(int a, string b, string c): student(a,b)
{
course = c;
}

undergraduate bb; 父类和子类无参数构造函数都将被调用

undergraduate bb(20, “张三”, “physics”);

多态 不同类的对象可以运用相同的方法，“相同”指的是方法名字相同，但内容不相同

c++实现多态的方法：重载、隐藏、覆盖

重载：重载两个函数的参数格式必须是不一样的，隐藏和覆盖可以

隐藏：
class student{
public:
void study(bool a){cout<<”好好学习”};
}

class undergraduate: public student{
public:
void study(int a){cout<<”好好学习”};
}

student aa;
undergraduate bb;
aa.study(true);
bb.study(5);
bb.study(true); 出错，父类方法被隐藏了，系统找不到对应的方法

类指针 不考虑继承，和结构体指针相同

student *p;
student aa;
p = &aa;
p -> name; 和aa.name一样
p ->age; 和aa.age一样
p ->study(); 和aa.study()一样

更高级的写法：
student *p = student(20, “张三”);
delete p;

父类指针可以指向子类对象，但不能调用子类的属性和方法

student *p1;
undergraduate *p2;
student aa;
undergraduate bb;
p1 = &aa;
p2 = &bb;
p1 = &bb;
p2 = &aa; 这里出错，子类指针不能指向父类对象

真正的多态与虚函数

class student{
public:
virtual void study();
}

void student::study()
{cout<<”好好学习”}

class postgraduate: public student{
public:
virtual void study();
}

void postgraduate::study()
{cout<<”芯片设计”;}

class undergraduate:public student{
public:
virtual void study();
}

void undergraduate::study()
{cout<<”大学物理”;}

student aa;
postgraduate bb;
undergraduate cc;
student *p;
p = &aa;
p ->study();
p = &bb;
p ->study();
p = &cc;
p ->study();

c++多态的核心：在开始时设置一个父类指针，之后指针可以动态地指向不同的类，并调用不同类的方法

纯虚函数和抽象类

学生类不应该有自己的对象，于是学生类被叫做抽象类

class student{
public:
student();
student(int a, string b);
virtual void study() = 0; 表明这是纯虚函数
}

student aa; 报错
student *p;
undergraduate bb;
p = &bb;
p ->study(); 通过多态调用子类的study方法