静态成员变量
static 基类和派生类 使用的同一个
必须要初始化
静态成员函数，只能在类的内部定义，只能使用静态成员变量
1构造顺序
基类
子对象
派生类
2析构顺序
派生类
子对象
基类
派生类的析构调用顺序 相反
先调用派生类的析构 再调用基类的
在派生类的外部访问基类中的成员时，会根据继承方式影响基类成员的访问级别
子类调用父类的方法
子类.父类::fun()
带引用类型返回值的函数 不要返回临时变量的引用
友元函数
1.写在类的外部，声明在类的里面，可以通过类的对象去访问类的私有成员
2.使用friend 关键字
class Student{
friend void pass(Student &s);
}
void pass(Student &s){
}
访问控制
级别：public < protected < private
类的继承方式和内部的成员，取级别高的
概念：
1.重载：在同一作用域下，函数名相同，但参数列表不同。
2.重写：分别在基类和派生类中（在不同的作用域下），函数名相同，参数相同，返回类型相同，并且基类函数必须为虚函数。
3.重定义：分别在基类和派生类中（在不同作用域下），函数名相同，不不构成重写的话则为重定义。（参数列表可相同可不同）。
完成程序：职业系统
要求：
1.设计一个包含所有职业共同属性和方法的基类（HP,MP,DEF,RES,普通攻击）
2.设计合集三个不同的派生类（Warrior，Mage，Priest），各个派生类特有的属性（战士：ATN，法师，牧师:INT）不同职业拥有各自不同的技能
（战士：刀斩，法师：火球术，牧师：治疗术）
3.创建各个对象并使用技能。
#include <iostream>
#include "stdio.h"
#include "string"
using namespace std;
class B
{
public:
int b_;
B(int b = 0)
{
b_ = b;
cout << "调用B的构造函数" << endl;
}
};
class C1 :virtual public B
{
public:
int c1_;
C1(int b = 0, int c1 = 0) :B(b)
{
c1_ = c1;
cout << "调用C1的构造函数" << endl;
}
};
class C2 :virtual public B
{
public:
int c2_;
C2(int b = 0, int c2 = 0) :B(b)
{
c2_ = c2;
cout << "调用C2的构造函数" << endl;
}
};
class D :public C1, public C2
{
public:
int d_;
D(int b = 0, int c1 = 0, int c2 = 0, int d = 0) :B(b), C1(b, c1), C2(b, c2)
{
d_ = d;
cout << "调D的构造函数" << endl;
}
void printf()
{
cout << " C1.b_: " << C1::b_ << " C2.b_: " << C2::b_ << " c1_: " << c1_ << " c2_: " << c2_ << " d_: " << d_ << endl;
}
};
class D2 : public C1, public C2
{
public:
int d2_;
D2(int b = 0, int c1 = 0, int c2 = 0, int d2 = 0) :B(b), C1(b, c1), C2(b, c2)
{
d2_ = d2;
cout << "调用D2的构造函数" << endl;
}
void printf()
{
cout << "b_: " << b_ << " c1_: " << c1_ << " c2_: " << c2_ << " d_: " << d2_ << endl;
}
};
int main()
{
D d = D(1, 2, 3, 4);
d.printf();
D2 d2 = D2(3, 4, 5, 6);
d2.printf();
}
#include <iostream>
#include "stdio.h"
#include "string"
using namespace std;
class Student
{
protected:
string name_;
int age_;
public:
void setStudent(string name, int age)
{
name_ = name;
age_ = age;
}
void printf()
{
cout << "姓名： " << name_ << " 年龄： " << age_ << endl;
}
int get_age()
{
return age_;
}
string get_name()
{
return name_;
}
};
class Collagestudent:public Student
{
private:
string major_;
public:
void setCStudent(string name, int age, string major)
{
name_ = name;
age_ = age;
major_ = major;
}
void printf()
{
cout << "姓名： " << name_ << " 年龄： " << age_ << " 专业： "<<major_<<endl;
}
};
void work(Student &s)
{
if (s.get_age() >=18)
cout <<s.get_name()<< "达到法定工作年龄" << endl;
else
cout << s.get_name() << "未达到法定工作年龄" << endl;
}
int main()
{
Student stu;
stu.setStudent("李明",15);
stu.printf();
Collagestudent cstu;
cstu.setCStudent("李雷", 18, "计算机");
cstu.printf();
Student stu1 = cstu;//将派生类对象赋值给基类对象
stu1.printf();
Student& rs = cstu;//将派生类的对象初始化基类的引用
rs.printf();
Student* ps = &cstu;//可以将派生类对象的地址赋给基类指针
ps->printf();
work(stu);//使用基类对象作为形参
work(cstu);//使用派生类对象作为形参
}
#include <iostream>
#include "stdio.h"
#include "string"
using namespace std;
class Base
{
private:
int bnum1_;
public://在类的内部都可以访问到，通过成员方法或者友元函数。
//在派生类中只能访问到基类的public成员和protected成员。
int bnum2_;
void setNum(int bnum1, int bnum2, int bnum3)
{
bnum1_ = bnum1;
bnum2_ = bnum2;
bnum3_ = bnum3;
}
friend void printf(Base &b)
{
cout << " bnum1: " << b.bnum1_ << " bnum2: " << b.bnum2_ << " bnum3: " << b.bnum3_ << endl;
}
protected:
int bnum3_;
};
class Derived1 :private Base
{
public:
void printf()
{
//基类私有成员不能被访问。
cout << "bnum2: " << bnum2_ << " bnum3: " << bnum3_ << endl;
}
};
class Derived2 :protected Base
{
void printf()
{
//基类私有成员不能被访问。
cout << "bnum2: " << bnum2_ << " bnum3: " << bnum3_ << endl;//基类的公有成员和保护成员，在派生类中可以访问。
}
};
class Derived : public Base
{
private:
int bnum1_;
public:
int bnum2_;
protected:
int bnum3_;
};
int main()
{
Base b;
b.bnum2_=10;
//b.bnum1_=10;//不可以访问
//b.bnum3_=10;//不可以访问
b.setNum(20, 25, 30);
printf(b);
Derived d;
d.bnum2_ = 10;//可以被访问
}
实现一个Money类
要求：
1.Money类有两个数据成员：金币数量和银币数量，每一个金币等于1000个银币。
2.实现+，-，*，/。
3.实现++，--运算符的重载（银币加减100）。
4.实现=运算符的重载。
5.实现==，！=，>=，<=，<，>运算符的重载。
6.实现>>,<<运算符的重载。
#include <iostream>
#include "stdio.h"
#include "string"
using namespace std;
class Money
{
private:
float gold_;
float silver_;
static const int ratio = 1000;
public:
Money(int gold = 0, int silver = 0);
~Money();
Money operator+(const Money& m);
Money operator-(const Money& m);
Money operator*(const int n);
Money operator/(const int n);
Money& operator++();
Money& operator--();
Money& operator=(const Money& m);
bool operator==(const Money& m);
bool operator!=(const Money& m);
bool operator>=(const Money& m);
bool operator<=(const Money& m);
bool operator<(const Money& m);
bool operator>(const Money& m);
friend ostream& operator<<(ostream& os, const Money& m);
friend istream& operator>>(istream& is, Money& m);
};
int main()
{
Money m1 = Money(100, 600);
Money m2 = Money(100, 500);
Money m3 = m1;
Money m4 = m3 + m2;
Money m5 = m1 * 2;
++m3;
Money m6 = m5 / 2;
cout << m1 << endl << m2 << endl << m3 << endl << m4 << endl << m5 << endl << m6 << endl;
Money m7;
cout << "请输入m7的值： ";
cin >> m7;
Money m8;
cout << "请输入m8的值： ";
cin >> m8;
if (m7 == m8)
cout << "m7等于m8" << endl;
else if (m7 > m8)
{
cout << "m7大于m8" << endl;
}
}
Money::Money(int gold, int silver)
{
gold_ = gold;
silver_ = silver;
}
Money::~Money() {}
Money Money::operator+(const Money& m)
{
Money money;
int i = this->gold_ * ratio + m.gold_ * ratio + this->silver_ + m.silver_;
money.gold_ = i / ratio;
money.silver_ = i % ratio;
return money;
}
Money Money::operator-(const Money& m)
{
Money money;
int i = this->gold_ * ratio - m.gold_ * ratio + this->silver_ - m.silver_;
money.gold_ = i / ratio;
money.silver_ = i % ratio;
return money;
}
Money Money::operator*(const int n)
{
Money money;
int i = this->gold_ * ratio * n + this->silver_ * n;
money.gold_ = i / ratio;
money.silver_ = i % ratio;
return money;
}
Money Money::operator/(const int n)
{
Money money;
int i = (this->gold_ * ratio + this->silver_) / n;
money.gold_ = i / ratio;
money.silver_ = i % ratio;
return money;
}
Money& Money::operator++()
{
int i = this->gold_ * ratio + this->silver_;
i += 100;
this->gold_ = i / ratio;
this->silver_ = i % ratio;
return*this;
}
Money& Money::operator--()
{
int i = this->gold_ * ratio + this->silver_;
i -= 100;
this->gold_ = i / ratio;
this->silver_ = i % ratio;
return*this;
}
Money& Money::operator=(const Money& m)
{
this->gold_ = m.gold_;
this->silver_ = m.silver_;
return *this;
}
bool Money::operator==(const Money& m)
{
if ((this->gold_ * ratio + this->silver_) == (m.gold_ * ratio + m.silver_))
return true;
else
return false;
}
bool Money::operator!=(const Money& m)
{
if ((this->gold_ * ratio + this->silver_) != (m.gold_ * ratio + m.silver_))
return true;
else
return false;
}
bool Money::operator>=(const Money& m)
{
if ((this->gold_ * ratio + this->silver_) >= (m.gold_ * ratio + m.silver_))
return true;
else
return false;
}
bool Money::operator<=(const Money& m)
{
if ((this->gold_ * ratio + this->silver_) <= (m.gold_ * ratio + m.silver_))
return true;
else
return false;
}
bool Money::operator<(const Money& m)
{
if ((this->gold_ * ratio + this->silver_) < (m.gold_ * ratio + m.silver_))
return true;
else
return false;
}
bool Money::operator>(const Money& m)
{
if ((this->gold_ * ratio + this->silver_) > (m.gold_ * ratio + m.silver_))
return true;
else
return false;
}
ostream& operator<<(ostream& os, const Money& m)
{
os << "金币数量：" << m.gold_ << " " << "银币数量：" << m.silver_ << endl;
return os;
}
istream& operator>>(istream& is, Money& m)
{
is >> m.gold_ >> m.silver_;
if (!is)
{
m = Money();
}
return is;
}
#include <iostream>
#include "stdio.h"
#include "string"
using namespace std;
class Time
{
private:
int hours_;
int minutes_;
public:
Time(int hours = 0, int minutes = 0);
~Time();
void showTime();
Time operator+(const Time& t);
Time operator-(const Time& t);
Time operator*(int const i);
};
int main()
{
Time t1 = Time(19, 55);
Time t2 = Time(1, 5);
Time t3 = Time(5, 30);
//t1.showTime();
Time total1 = t1 + t2;
Time total2 = t1.operator-(t3);
Time total3 = t3.operator*(2);
Time total4 = t1 + t3 * 2;
total1.showTime();
total2.showTime();
total3.showTime();
total4.showTime();
}
Time::Time(int hours, int minutes)
{
hours_ = hours;
minutes_ = minutes;
}
Time::~Time() {}
void Time::showTime()
{
cout << "当前时间为:" << hours_ << "小时" << minutes_ << "分" << endl;
}
Time Time::operator+(const Time& t)
{
Time Temp;
Temp.hours_ = this->hours_ + t.hours_;
if (this->minutes_ + t.minutes_ < 60)
Temp.minutes_ = this->minutes_ + t.minutes_;
else
{
Temp.hours_ += 1;
Temp.minutes_ += (this->minutes_ + t.minutes_) % 60;
}
return Temp;
}
Time Time::operator-(const Time& t)
{
Time Temp;
float i = this->hours_ * 60 + this->minutes_ - t.hours_ * 60 - t.minutes_;
Temp.hours_ = i / 60;
Temp.minutes_ = i - Temp.hours_ * 60;
return Temp;
}
Time Time::operator*(int const i)
{
int j;
Time temp;
j = this->hours_ * i * 60 + this->minutes_ * i;
temp.hours_ = j / 60;
temp.minutes_ = j - temp.hours_ * 60;
return temp;
}
1）const成员函数可以访问非const对象的非const数据成员、const数据成员，也可以访问const对象内的所有数据成员；
2）非const成员函数可以访问非const对象的非const数据成员、const数据成员，但不可以访问const对象的任意数据成员；
3）作为一种良好的编程风格，在声明一个成员函数时，若该成员函数并不对数据成员进行修改操作，应尽可能将该成员函数声明为const 成员函数。
4）如果只有const成员函数，非const对象是可以调用const成员函数的。当const版本和非const版本的成员函数同时出现时，非const对象调用非const成员函数。
C++中一般情况下的联编是静态联编。一旦涉及到多态和虚函数就必须使用动态联编。
1.一般为了便于阅读，派生类的虚函数也会添加上virtual关键字；
2.使用基类的对象的引用作为参数，可以根据传递的实参类型，去选择调用的函数。
静态成员函数只能访问静态数据成员和静态成员函数。
一般来说，系统会自动提供一个默认的拷贝构造函数和赋值符重载函数；
但当类中包含有指针或任何运行时分配的资源时，则需要我们自定义赋值操作符重载函数与拷贝构造函数。
