对象的使用

目录

5.3.1 对象指针

5.3.2 对象引用

5.3.3 对象数组

5.3.4 动态对象

5.3.5 this指针

5.3.6 组合对象

---

 

5.3.1 对象指针

（1）定义： 对象如同一般的变量，占用一块连续的内存区域，因此可以用对象指针，指向存放该对象的地址。 

（2）定义形式：类名 * 对象指针名

ps：建立对象指针并没有建立对象，所以此时不调用构造函数。

（3）对象指针用“->”访问该类的公有数据成员和函数成员。其语法形式如下：

对象指针名->数据成员名 / 对象指针名-> 成员函数名（参数表）

例如

Clock C1 (8,0,0);
Clock *Cp;
Cp= &C1;
Cp->ShowTime();

//实战

//带时间加法的时钟类 

#include <iostream>
using namespace std;
class Clock{
	private:
		int H,M,S;
	public:
		void SetTime(int h,int m,int s){
			H=h,M=m,S=s;
		}
		void ShowTime(){
			cout<<H<<":"<<M<<":"<<S<<endl;
		}
		Clock(int h=0,int m=0,int s=0){
			H=h,M=m,S=s;
		}//默认初始化
		Clock(Clock &p){//拷贝构造函数 
			H=p.H,M=p.M,S=p.S; 
		} 
		void TimeAdd(Clock *Cp);
		void TimeAdd(int h,int m,int s);
		void TimeAdd(int s);//函数的重载 
}; 
void Clock::TimeAdd(Clock *Cp){

	H=(Cp->H+H+(Cp->M+M+(Cp->S+S)/60)/60)%24;
	M=(Cp->M+M+(Cp->S+S)/60)%60;
	S=(Cp->S+S)%60;
}
void Clock::TimeAdd(int h,int m,int s){
	
	H=(H+h+(m+M+(s+S)/60)/60)%24; 
	M=(m+M+(s+S)/60)%60;
	S=(s+S)%60;
}
void Clock::TimeAdd(int s)
{
	H=(H+(M+(S+s)/60)/60)%24;
	M=(M+(s+S)/60)%60;
	S=(s+S)%60;
}

int main() {
	Clock C1;
	Clock C2(8,20,20);
	C1.ShowTime();
	C1.TimeAdd(4000);
	C1.ShowTime();
	C2.TimeAdd(&C1);
	C2.ShowTime();
	
	return 0;
}

 运行如下：

0：0：0

1: 60: 40

9: 27: 0

---

5.3.2 对象引用

（1）对象引用就是对某类对象定义一个引用，其实实质就是通过将被引用对象的地址赋给引用对象，使二者指向同一个空间，就这样引用对象就成为了被引用对象的别名（引用是一种特殊的指针）

（2）定义形式：类名& 对象引用名=被引用对象

（3）对象引用不仅拥有指针的优点，还比指针更简洁，方便。其语法形式如下：

对象引用.数据成员名 / 对象引用。成员函数名（参数表）

例如

Clock C1(8,0,0);
Clock& Cr = C1;
Cr.ShowTime();

---

5.3.3 对象数组

（1）定义：对象数组使以对象为元素的数组

（2）对象数组的初始化需要使用构造函数完成，不带初始化表的对象数组，其初始化靠调用不带参数的构造函数完成。

（3）以m维数组为例，对象数组存取的格式如：
数组名[下标表达式1][下标表达式2]....[下标表达式m].数据成员 或 数组名[下标表达式1][下标表达式2...][下标表达式m].成员函数名（参数表）

实例如下

//求一个班学生某门功课的总评成绩 

#include <iostream>
using namespace std;
const int MaxN = 100;
const double Rate = 0.6;//平时成绩比例
class Score{
	private:
		long No;//学号
		char * Name;//姓名
		int Usual;//平时成绩 
		int Final;//期末考试成绩 
		int Total; //总成绩
	public:
	    Score(long=0,char * = NULL,int =0,int =0,int =0);//构造函数 
		void Count();
		void ShowScore(); 
}; 
Score::Score(long no,char * name,int usual,int final,int total){
	No=no;
	Name = name;
	Usual=usual;
	Final=final;
	Total=total;
}
void Score::Count(){
	Total=Usual*Rate+Final*(1-Rate); 
}
void Score::ShowScore(){
	cout<<No<<"\t"<<Name<<"\t"<<Usual<<"\t"<<Final<<"\t"<<Total<<endl;
}


int main() {
	Score ClassScore1[3]={Score(2023,"Xuya",80,90),Score(2024,"Yu song rong",75,90),Score(2025,"Yi jia ning",100,80)};
	for(int i=0;i<3;i++){
		ClassScore1[i].Count();
	}
	for(int i=0;i<3;i++){
		ClassScore1[i].ShowScore();
	}

	return 0;
}

---

5.3.4 动态对象

（1）定义：动态对象是指编程者随时动态建立并且可以随时消失的对象。

ps：函数体内的局部对象在调用函数时建立，函数调用结束后消失，全局对象则在程序执行时建立，执行完成后消失。

（2）建立动态对象采用动态申请内存的语句new，删除对象使用delete语句。形式如下：

指针对象 = new 类名（初值表）； delete 指针对象；

（3）可以用动态对象组成动态对象数组。建立 删除一个一维动态对象数组的格式如下：

对象指针 = new 类名[数组大小]；delete[]  对象指针；

例如：

Clock *Cp;//建立对象指针
Cp=new Clock;//建立动态对象，调用默认构造函数
Cp->ShowTime();//结果为0：0：0
Cp = new Clock(8,0,0);//建立动态对象，调用构造函数Clock（int，int，int）
Cp->ShowTime();//输出结果为8：0；0

 

---

5.3.5 this指针

（1）定义：在一个类的成员函数中，有时希望调用它的对象。this指针是一个系统预定义的特殊指针，指向当前对象，表示当前对象的地址。

例如：

void Clock::SetTime(int h,int m,int s)
{
 H=h,M=m,S=s;
 this->H=h,this->M=m,this->S=s;
 (*this).H=h,(*this).M=m,(*this).S=s;//以上三句等效
}

---

5.3.6 组合对象

（1）定义：类的组合用来描述一类复杂的对象，在某些类的定义中，它的属性往往时别的类的对象，也就是“一个类内嵌其他类的对象作为成员”，此成为类的组合。一个含有其他类对象的类成为组合类，组合类的对象称为组合对象。

（2）定义组合类时先定义成员类再定义组合类

实例如下：

//计算某次火车的旅途实践
// 某次火车有车次，起点站，终点站，出发时间，到达时间。可以利用 clock 对象组合一个火车旅途类TrainTrip
//假定火车均在24h内到达 

#include <iostream>
using namespace std;
class Clock{
	private:
		int H,M,S;
	public:
		void ShowTime(){
			cout<<H<<":"<<M<<":"<<S<<endl;
		}
		void SetTime(int H=0,int M=0,int S=0){
			this->H=H,this->M=M,this->S=S;
		}
		Clock(int H=0,int M=0,int S=0){//构造函数 
			this->H=H,this->M=M,this->S=S;
		}
		int GetH(){
			return H;
		}
		int GetM(){
			return M; 
		}
		int GetS(){
			return S;
		}
};
class TrainTrip{
	private:
	    char *TrainNo;//车次
		Clock StartTime;//出发时间 
		Clock EndTime; //到达时间
	public:
		TrainTrip(char * TrainNo,Clock S,Clock E){
			this->TrainNo = TrainNo;
			StartTime=S;
			EndTime = E;
		}
		Clock TripTime(){
			int tH,tM,tS;//用于临时储存
			int carry;//借位
			Clock tTime;//临时储存时间
			(tS = EndTime.GetS()-StartTime.GetS())>0?carry=0:tS+=60,carry = 1;
			(tM = EndTime.GetM()-StartTime.GetM()-carry)>0?carry=0:tM+=60,carry=1;
			(tH = EndTime.GetH()-StartTime.GetH()-carry)>0?carry=0:tH+=24;
			tTime.SetTime(tH,tM,tS);
			return tTime; 
		}
};

int main() {
	Clock C1(8,10,10),C2(6,1,2);
	Clock C3;
	TrainTrip T1("K16",C1,C2);
	C3 = T1.TripTime();
	C3.ShowTime();
	return 0;
}

运行结果为：21：50：52