练习：
实现3*3矩阵类，支持如下操作符：
+ - += -=
#include<iostream>
#include<iomanip>//setw()设置域宽
using namespace std;
class M33{
public:
M33(void){
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
m_a[i][j]=0;
}
M33(int a[][3]){
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
m_a[i][j]=a[i][j];
}
friend ostream& operator<<(ostream& os,const M33& m){
for(int i=0;i<3;i++){
for(int j=0;j<3;j++)
os<<setw(4)<<m.m_a[i][j];
os<<endl;
}
return os;
}
const M33 operator+(const M33& m)const{
int a[3][3]={};
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
a[i][j]=m_a[i][j]+m.m_a[i][j];
return a; //return M33(a);
}
const M33 operator-(const M33& m)const{
int a[3][3]={};
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
a[i][j]=m_a[i][j]-m.m_a[i][j];
return a; //return M33(a);
}
const M33 operator*(const M33& m)const{
int a[3][3]={};
for(int i=0;i<3;i++)
for(int j=0;j<3;j++)
for(int k=0;k<3;k++)
a[i][j]+=m_a[i][k]*m.m_a[k][j];
return a; //return M33(a);
}
//+ - *返回值右值，左操作数必须是左值，右操作数可以为左值，也可以为右值
M33& operator+=(const M33& m){
return *this=*this + m;
}
M33& operator-=(const M33& m){
return *this=*this - m;
}
M33& operator*=(const M33& m){
return *this=*this * m;
}
private:
int m_a[3][3];
};
int main(){
int a1[3][3]={1,2,3,4,5,6,7,8,9};
int a2[3][3]={9,8,7,6,5,4,3,2,1};
M33 m1(a1);
M33 m2(a2);
cout<<m1<<endl;
cout<<m2<<endl;
cout<<"m1+m2"<<endl;
cout<<m1+m2<<endl;
cout<<"m1-m2"<<endl;
cout<<m1-m2<<endl;
cout<<"m1*m2"<<endl;
cout<<m1*m2<<endl;
cout<<"m1+=m2"<<endl;
cout<<(m1+=m2)<<endl;
cout<<"m1-=m2"<<endl;
cout<<(m1-=m2)<<endl;
cout<<"m1*=m2"<<endl;
cout<<(m1*=m2)<<endl;
return 0;
}
tarena@tarena-virtual-machine:~/day42$./a.out
1 2 3
4 5 6
7 8 9
9 8 7
6 5 4
3 2 1
m1+m2
10 10 10
10 10 10
10 10 10
m1-m2
-8 -6 -4
-2 0 2
4 6 8
m1*m2
30 24 18
84 69 54
138114 90
m1+=m2
10 10 10
10 10 10
10 10 10
m1-=m2
1 2 3
4 5 6
7 8 9
m1*=m2
30 24 18
84 69 54
138114 90
3、（操作符重载，接昨天）单目操作符重载：#O
3.1 计算类的单目操作符（~ 、 ！…） ！a, ~a ; -a; &a ;
1）成员函数形式
#O==》O.operator#( )
2）全局函数形式
#O==》：：operator#(0)
举例：
1#include<iostream>
2using namespace std;
3class Integer{
4public:
5 Integer(int i=0):m_i(i){}
6 const Integeroperator-(void)const{//取负操作符重载
7 return Integer(-m_i);
8 }
9 //自定义~表示乘方
10 friend const Integer operator~(const Integer& i){
11 return Integer(i.m_i*i.m_i);
12 }
13 friend ostream& operator<<(ostream& os,const Integer&i){
14 os<<i.m_i;
15 }
16private:
17 int m_i;
18};
19int main(void){
20 Integer i(100);
21 Integer j=-i;
22 cout<<i<<endl;//-100
23 cout<<j<<endl;//-100
24 j=~i;
25 cout<<j<<endl;//10000
26 return 0;
27 }
3.2自增减操作符
1）前缀自增减
成员函数： #O==》O.operator#( )
全局函数： #O==》：：operator#(0)
++n; 操作数必须是左值，返回值就是操作数自身也是左值
2）后缀自增减
成员函数： #O==》O.operator#( int)
全局函数： #O==》：：operator#(0,int)
int num=10;
num++；
num ; 11
操作数必须是左值，返回值是右值，是自增减之前的副本
举例：
1#include<iostream>
2using namespace std;
3class Integer{
4public:
5 Integer(int i=0):m_i(i){}
6 //前++ (可以用友元) 成员函数
7 Integer&operator++(void){
8 ++m_i;
9 return *this;
10 }
11 //前-- 全局函数
12 friend Integer& operator--(Integer& i){
13 --i.m_i;
14 return i;
15 }
16 //后++ (可以用友元friend，这样也可以)
17 const Integer operator++(int){
18 Integer old=*this;
19 ++*this;//复用前++
20 return old;
21 }
22 //后--
23 friend const Integeroperator--(Integer& i,int){
24 Integer old=i;
25 --i;
26 return old;
27 }
28 friend ostream& operator<<(ostream& os,const Integer&i){
29 os<<i.m_i;
30 }
31private:
32 int m_i;
33};
34int main(void){
35 Integer i(123);
36 Integer j=++i;
37 cout<<"i="<<i<<endl;//124
38 cout<<"j="<<j<<endl;//124
39 j=++++++i;
40 cout<<"i="<<i<<endl;//127
41 cout<<"j="<<j<<endl;//127
42
43 j=i++;
44 cout<<"i="<<i<<endl;//128
45 cout<<"j="<<j<<endl;//127
46
47 j=--i;
48 cout<<"i="<<i<<endl;//127
49 cout<<"j="<<j<<endl;//127
50
51 j=i--;
52 cout<<"i="<<i<<endl;//126
53 cout<<"j="<<j<<endl;//127
54 return 0;
55 }
4、函数操作符：（）（少用！）
如果一个类重载了函数操作符，那么该类的对象就可以当做函数来调用，其参数和返回值就是函数操作符函数的参数和返回值
1#include<iostream>
2using namespace std;
3class Square{
4public:
5 double operator()(doublex)const{
6 return x*x;
7 }
8 int operator()(int a,intb,int c=9){
9 return a+b-c;
10 }
11};
12int main(void){
13 Square square;
14 cout<<square(13.)<<endl;//square.operator()(13.)
15 cout<<square(10,40,20)<<endl;//30
16 cout<<square(10,40)<<endl;//41
17 return 0;
18 }
5、下标操作符，[]
int arr[5]={1,2,3,4,5};
arr[1]=20;
cosnt int (rarr)[5]= arr;
rarr[1]=20;//error
举例：
1#include<iostream>
2using namespace std;
3class Array{
4public:
5 Array(int size):m_data(newint[size]),m_size(size){}
6 ~Array(void){
7 delete[] m_data;
8 m_data=0;
9 }
10 int& operator[](int i){//非常对象调用
11 return m_data[i];
12 }
13 const int& operator[](int i)const{//常对象调用
14 //return m_data[i];
15 //直接复用上面的非常版本
16 returnconst_cast<Array&>(*this)[i];
17 }
18private:
19 int * m_data;
20 int m_size;
21};
22int main(void){
23 Array a(10);
24 a[0]=10;//a.operator[](0)->a.m_data[0]=10
25 a[1]=20;
26 cout<<a[0]<<','<<a[1]<<endl;//10,20
27 const Array& ra=a;
28 cout<<ra[0]<<','<<ra[1]<<endl;//10,20
29 //ra[0]=11; error const修饰不能修改值
30 //ra[1]=12; error
31 return 0;
32 }
6、解引用和间接成员访问操作符： * 、->
用于实现智能指针：一个封装常规指针的类类型对象，当它离开作用域时，其析构函数负责释放该常规指针所指向的动态内存，避免内存泄露。
代码：
1#include<iostream>
2using namespace std;
3class A{
4public:
5 A(void){
6 cout<<"A::A()"<<endl;
7 }
8 ~A(void){
9 cout<<"A::~A()"<<endl;
10 }
11};
12class PA{
13public:
14 PA(A* pa=NULL):m_pa(pa){}
15 ~PA(void){
16 if(m_pa){
17 delete m_pa; //释放栈区空间
18 m_pa=NULL;
19 }
20 }
21private:
22 A* m_pa;
23};
24 int main(void){
25 //A a;
26 //A* pa=new A;
27 PA pa(new A);//栈区对象
28 return 0;//智能指针：析构函数一定会被调用，防止内存泄露
29 }
tarena@tarena-virtual-machine:~/day42$./a.out
A::A()
A::~A()
实际使用：
#include<iostream>
#include<memory>
using namespace std;
class A{
public:
A(const string& str):m_str(str){
cout<<"A::A()"<<endl;
}
~A(void){
cout<<"A::~A()"<<endl;
}
string m_str;
};
class PA{
public:
PA(A* pa=NULL):m_pa(pa){}
~PA(void){
if(m_pa){
delete m_pa; //释放栈区空间
m_pa=NULL;
}
}
A* operator->(void)const{
return m_pa;
}
A& operator*(void)const{
return *m_pa;
}
private:
A* m_pa;
};
int main(void){
//A a;
//A* pa=new A;
#if 0
PA pa(new A("hello world"));//栈区对象
//pa.operator->()->m_str;
cout<<pa->m_str<<endl;
//pa.operator*().m_str;
cout<<(*pa).m_str<<endl;
#else
auto_ptr<A> pa(new A("hello world!"));//内部自动封装了只能指针
cout<<pa->m_str<<endl;
cout<<(*pa).m_str<<endl;
#endif
return 0;//智能指针：析构函数一定会被调用，防止内存泄露
}
7、类型转换操作符
1）通过构造函数实现自定义类型转换
基本类型-à类类型
Integer i (100);
//int -> Integer
i=200;//通过类型转换构造函数
2）通过类型转换操作符函数实现自定义类型转换
operator 目标类型（void）const { }
类类型à基本类型
//Integer àint
int i2=i ;//类型转换操作符函数
3）如果两个类型都是基本类型，无法转换
4）如果两个类型都是自定义类型，两种方式都可以
例：
1#include<iostream>
2using namespace std;
3class Integer{
4public:
5 //int ---> Integer
6 Integer(int data=0):m_data(data){
7 cout<<"类型转换构造函数"<<endl;
8 }
9 operator int(void)const{
10 cout<<"类型转换操作符函数"<<endl;
11 return m_data;
12 }
13private:
14 int m_data;
15};
16int main(){
17 Integer i1(100);//构造函数
18 i1=200;//类型转换构造函数，把i1转换成整型数
19 cout<<i1<<endl;//200 操作符函数
20 int i2=i1;//操作符函数
21 cout<<i2<<endl;//200
22 return 0;
23 }
类型转换构造函数
类型转换构造函数
类型转换操作符函数
200
类型转换操作符函数
200
8、new/delete 操作符
static void* operator new(size_t size){….}
static void operator delete(void *p){….}
举例：
1#include<iostream>
2#include<cstdlib>
3using namespace std;
4class A{
5public:
6 A(void){
7 cout<<"A::A()"<<endl;
8 }
9 ~A(void){
10 cout<<"A::~A()"<<endl;
11 }
12 static void* operator new(size_t size){
13 cout<<"A::new"<<endl;
14 void *pv=malloc(size);
15 return pv;
16 }
17 static void operator delete(void* pv){
18 cout<<"A::delete"<<endl;
19 free(pv);
20 }
21};
22int main(){
23 //1)分配内存
24 //A* pa=(A*)A::operator new(sizeof(A));
25 //2)pa->A();
26 A* pa=new A;
27
28 //1)pa->~A();
29 //2)释放内存
30 //A::operator delete(pa);
31 delete pa;
32 return0;
33 }
9、操作符重载限制
1）不是所有的操作符都能重载，下列操作符无法重载：
作用域限定操作符：“：：”
直接成员访问操作符：“.”
直接成员指针解引用操作符：“.*”
条件操作符：“？”
字节长度操作符：“sizeof( )”
类型信息操作符：“typeid”
2）如果一个操作符所有的操作数都是基本类型，则无法重载
3）操作符重载不会改变编译器预定义的优先级
4）操作符重载无法改变操作数的个数
5）无法通过操作符重载发明新的操作符
6）操作符重载完全可以用普通成员函数来替换
一、继承（重点）！！！！（Inheritance）
1、继承的基本概念
通过一种机制表达类型之间共性和特性的方式，利用已有数据类型定义新的数据类型，这种机制就是继承。
人类：姓名、年龄、吃饭、睡觉
学生类：姓名、年龄、学号、吃饭、睡觉、学习
教师类：姓名、年龄、工资、吃饭、睡觉、讲课
人类：姓名、年龄、吃饭、睡觉
学生类继承人类：学号、学习
教师类继承人类：工资、讲课
人类（基类/父类）
/ \
学生类 教师类（派生类/子类）
基类派生子类，子类继承基类
2、继承的语法形式
class 子类：继承方式1 基类1，继承方式2，基类2……{
…..
}
继承方式：
public ：公有继承
protected ：保护继承
private：私有继承
class Human{};
class Student:public Human{
//Student类继承了Human类
//Student类存在一份Human中的成员
}；
举例
#include<iostream>
using namespace std;
//人类（基类）
class Human{
public:
Human(const string& name,int age)
:m_name(name),m_age(age){}//初始化
void eat(const string& food)const{//常函数(const *this)不需要修改成员变量
cout<<"我在吃"<<food<<endl;
}
void sleep(int time)const{
cout<<"我睡了"<<time<<"小时"<<endl;
}
protected: //保护成员可以在子类中访问，外部不能访问
string m_name;
int m_age;
};
//学生类（人类派生的子类）
class Student:public Human{
public:
Student(const string& name,int age,int no):
Human(name,age),m_no(no){}//初始化
void who(void)const{//不修改成员变量的都尽量使用常函数
cout<<"我叫"<<m_name<<",今年"<< \
m_age<<"岁，学号"<<m_no<<endl;
}
void learn(const string& course)const{
cout<<"我在学"<<course<<endl;
}
private:
int m_no;
};
//教师类（人类派生的另外一个子类）
class Teacher:public Human{
public:
Teacher(conststring& name,int age,double salary):
Human(name,age),m_salary(salary){}
void teach(const string& course)const{
cout<<"我在讲"<<course<<endl;
}
void who(void)const{
cout<<"我叫"<<m_name<<",今年"<< \
m_age<<"岁，工资："<<m_salary<<endl;
}
private:
double m_salary;
};
int main(void){
Student s("悟空",30,10001);
s.who();
s.eat("桃子");
s.sleep(8);
s.learn("打坐");
Teacher t("唐僧",31,5000.5);
t.who();
t.eat("蔬菜");
t.sleep(6);
t.teach("佛法");
return 0;
}
tarena@tarena-virtual-machine:~/day42$./a.out
我叫悟空,今年30岁，学号10001
我在吃桃子
我睡了8小时
我在学打坐
我叫唐僧,今年31岁，工资：5000.5
我在吃蔬菜
我睡了6小时
我在讲佛法
3、公有继承的特性
3、1共同性：任何时候子类对象都可以看做是一个基类对象
3、2向上造型（重点）
将子类类型的指针或引用转换成基类类型的指针或引用。
（将学生类型转换成老师类型）
这种转换缩小了指针或引用操作范围，在编译看来是安全的，所以可以隐式转换。
#include<iostream>
using namespace std;
//人类（基类）
class Human{
public:
Human(const string& name,int age)
:m_name(name),m_age(age){}//初始化
void eat(const string& food)const{//常函数(const *this)不需要修改成员变量
cout<<"我在吃"<<food<<endl;
}
void sleep(int time)const{
cout<<"我睡了"<<time<<"小时"<<endl;
}
protected: //保护成员可以在子类中访问，外部不能访问
string m_name;
int m_age;
};
//基类子对象：子类对象中包含基类的部分
//学生类（人类派生的子类）
class Student:public Human{
public:
Student(const string& name,int age,int no):
Human(name,age),m_no(no){}//初始化
void who(void)const{//不修改成员变量的都尽量使用常函数
cout<<"我叫"<<m_name<<",今年"<< \
m_age<<"岁，学号"<<m_no<<endl;
}
void learn(const string& course)const{
cout<<"我在学"<<course<<endl;
}
private:
int m_no;
};
//教师类（人类派生的另外一个子类）
class Teacher:public Human{
public:
Teacher(const string& name,int age,double salary):
Human(name,age),m_salary(salary){}
void teach(const string& course)const{
cout<<"我在讲"<<course<<endl;
}
void who(void)const{
cout<<"我叫"<<m_name<<",今年"<< \
m_age<<"岁，工资："<<m_salary<<endl;
}
private:
double m_salary;
};
int main(void){
Student s("悟空",30,10001);
s.who();
s.eat("桃子");
s.sleep(8);
s.learn("打坐");
Teacher t("唐僧",31,5000.5);
t.who();
t.eat("蔬菜");
t.sleep(6);
t.teach("佛法");
//向上造型，缩小了指针的操作范围，所以安全，可以做隐式类型转换
//（12个字节只访问前8个字节，安全！）
Human* ph=&s; //ph指向子类对象的基类指针
ph->eat("桃");//可以访问基类中有的部分
ph->sleep(10);//可以访问基类中有的部分
//ph->who();
return 0;
}
图：向上造型
练习：M33矩阵类让它增加支持如下操作符：
前后++ 前后-- 取负（让无参构造对象减去有参构造对象）、取下标[ ]值
arr[1][1]=>*(arr+1)[1]=>*(*(arr+1)+1)
#include <iostream>
#include <iomanip>//setw()设置域宽
using namespace std;
class M33{
public:
M33(void){
for(inti=0; i<3; i++)
for(intj=0; j<3; j++)
m_a[i][j]= 0;
}
M33(inta[][3]){
for(inti=0; i<3; i++)
for(intj=0; j<3; j++)
m_a[i][j]= a[i][j];
}
friendostream& operator<<(ostream& os,
constM33& m){
for(inti=0; i<3; i++){
for(intj=0; j<3; j++)
os<< setw(4) << m.m_a[i][j];
os<< endl;
}
returnos;
}
//+- *:返回值右值，左右操作数可以右值也可
//以为左值
constM33 operator+(const M33& m)const{
inta[3][3]={};
for(inti=0; i<3; i++)
for(intj=0; j<3; j++)
a[i][j]=m_a[i][j]+m.m_a[i][j];
returna;
}
constM33 operator-(const M33& m)const{
inta[3][3]={};
for(inti=0; i<3; i++)
for(intj=0; j<3; j++)
a[i][j]=m_a[i][j]-m.m_a[i][j];
returna;
}
constM33 operator*(const M33& m)const{
inta[3][3]={};
for(inti=0; i<3; i++)
for(intj=0; j<3; j++)
for(intk=0; k<3; k++)
a[i][j]+=
m_a[i][k]*m.m_a[k][j];
returna;
}
//+=-= *=:返回值左值，左操作数必须是左值，右
//操作数可以为左值也可以为右值
M33&operator+=(const M33& m){
return*this = *this + m;
}
M33&operator-=(const M33& m){
return*this = *this - m;
}
M33&operator*=(const M33& m){
return*this = *this * m;
}
constM33 operator-(void)const{
returnM33() - *this;
}
//前++ --，操作数左值，返回值左值
M33&operator++(void){
for(inti=0; i<3; i++)
for(intj=0; j<3; j++)
++m_a[i][j];
return*this;
}
M33&operator--(void){
for(inti=0; i<3; ++i)
for(intj=0; j<3; j++)
--m_a[i][j];
return*this;
}
//后++ --，操作符左值，返回值右值
constM33 operator++(int){
M33m = *this;
++*this;
returnm;
}
constM33 operator--(int){
M33m = *this;
--*this;
returnm;
}
int*operator[](int i){
returnm_a[i];
}
constint* operator[](int i)const{
//复用上面的版本
returnconst_cast<M33&>(*this) [i];
}
private:
intm_a[3][3];
};
int main(void)
{
inta1[3][3]={1,2,3,4,5,6,7,8,9};
inta2[3][3]={9,8,7,6,5,4,3,2,1};
M33m1(a1);
M33m2(a2);
cout<< "-m2:" << endl;
cout<< -m2 << endl;
cout<< "++m2:" << endl;
cout<< ++m2 << endl;
cout<< m2 << endl;
cout<< "--m2:" << endl;
cout<< --m2 << endl;
cout<< m2 << endl;
cout<< "m2++:" << endl;
cout<< m2++ << endl;
cout<< m2 << endl;
cout<< "m2--:" << endl;
cout<< m2-- << endl;
cout<< m2 << endl;
cout<< "下标:"<< endl;
for(inti=0;i<3;i++){
for(intj=0;j<3;j++)
m2[i][j]+= 10;
}
cout<< m2 << endl;
constM33& cm = m2;
//cm[1][1]= 20;//error
return0;
}
