C++实验报告四运算符的重载模板与STL.docx
《C++实验报告四运算符的重载模板与STL.docx》由会员分享，可在线阅读，更多相关《C++实验报告四运算符的重载模板与STL.docx（30页珍藏版）》请在冰豆网上搜索。
C++实验报告四运算符的重载模板与STL
课程实验报告
课程名称
C++
班级
实验日期
姓名
学号
实验成绩
实验名称
C++：
运算符的重载、模板与STL
实
验
目
的
及
要
求
运算符重载
1、类中运算符重载
2、友元函数重载
3、特殊运算符的重载
模板与STL
1、函数模板与模板函数
2、类模板与模板类的应用
3、STL容器与迭代器
实
验
环
境
Dev-C++
实
验
内
容
运算符重载
1、类中运算符重载
2、友元函数重载
3、特殊运算符的重载
模板与STL
1、函数模板与模板函数
2、类模板与模板类的应用
3、STL容器与迭代器
算
法
描
述
及
实
验
步
骤
运算符重载
1、类中运算符重载（以负号运算符重载为例）
文件1：
Coordinate.h
#ifndefCOORDINATE_H
#defineCOORDINATE_H
#include
usingnamespacestd;
classCoordinate{
public:
Coordinate（intx,inty）;
Coordinate&operator-（）;
intgetX（）;
intgetY（）;
private:
intm_iX;intm_iY;
};
#endif
文件2：
Coordinate.cpp
#include"Coordinate.h"
Coordinate:
:
Coordinate（intx,inty）{
m_iX=x;m_iY=y;
}
intCoordinate:
:
getX（）{
returnm_iX;
}
intCoordinate:
:
getY（）{
returnm_iY;
}
Coordinate&Coordinate:
:
operator-（）{
m_iX=-m_iX;
this->m_iY=-this->m_iY;
return*this;//返回值为引用，所以要加this的指针
}
文件3：
Demo.cpp
#include"Coordinate.h"
#include
usingnamespacestd;
/*运算符重载—一元运算符重载
要求：
定义Coordinate坐标类
成员函数：
构造函数、getX、getY
数据成员：
m_iX、m_iY
*/
intmain（）{
Coordinatecoor1（1,3）;
cout<-coor1;//coor1.operator-（）;
cout<system（"pause"）;
return0;
}
2、友元函数重载（以负号运算符友元函数重载为例）
File1：
Coordinate.h
#ifndefCOORDINATE_H
#defineCOORDINATE_H
#include
usingnamespacestd;
classCoordinate{
friendCoordinate&operator-（Coordinate&c）;
//写&c是为了其传递的效率
public:
Coordinate（intx,inty）;
intgetX（）;
intgetY（）;
private:
intm_iX;intm_iY;
};
#endif
File2：
Coordinate.cpp
#include"Coordinate.h"
Coordinate:
:
Coordinate（intx,inty）{
m_iX=x;m_iY=y;
}
intCoordinate:
:
getX（）{
returnm_iX;
}
intCoordinate:
:
getY（）{
returnm_iY;
}
Coordinate&operator-（Coordinate&c）{
c.m_iX=-c.m_iX;
c.m_iY=-c.m_iY;
returnc;//返回值为Coordinate&
}
File3：
Demo.cpp
#include"Coordinate.h"
#include
usingnamespacestd;
/*运算符重载—一元运算符重载
要求：
定义Coordinate坐标类
成员函数：
构造函数、getX、getY
数据成员：
m_iX、m_iY
1、负号运算符重载（成员函数、友元函数）
*/
intmain（）{
Coordinatecoor1（1,3）;
cout<-coor1;
cout<system（"pause"）;
return0;
}
3、特殊运算符的重载（++运算符重载（前置++、后置++））
File1：
Coordinate.h
#ifndefCOORDINATE_H
#defineCOORDINATE_H
#include
usingnamespacestd;
classCoordinate{
friendCoordinate&operator-（Coordinate&c）;
//写&c是为了其传递的效率
public:
Coordinate（intx,inty）;
Coordinate&operator++（）;
intgetX（）;
intgetY（）;
private:
intm_iX;intm_iY;
};
#endif
File2：
Coordinate.cpp
#include"Coordinate.h"
Coordinate:
:
Coordinate（intx,inty）{
m_iX=x;m_iY=y;
}
intCoordinate:
:
getX（）{
returnm_iX;
}
intCoordinate:
:
getY（）{
returnm_iY;
}
Coordinate&Coordinate:
:
operator++（）{
m_iX++;//++m_iX;
m_iY++;//++m_iY;
return*this;
}
File3：
Demo.cpp
#include
usingnamespacestd;
intmain（）{
Coordinatecoor1（1,3）;
cout<++coor1;
cout</*-coor1;
cout<system（"pause"）;
return0;
}
4、特殊运算符的重载（++运算符重载（后置++））
文件1：
Coordinate.h
#ifndefCOORDINATE_H
#defineCOORDINATE_H
#include
usingnamespacestd;
classCoordinate{
friendCoordinate&operator-（Coordinate&c）;
public:
Coordinate（intx,inty）;
Coordinate&operator++（）;
Coordinateoperator++（int）;
//++放在后面特点：
当前表达式使其++之前的值
//下一行代码再去访问时才是++之后此对象的值
intgetX（）;
intgetY（）;
private:
intm_iX;intm_iY;
};
#endif
文件2：
Coordinate.cpp
#include"Coordinate.h"
Coordinate:
:
Coordinate（intx,inty）{
m_iX=x;m_iY=y;
}
intCoordinate:
:
getX（）{
returnm_iX;
}
intCoordinate:
:
getY（）{
returnm_iY;
}
Coordinate&Coordinate:
:
operator++（）{
m_iX++;//++m_iX;
m_iY++;//++m_iY;
return*this;
}
CoordinateCoordinate:
:
operator++（int）{
Coordinateold（*this）;//拷贝构造函数
this->m_iX++;
this->m_iY++;
returnold;
}
文件3：
Demo.cpp
#include"Coordinate.h"
#include
usingnamespacestd;
/*运算符重载—一元运算符重载
要求：
定义Coordinate坐标类
成员函数：
构造函数、getX、getY
数据成员：
m_iX、m_iY
++运算符重载（后置++）
*/
intmain（）{
Coordinatecoor1（1,3）;
cout<cout<<（coor1++）.getX（）<<",";//（coor1++）.getX（）是++之前的值
cout<<（coor1++）.getY（）</*-coor1;
cout<system（"pause"）;
return0;
}
定义Coordinate类
数据成员：
m_iX,m_iY
成员函数：
构造函数
重载“--”运算符，重载“+”运算符
====================================
#include
usingnamespacestd;
/**
*定义Coordinate类
*数据成员：
m_iX，m_iY
*成员函数：
构造函数
*重载--运算符，重载+运算符
*/
classCoordinate
{
public:
Coordinate（intx,inty）
{
m_iX=x;
m_iY=y;
}
//前置--运算符重载
Coordinate&operator--（）{
m_iX--;m_iY--;
return*this;
}
//后置--运算符重载
Coordinateoperator--（int）{
Coordinateold（*this）;
this->m_iX--;m_iY--;
returnold;
}
//+号运算符重载
Coordinateoperator+（constCoordinate&coor）{
Coordinatetemp（0,0）;
temp.m_iX=this->m_iX+coor.m_iX;
temp.m_iY=this->m_iY+coor.m_iY;
returntemp;
}
public:
intm_iX;
intm_iY;
};
intmain（void）
{
Coordinatecoor1（1,3）;
Coordinatecoor2（2,4）;
Coordinatecoor3（0,0）;
coor1--;
--coor2;
coor3=coor1+coor2;
cout<cout<return0;
}
模板与STL
1、函数模板与模板函数
例1：
#include
#include
usingnamespacestd;
/*函数模板：
要求定义函数模板display（）;
*/
//模板函数1
template//最好用typename
voiddisplay（Ta）{//T类型的参数
cout<}
//模板函数2
template//带两个参数的模板
voiddisplay（Tt,Ss）{//用t、s当其变量
cout<cout<}
//模板函数3
template//定义一个类型参数和一个变量（变量实例化后就变成常量）
voiddisplay（Ta）{
for（inti=0;icout<}
}
//以上为模板函数
intmain（）{
display（10）;//模板函数1的函数模板1
display（10.75）;//模板函数1的函数模板2
display（5,8.3）;//模板函数2
display（6）;//模板函数3
system（"pause"）;
return0;
}
例二：
#include
usingnamespacestd;
/**
*定义模板函数swapNum
*实现功能：
交换两个数的位置
*/
template
voidswapNum（T&a,T&b）
{
Ttemp=a;
a=b;
b=temp;
}
intmain（void）
{
intx=10;
inty=20;
//调用模板函数
swapNum（x,y）;
cout<<"x="<cout<<"y="<return0;
}
2、类模板与模板类的应用
文件1:
MyArray.h
#ifndefMYARRAY_H
#defineMYARRAY_H
#include
usingnamespacestd;
template
classMyArray{
public:
MyArray（）;
~MyArray（）{
delete[]m_pArr;
m_pArr=NULL;
}
voiddisplay（）;
private:
T*m_pArr;
};
//若要定义类的模板，必须将类的声明及定义写在同一个文件中
template//*template+模板参数列表
MyArray:
:
MyArray（）{//类名后记得写上参数名字
m_pArr=newT[KSize];
for（inti=0;im_pArr[i]=KVal;
}//构造函数中我们将其定义为数组，并给元素进行了赋值操作
}
template//类外定义必加
voidMyArray:
:
display（）{
for（inti=0;icout<}
}
#endif
文件2:
MyArray.cpp
#include"MyArray.h"
文件3:
Demo.cpp
#include
#include
#include"MyArray.h"
usingnamespacestd;
intmain（）{
//将模板类实例化成类模板：
MyArrayarr;
//列表中参数顺序不能变:
T,KSize,KVal
//上述模板类被实例化成类模板后，定义了一个对象arr
arr.display（）;
system（"pause"）;
return0;
}
3、STL容器与迭代器
#include
#include
#include
#include
usingnamespacestd;
intmain（void）
{
//使用vector存储数字：
3、4、8、4
vectorvec;
vec.push_back（3）;
vec.push_back（6）;
vec.push_back（4）;
vec.push_back（8）;
//循环打印数字
vector:
:
iteratoritor;
for（itor=vec.begin（）;itor!
=vec.end（）;itor++）{
cout<<*itor<}
//使用map来存储字符串键值对
mapm;
pairp1（"S","SHANGHAI"）;
pairp2（"B","BEIJING"）;
pairp3（"G","GUANGZHOU"）;
m.insert（p1）;
m.insert（p2）;
m.insert（p3）;
map:
:
iteratoritor1;
//打印map中数据
for（itor1=m.begin（）;itor!
=m.end（）;itor++）{
cout<first<cout<second<}
return0;
}
调
试
过
程
及
实
验
结
果
运算符重载
1、类中运算符重载（以负号运算符成员函数重载为例）
2、友元函数重载（以负号运算符友元函数重载为例）
3、特殊运算符的重载（++运算符重载（前置++））
4、特殊运算符的重载（++运算符重载（后置++））
模板与STL
1、函数模板与模板函数
（例一）
（例二）
2、类模板与模板类的应用：
总
结
运算符的重载：
（以下代码仅为说明总结知识点，并不完整，具体编程示例见面两版块）
概念：
给原有的运算符赋予新的功能；（eg:
+是用于两个数字相加，我们会用+做两个字符串的拼接：
+的重载）
例1：
intmain（）{
stringstr1（"jamed"）;
stringstr2（"yuan"）;
stringstr3=str1+""+str2;//用+连多个字符串，使其拼接为一个串
cout<return0;
}
本质：
函数重载
关键字：
operator
一元运算符重载例子：
-（负号）的重载++符号的重载
（一元：
此符号只与一个操作数进行运算，+为二元运算符）
-（负号）的重载：
友元函数重载、成员函数重载
例2：
（-（负号）成员函数的重载）
classCoordinate{//定义
public:
Coordinate（intx,inty）;
Coordinate&operator-（）;
private:
intm_iX;intm_iY;
};
Coordinate&Coordinate:
:
operator-（）{//实现
m_iX=-m_ix;m_iY=-m_iY;
return*this;
}
intmain（）{//使用
Coordinatecoor1（3,5）;//先定义Coordinate对象
-coor1;//coor1.operator-（）;
//在对象前加-，此对象中所有值均取反
return0;
}
//语法：
类名&+operator+运算符+（）;
例3：
（-（负号）友元函数的重载）
classCoordinate{
friendCoordinate&operator-（Coordinate&coor）;
public:
Coordinate（inrx,inty）;
private:
intm_iX;intm_iY;
};
Coordinate&operator-（Coordinate&coor）{
coor.m_iX=-coor.m_iX;
coor.m_iY=-coor.m_iY;
return*this;
}
intmain（）{
Coordinatecoor1（3,5）;
-coor1;//operator-（coor1）;
return0;
}
++符号的重载：
前置++符号重载、后置++符号重载
例4：
++运算符的重载—前置
classCoordinate{
public:
Coordinate（inrx,inty）;
Coordinate&operator++（）;//前置++
private:
intm_iX;intm_iY;
};
Coordinate&Coordinate:
:
operator++（）{
m_iX++;m_iY++;
return*this;
}
intmain（）{
Coordinatecoor1（3,5）;
++coor1;//coor1.operator++（）;
return0;
}
例5：
++运算符的重载—后置
cla
升级会员 