目录
一、静态成员
1.1 概念
静态数据成员和静态成员函数是属于类的，不属于类的实例，它们在所有类的实例中是共享。
在数据成员前加static ----->静态数据成员
在成员函数前加static ------>静态成员函数
静态变量的初始化必须在类外初始化，如果没有初始化(不建议)，默认为0
静态成员函数只能访问静态数据成员。
1.2 格式
class 类名
{
static 数据类型 变量名; //静态数据成员
static 函数返回值类型 函数名(形参列表) //静态成员函数
{}
};
数据类型 类名::变量 = 初始化; 1.3 银行账户实例
#include <iostream>
using namespace std;
//封装银行账户 类
class BankAccount
{
private:
double balance; //余额
static double interest_rate; //利率 静态数据成员 属于类的
public:
//无参构造
BankAccount() {}
//有参构造函数
BankAccount(double b):balance(b)
{}
//静态成员函数 获取当前的利率
static double getInterestRate()
{
return interest_rate;
}
//静态成员函数，设置当前利率
static void setInterestRate(double rate)
{
interest_rate = rate;
}
//静态成员函数 获取连本带利的余额
static double getLastMoney(BankAccount &account)
{
return account.balance*(1+interest_rate);
}
};
double BankAccount::interest_rate = 0.05; //在类外初始化 静态数据成员
int main()
{
cout << "当前利率：" << BankAccount::getInterestRate() << endl;
BankAccount::setInterestRate(0.03);
cout << "当前利率：" << BankAccount::getInterestRate() << endl;
BankAccount account1(1000.0);
BankAccount account2(2000.0);
cout << "第一个人连本带利的余额：" << BankAccount::getLastMoney(account1) << endl;
return 0;
}二、类的继承
类的三大属性：封装、继承、多态
2.1 目的
1> 实现代码的重用性
2> 建立父类和子类之间的联系
3> 在实现多态的时候，通过继承，实现子类对父类函数的重写
2.2 概念
保持已有类的特性，在原来基础上，增加新的特性，构造出新类的过程， 成为 继承 / 派生
被继承者 称为 父类 / 基类
继承者 称为 子类 / 派生类
2.3 格式
class 类名:继承方式 类名
{
子类的拓展;
};
//继承方式： public 共有继承 protected保护继承 private私有继承
//一般用public方式继承#include <iostream>
using namespace std;
//封装 人 类 父类/基类
class Person
{
private:
string name;
int age;
public:
//无参构造函数
Person()
{
cout << "父类的无参构造函数" << endl;
}
//有参构造
Person(string name, int age):name(name),age(age)
{
cout << "父类的有参构造函数" << endl;
}
};
//封装 学生 类 共有继承人 类
class Stu:public Person //子类 、派生类
{
private:
int id;
int math;
public:
//无参构造函数
Stu()
{
cout << "子类的无参构造函数" << endl;
}
//有参构造函数
Stu(string name, int age, int id, int math):Person(name,age),id(id),math(math)
{
cout << "子类的有参构造函数" << endl;
}
};
int main()
{
Stu s("zhangsan",12,1001,78);
return 0;
}2.4 继承方式
父类中成员权限 public | protected | private public | protected | private public | protected | private
继承方式 public protected private
继承到子类中该成员的权限 public | protected | 不可访问 protected | protected | 不可访问 private | private | 不可访问
类外是否可以访问子类 可以 | 不可以 | 不可以 不可以 | 不可以 | 不可以 不可以 | 不可以 | 不可以
从父类中继承下来的成员
2.5 继承中的特殊成员函数
2.5.1 构造函数
父类的初始化必须赶在子类之前，换句话说，先调用父类的构造函数，再调用子类的构造函数
2.5.2析构函数
析构函数调用的顺序：先调用子类的析构函数，再调用父类的析构函数。
先构造的 后析构。 后构造的 先析构
2.5.3 拷贝构造函数
父类的拷贝构造函数会继承到子类中，在子类的拷贝构造函数中使用父类的拷贝构造函数，来完成子类从父类继承下来的成员的拷贝工作。
如果涉及深拷贝，则需要在子类和父类各自完成深拷贝工作。
2.5.4拷贝赋值函数
父类的拷贝赋值函数会继承到子类中，在子类的拷贝赋值函数中使用父类的拷贝赋值函数，来完成子类从父类继承下来的成员的赋值工作。
如果涉及深拷贝，则需要在子类和父类各自完成深拷贝工作
#include <iostream>
using namespace std;
//封装 人 类 父类/基类
class Person
{
private:
string name;
protected:
int age;
public:
int h;
public:
//无参构造函数
Person()
{
cout << "父类的无参构造函数" << endl;
}
//有参构造
Person(string name, int age, int h):name(name),age(age),h(h)
{
cout << "父类的有参构造函数" << endl;
}
//拷贝构造函数
Person(const Person & other):name(other.name),age(other.age),h(other.h)
{
cout << "父类的拷贝构造函数" << endl;
}
//拷贝赋值函数
Person & operator=(const Person &p)
{
name = p.name;
age = p.age;
h = p.h;
cout << "父类的拷贝赋值函数" << endl;
return *this;
}
void show()
{
cout << "父类的show" << endl;
}
};
//封装 学生 类 共有继承人 类
class Stu:public Person //子类 、派生类
{
private:
int id;
int math;
public:
//无参构造函数
Stu()
{
cout << "子类的无参构造函数" << endl;
}
//有参构造函数
Stu(string name, int age, int h, int id, int math):Person(name,age,h),id(id),math(math)
{
cout << "子类的有参构造函数" << endl;
}
//拷贝构造函数
Stu(const Stu & s):id(s.id),math(s.math),Person(s)
{
cout << "子类的拷贝构造函数" << endl;
}
//拷贝赋值函数
Stu & operator=(const Stu & s)
{
Person::operator=(s);
id = s.id;
math = s.math;
cout << "子类的拷贝赋值函数" << endl;
return *this;
}
void show()
{
cout << "子类的show" << endl;
cout << h << endl; //通过共有继承，类外、子类可以访问父类共有成员
cout << age << endl; //通过共有继承，子类可以访问父类保护成员,类外不可以访问
//cout << name << endl;//通过共有继承，子类不可访问父类私有成员,类外不可以访问
}
};
int main()
{
Stu s("zhangsan",12,190,1001,78);
Stu s2=s;
Stu s3;
s3 = s2;
// s.show();
// s.Person::show();
return 0;
}
总结：
1> 父类的初始化必须赶在子类之前，换句话说，先调用父类的构造函数，再调用子类的构造函数
2> 当父类的函数和子类的函数是同名同类型时，不会报错，原因是作用域不同，如果子类实例化出一个对象，这个对象调用该函数，调用的是子类的函数，如果想调用父类中函数。则需要加上类名和作用域限定符。
三、多继承
3.1 概念
一个类由多个类公共派生。
3.2 格式
class 类名:继承方式1 类名1,继承方式2 类名2,.....,继承方式n 类名n
{
子类的拓展
};#include <iostream>
using namespace std;
//封装 沙发的类
class Sofa
{
private:
string sitting;
public:
//无参构造
Sofa() {cout << "沙发的无参构造" << endl;}
//有参构造函数
Sofa(string s):sitting(s)
{
cout << "沙发的有参构造" << endl;
}
void display()
{
cout << sitting << endl;
}
};
//封装 床 类
class Bed
{
private:
string sleep;
public:
//无参
Bed() {cout << "床的无参构造" << endl;}
//有参
Bed(string s):sleep(s)
{
cout << "床的有参构造" << endl;
}
void display()
{
cout << sleep << endl;
}
};
//封装 沙发床类 继承于沙发 和 床
class Sofa_Bed:public Bed,public Sofa
{
private:
int w;
public:
//
Sofa_Bed(){cout << "沙发床的无参构造" << endl;}
//有参构造
Sofa_Bed(string sit, string s, int w):Bed(s),Sofa(sit),w(w)
{
cout << "沙发床的有参构造" << endl;
}
};
int main()
{
Sofa_Bed s;
Sofa_Bed s1("可坐","可躺",123);
s1.Sofa::display();
s1.Bed::display();
return 0;
}
3.3总结
1> 子类由多个父类共同派生，子类调用调用构造函数顺序，肯是最后调用自己，对于多个父类的构造函数顺序的调用，和初始化列表的书写顺序无关，和继承的时候顺序有关。
2> 当多个父类中有同名同类型的函数，子类对象调用该函数时，需要表明哪个类的，加上类名和作用域限定符。
379
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
