酒店网站案例,谷歌商店paypal三件套,接广告的平台推荐,网站建设手机端管网运算符重载
赋值运算符重载
种类#xff1a;、、-、*、/、%表达式#xff1a;L # R #xff08;L#xff1a;左操作数 #运算符 R#xff1a;右操作数#xff09;左操作数#xff1a;只能是左值右操作数#xff1a;可以是左值#xff0c;也可以是右值#xff0c;在运…运算符重载
赋值运算符重载
种类、、-、*、/、%表达式L # R L左操作数 #运算符 R右操作数左操作数只能是左值右操作数可以是左值也可以是右值在运算过程中不会被改变结果自身的引用实现方式
1.成员函数实现类名 operator#(const 类名 R){}2.全局函数实现类名 operator#(类名 L, const 类名 R){}自增、自减运算符重载
前置自增
表达式0操作数左值运算过程中要被改变结果自身的引用实现方式 成员函数实现类名 operator() 全局函数实现类名 operator(类名 O)
后置自增
表达式O操作数左值运算过程中要被改变结果右值(不可以被改变)实现方式 成员函数实现const 类名 operator(int) 全局函数实现const 类名 operator(类名 Oint)
代码示例 #include iostreamusing namespace std;//封装人 类
class Person
{
// friend const Person operator(const Person L, const Person R);friend Person operator(Person L, const Person R);
private:int a;int b;
public://无参构造函数Person() {}//有参构造函数Person(int a, int b):a(a),b(b){}Person(const Person p):a(p.a),b(p.b){}//成员函数实现 号运算符重载const Person operator(const Person R) const{Person temp;temp.a a R.a;temp.b b R.b;return temp;}//成员函数实现 浩运算符重载bool operator(const Person R){if(aR.a bR.b){return true;}else{return false;}}//成员函数实现运算符重载
// Person operator(const Person R)
// {
// a R.a; // a a R.a;
// b R.b;
// return *this;
// }//成员函数实现前运算符重载Person operator(){a;b;return *this;}//成员函数实现后运算符重载const Person operator(int) //区别前置自增{Person temp;temp.a a;temp.b b;return temp;}void display(){cout a a endl;cout b b endl;}
};全局函数实现号运算符重载
//const Person operator(const Person L, const Person R)
//{
// Person temp;
// temp.a L.a R.a;
// temp.b L.b R.b;// return temp;
//}//全局函数实现运算符重载
Person operator(Person L, const Person R)
{L.a R.a;L.b R.b;return L;
}int main()
{Person p1(10,10);Person p2(10,10);//简化成//Person p3 p1 p2; //本质 p3 p1.operator(p2)Person p3 p1 p2; //本质 p3 operator(p1,p2)p3.display();//Person p4 p1.operator(p2);//p4.display();if(p3p1){cout p3p1 endl;}cout endl;Person p4(3,4);p4 p1;p4.display();cout endl;p1 p4;p1.display();p4.display();cout endl;Person p5(7,8);p2 p5;p2.display();p5.display();return 0;
}插入提取运算符重载
插入 提取 cout是ostream类的对象cin是istream类的对象
代码示例 #include iostreamusing namespace std;//封装人 类
class Person
{
// friend const Person operator(const Person L, const Person R);friend Person operator(Person L, const Person R);friend ostream operator(ostream cout, const Person p);friend istream operator(istream cin, Person p);
private:int a;int b;
public://无参构造函数Person() {}//有参构造函数Person(int a, int b):a(a),b(b){}Person(const Person p):a(p.a),b(p.b){}//成员函数实现 号运算符重载const Person operator(const Person R) const{Person temp;temp.a a R.a;temp.b b R.b;return temp;}//成员函数实现 浩运算符重载bool operator(const Person R){if(aR.a bR.b){return true;}else{return false;}}//成员函数实现运算符重载
// Person operator(const Person R)
// {
// a R.a; // a a R.a;
// b R.b;
// return *this;
// }//成员函数实现前运算符重载Person operator(){a;b;return *this;}//成员函数实现后运算符重载const Person operator(int) //区别前置自增{Person temp;temp.a a;temp.b b;return temp;}void display(){cout a a endl;cout b b endl;}
};全局函数实现号运算符重载
//const Person operator(const Person L, const Person R)
//{
// Person temp;
// temp.a L.a R.a;
// temp.b L.b R.b;// return temp;
//}//全局函数实现运算符重载
Person operator(Person L, const Person R)
{L.a R.a;L.b R.b;return L;
}//全局函数实现插入运算符重载
ostream operator(ostream cout, const Person p)
{cout p.a endl;cout p.b endl;return cout;
}//全局函数实现提取运算符重载
istream operator(istream cin, Person p)
{cin p.a;cin p.b;return cin;
}int main()
{Person p1(10,10);Person p2(10,10);//简化成//Person p3 p1 p2; //本质 p3 p1.operator(p2)Person p3 p1 p2; //本质 p3 operator(p1,p2)p3.display();//Person p4 p1.operator(p2);//p4.display();if(p3p1){cout p3p1 endl;}cout endl;Person p4(3,4);p4 p1;p4.display();cout endl;p1 p4;p1.display();p4.display();cout endl;Person p5(7,8);p2 p5;p2.display();p5.display();cout endl;// operator(cout,p2)cout p2 endl; //本质 cout.perator(p2)//全局函数本质 operator(cout,p2)// ostream operator(ostream cout,const Person p)cout endl;Person p6;cin p6; //cin.operator(p2)// operator(cin,p6)// istream operator(istream cin, Person p)cout p6;return 0;
}不能重载的运算符
成员运算符 .成员指针运算符 -作用域限定符 ::计算字节大小 sizeof()三目运算符 ?:
静态成员
概念
静态数据成员和静态成员函数是属于类的不属于类的实例它们在所有类的实例中是共享的
在数据成员前加static -----静态数据成员 在成员函数前加static -----静态成员函数
静态变量的初始化必须在类外初始化如果没有初始化默认为0 静态成员函数只能访问静态数据成员
格式
class 类名
{static 数据类型 变量名; //静态数据成员static 函数返回值类型 函数名(形参列表) //静态成员函数{} };
数据类型 类名::变量 初始化; 银行账户实例代码
#include iostreamusing 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*(1interest_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;
}类的继承
类的三大属性封装、继承、多态
目的
实现代码的重用性建立父类和子类之间的联系在实现多态的时候通过继承实现子类对父类函数的重写
概念
保持已有类的特性在原来的基础上增加新的特性构造出新类的过程成为继承/派生被继承者称为 父类 / 基类继承者称为 子类 / 派生类
格式
class 类名:继承方式 类名
{子类的拓展;
};//继承方式 public 共有继承 protected保护继承 private私有继承
//一般用public方式继承代码示例
#include iostreamusing 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;
}继承方式
父类中成员权限 public | protected | private public | protected | private public | protected | private
继承方式 public protected private
继承到子类中该成员的权限 public | protected | 不可访问 protected | protected | 不可访问 private | private | 不可访问
类外是否可以访问子类 可以 | 不可以 | 不可以 不可以 | 不可以 | 不可以 不可以 | 不可以 | 不可以
从父类中继承下来的成员继承中的特殊成员函数
构造函数
父类的初始化必须赶在子类之前换句话说先调用父类的构造函数再调用子类的构造函数
析构函数
析构函数的调用顺序先调用子类的析构函数再调用父类的析构函数 先构造的后析构。后构造的先析构
构造拷贝函数
父类的拷贝构造函数会继承到子类中在子类的拷贝赋值函数中使用父类的拷贝赋值函数来完成子类从父类继承下来的成员的赋值工作。 如果涉及深拷贝则需要再子类和父类中各自完成深拷贝工作
代码示例
#include iostreamusing 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 s2s;Stu s3;s3 s2;// s.show();
// s.Person::show();return 0;
}
总结
父类的初始化必须赶在子类之前也就是先调用父类的构造函数再调用子类的构造函数当父类的函数和子类的函数是同名类型时不会报错原因是因为作用域不同如果子类实例化出一个对象这个对象调用该函数调用的是子类的函数如果调用父类中函数则需要加上类名和作用域限定符
多继承
概念
一个类由多个类公共派生
格式
class 类名:继承方式1 类名1,继承方式2 类名2,.....,继承方式n 类名n
{子类的拓展
};代码示例
#include iostreamusing 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;
}
总结
子类由多个父类共同派生子类调用构造函数的顺序是最后调用自己对于多个父类的构造函数顺序的调用和初始化列表的书写顺序无关和继承时候的顺序有关当多个父类中有同名同类型的函数子类对象调用该函数时需表明属于哪个类加上类名和作用域限定符
