C++ DAY5
一、静态成员
在创建出来的同一类中是一样的。
class MyClass {
public:
static int myStaticVar;
};
int MyClass::myStaticVar = 0; // 初始化
MyClass obj1;
MyClass obj2;
obj1.myStaticVar = 1; // 修改静态成员变量
cout << obj2.myStaticVar; // 输出也是 1，因为静态成员变量是共享的
在数据成员前加static ----->静态数据成员
在成员函数前加static ------>静态成员函数
静态数据成员
- 作用域：静态成员变量的作用域仅限于其所属的类。
- 访问控制：静态成员变量可以是
public、protected或private，这意味着你可以限制对它的访问。 - 类关联：静态成员变量是与类关联的，而不是与特定对象关联。所有对象共享同一个静态成员变量。
- 初始化：必须在类定义外部进行初始化。
- 访问方式：可以通过类名或对象来访问。
静态成员函数
只能访问静态数据成员，非静态数据成员均访问不了
格式
class 类名
{
static 数据类型 变量名; //静态数据成员
static 函数返回值类型 函数名(形参列表) //静态成员函数
{}
};
数据类型 类名::变量 = 初始化; 银行账户实例
#include
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;
} 二、类的继承
类的三大属性：封装继承和多态
目的：1.实现代码的重用性
2.建立父类和子类之间的联系
3.在实现多态的时候，通过继承，实现子类对父类函数的重写
保持已有类的特性，在原来基础上，增加新的特性，构造出新类的过程， 成为 继承 / 派生
被继承者 称为 父类 / 基类
继承者 称为 子类 / 派生类
格式
class 类名:继承方式 类名
{
子类的拓展;
};
//继承方式： public 共有继承 protected保护继承 private私有继承
//一般用public方式继承当一个成员变量或成员函数在基类（父类）中被声明为 protected 时，该成员可以在派生类（子类）中被访问，但不能通过基类的对象直接访问（类外访问）。
#include
using namespace std;
//封装 人 类 父类/基类
class Person
{
protected:
int high;
private:
string name;
public:
int age;
//无参构造函数
Person()
{
cout << "父类的无参构造函数" << endl;
}
//有参构造
Person(string name, int age,int high):name(name),age(age),high(high)
{
cout << "父类的有参构造函数" << endl;
}
};
//封装 学生 类 共有继承人 类
class Stu:public Person //子类 、派生类
{
private:
int id;
int math;
public:
//无参构造函数
Stu()
{
cout << "子类的无参构造函数" << endl;
}
//有参构造函数
Stu(string name, int age, int high, int id, int math):Person(name,age,high),id(id),math(math)
{
cout << "子类的有参构造函数" << endl;
}
};
int main()
{
Stu s("zhangsan",12,180,1001,78);
//cout << s.Person::high < public继承：基类的public和protected成员在派生类中保持原来的访问级别。protected继承：基类的public和protected成员在派生类中都变为protected。private继承：基类的public和protected成员在派生类中都变为private。
父类中成员权限 public | protected | private public | protected | private public | protected | private
继承方式 public protected private
继承到子类中该成员的权限 public | protected | 不可访问 protected | protected | 不可访问 private | private | 不可访问
类外是否可以访问子类 可以 | 不可以 | 不可以 不可以 | 不可以 | 不可以 不可以 | 不可以 | 不可以
从父类中继承下来的成员示例代码
#include
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;
}
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;
}
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;
// s.show();
// s.Person::show();
return 0;
} 1> 父类的初始化必须赶在子类之前，换句话说，先调用父类的构造函数，再调用子类的构造函数
2> 当父类的函数和子类的函数是同名同类型时，不会报错，原因是作用域不同，如果子类实例化出一个对象，这个对象调用该函数，调用的是子类的函数，如果想调用父类中函数。则需要加上类名和作用域限定符。