如何使用类和对象

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

一.利用构造函数对类对象进行初始化

对象初始化

不能在类声明中对数据成员初始化，如class Time{hour=0；}；错误

若一个类中所有成员都是公用的，可以在定义对象时初始化（如果有私有的数据成员就不可以用）

class Time
{public:
hour;
minute;
sec;
};
Time t1={14，56，30}；

构造函数 实现数据成员初始化

• 构造函数的函数名与类名相同

#include<iostream>
using namespace std;
class Time
{
	public:
		Time()//**定义 构造成员函数，函数名与类名相同**
		{
			hour=0;
			minute=0;
			sec=0;
		}
		.......
 } 

注：

1. c++提供了 构造函数 来处理对象的初始化。构造函数是一种特殊的成员函数，不需要用户来调用它，而是在建立对象时自动执行
2. 构造函数没有返回值，因此也没有类型，它的作用只是对对象进行初始化
3. 构造函数不能被用户调用。t1.Time（）；错误
4. 用一个类对象初始化另一个类对象Time t1; Time t2=t1;把对象t1的数据成员值复制到t2

带参数的构造函数

构造函数名（形参1，形参2…)

例 求体积（编写一个程序，在类中用带参数的构造函数对数据成员初始化）

#include<iostream>
using namespace std;
class Box
{
	public:
		Box(int,int,int)//声明带参数的构造函数
		int volume();
	private:
		int height;
		int width;
		int length;
};
Box::Box(int h,int w,int len)//在类外定义带参的构造函数
{
	height=h;
	width=w;
	length=len;
 } 
 int Box::volume()//计算体积的函数
 {
 	return(height*width*length); 
 }
 int main()
 {
 	Box boxl(12,25,30);
 	cout<<boxl.volume() <<<endl;
 	return 0;
 }

参数初始化表 对数据成员初始化

形式：Box::Box(int h,int w,int len):height(h),width(w),length(len) {}

构造函数的重载

在一个类中可以定义多个构造函数，以便为对象提供不同的初始化方法。
这些构造函数具有相同的名字，而参数的个数或类型不相同。

默认参数

应在声明构造函数时指定默认值，而不能只在定义构造函数时指定指定默认值。
一个类只能有一个默认构造函数

二. 析构函数

1. 析构函数也是一个特殊的成员函数，它的作用与构造函数相反，名字是类名前加一个“~”
2. 析构函数的作用并不是删除对象，而是在撤销对象占用的内存之前完成一些清理工作
3. 一个类只能有一个析构函数，且不可以重载
4. 当对象的生命期结束时，会自动执行析构函数

注：先构造的后析构，后构造的先析构。相当于栈，先进后出。

三. 对象数组

例如：Student stud[50];//假设已经声明了student类，定义stud数组，有50个元素

例 输出3个立方体体积，用对象数组方法

#include<iostream>
using namespace std;
class Box
{
	public:
		Box(int h=10,int w=12,int len=15):height(h),width(w),length(len){}
		//声明有默认参数的构造函数，用参数初始化表对数据成员初始化
		int volume();
	private :
		int height;
		int width;
		int length;
};
int Box::volume ()
{
	return (height*width*length)
}
int main()
{
	Box a[3]={  //定义对象数组
	Box(10,12,15),
	Box(15,18,20),
	Box(3,54,23)
	};
	cout<<a[0].volume() <<endl;
	cout<<a[1].volume() <<endl;
	cout<<a[2].volume() <<endl;
	return 0;
}

四. 对象指针

指向对象的指针

Time *pt;//定义pt为指向Time类对象的指针
Time t1;//定义对象
pt=&t1;//将t1地址赋给pt

形式：类名*对象指针名

指向对象数据成员的指针

int*p1;
p1=&t1.hour;
cout<<*p1<<endl;

指向对象成员函数的指针

数据类型名（类名::*指针变量名）（参数表列）；
void(Time::*p2)();
指针指向公用的成员函数：指针变量名=&类名::成员函数名；p2=&Time::get_time;

#include<iostream>
using namespace std;
class Time
{
	public:
	Time (int,int,int);
	int hour;
	int minute;
	int sec;
	void get_time(); //声明公有成员函数
};
Time::Time(int h,int m,int s)//定义结构成员函数
{
	hour=h;
	minute=m;
	sec=s;
 } 
 void Time::get_time()
 {
 	cout<<hour<<":"<<minute<<":"<<sec<<endl;
 }
 int main()
 {
 	Time t1(10,13,56);定义Time类对象，并初始化
 	int*p1=&t1.hour ;
 	cout<<*p1<<endl;
 	t1.	get_time() ;
 	Time*p2=&t1;//定义指向Time类的指针变量p2，并使之指向t1 
 	p2->get_time();//调用p2指向的t1的get_time函数 
 	void(Time::*p3)();//定义指向Time类公用成员函数的指针变量 
 	p3=&Time::get_time;//p3指向函数get_time 
 	(t1.*p3)();//调用对象t1中p3所指向的成员函数（即t1.get_time()) 
 }
运行结果：
10   主函数第4行输出结果
10：13：56   第5行
10：13：56   第7行
10：13：56   第10行

8,9行也可以合写成一行：void(Time::*p3)()=&Time::get_time;

this指针

它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。
j假设this指向找到对象a的数据成员，计算height*width*length，实际上执行（this->height）*（this->width)*(this->length)，由于this指向a也相当于（a.height)*(a.width)*(a.length)

五.共用数据的保护

常对象

类名 const 对象名（实参表）Time const t1(12,34,46);

1. 常对象必须要有初值
2. 常对象只能调用它的常成员函数，不能调用该对象的普通成员函数
3. 常成员函数能访问常对象的数据成员，不可以修改值

常对象成员

1. 常数据成员：只能通过构造函数的参数初始化表对常数据成员进行初始化。Time::Time(int h):hour(h){}//对hour初始化
2. 常成员函数：类型名 函数名（参数表）const
   void get_time()const

指向对象的常指针

将指针变量声明为const类型，这样指针常量保持初值，即其指向不变。

形式：类名*const 指针变量名；Time*const p1=&t1;//指定p1指向t1

指向常对象的指针变量

1. 如果一个对象已被声明为常对象，只能用指向常对象的指针变量指向
2. 不能通过指针变量改变其指向的对象

Time t1(10,12,15);//定义Time类对象t1，是非const型对象
const Time *p=&t1;//定义p是指向常对象的指针变量，指向t1
t1.hour=18;//合法，t1不是常变量
(*p).hour=18;//不合法，不能通过指针变量改变t1的值

注意区别

Time *const p;//指向对象的常指针变量
const Time*p;//指向常对象的指针变量

记住这样一条规则：当希望在调用函数时对象的值不被修改，就应当把形参定义为指向常对象的指针变量，同时用对象的地址作为实参。

对象的常引用

void fun(Time&t)//形参t是Time类对象的引用
{t.hour=18;}
int main{Time t1(10,12,13);fun(t1);//实参是Time类对象，可以通过引用来修改实参的引用

如果不希望修改实参t1的值，可以把fun函数的形参t声明为const（常引用）void fun(const Time&t);

const型数据小结

形式	含义
Time const t；	t是常对象，其值在任何条件下不能改变
void Time::fun()const;	fun是Time类中的常成员函数，可以引用，但不能修改本类的数据成员
Time*const p;	p是指向Time类的常指针变量，p的指向不能变
const Time*p；	p是指向Time 类常对象的指针变量，p指向的类对象的值不能通过p来改变
const Time&t1=t；	t1是Time类对象t的引用，二者指向同一存储空间，t的值不能改变

六 对象的赋值与复制

赋值

实际上通过成员复制来完成，即将一个对象的成员值一一复制给另一个对象的对应成员。
一般形式：对象名1=对象名2；
对象的赋值只对其中数据成员的赋值，

复制

一般形式：类名 对象2（对象1）；//用对象1复制出对象2
执行时，调用的复制构造函数。
声明复制构造函数类名（类名&对象名）;Box（Box&b);

两者区别：赋值是对一个已经存在的对象赋值，因此必须先定义被赋值的对象；复制则是从无到有建立一个新对象，并使它与一个已有的对象完全相同（包括对象的结构和成员的值）。

七. 静态成员

静态数据各对象中的数据成员的值是一样的，所有对象都可以用它
1、只在类体中声明时加static，如static int height；
2、静态数据成员初始化，只能在类体外。（主函数外）
3、形式：数据类型 类名：：静态数据成员名=初值；
4、在类外可以通过对象名访问公用的静态数据成员，也可以通过类名引用静态数据成员。
静态成员函数
1、静态成员函数时类的一部分而不是对象的一部分。static int fun();如果在类外调用公用的静态成员函数，要用类名和域运算符“：：",如Box::fun();
2、主要用来访问静态数据成员，若用非静态则要用"."

八. 友元

友元函数
友元函数可以访问这个类中的私有成员。

简单例子（输出时间）

#include<iostream>
using namespace std;
class Time 
{
	public:
		Time (int,int,int);//声明构造函数 
		friend void display(Time &);//声明display函数为Time类的友元函数 
	private:
		int hour;
		int minute;
		int sec;
};
Time::Time(int h,int m,int s)//定义构造函数，赋初值 
{
	hour=h;
	minute=m;
	sec=s;
  } 
void display(Time&t)
{
	cout<<t.hour<<":"<<t.minute<<":"<<t.sec<<endl;
 } 
 int main()
 {
 	Time t1(12,13,23);
 	display(t1);
 	return 0;
 }

diplay是一个在类外定义且未用类Time作限定的函数， 如果不是友元函数，则它不能引用私有成员hour，minute，sec。引用时不要忘记加上对象名

友元成员函数
friend函数不仅可以是一般函数（非成员函数），也可以是另一个类中的成员函数。

#include<iostream>
using namespace std;
class Date;//**提前引用**对Date类的提前引用声明
class Time
{
	public:
		Time(int,int,int);
		void display(Date&);//display是成员函数，形参是Date类对象的引用
	private:
		int hour ;
		int minute;
		int sec;
 } ;
 class Date
 {
 	public:
 		Date(int,int,int);//声明构造函数
 		friend void Time::display(Date&);//声明Time中的display函数为本类的友元成员函数 
		private:
		int month;
		int day;
		int year; 
 };
 Time::Time(int h,int m,int s)//定义Time类的构造函数
 {
 	hour=h;minute=m;sec=s;
  } 
void Time::display(Date&d)//diplay 的作用是输出年月日，时分秒 
{
	cout<<d.month<<"/"<<d.day<<"/"<<d.year<<endl;//引用Date类中的私有数据
	cout<<hour<<":"<<minute<<":"<<sec<<endl;//引用本类对象中的私有数据
 } 
Date::Date(int m,int d,int t)
{
	month=m;day=d;year=y;
 } 
int main()
{
	Time t1(10,13,56);
	Date(12,25,2021);
	t1.display(d1) ;//调用t1中的display函数，实参是Date类对象d1 
	return 0;
}

友元类
可以将一个类声明为另一个类的“朋友”，如B类是A类的友元类，友元类B中的所有函数都是A类的友元函数，可以访问A类中的所有成员。
在A类的定义体中用friend B；声明B类为其友元类。

1. 友元的关系是单向的。
2. 友元的关系不能传递，b类是a类的友元类，c类是b类的友元类，但c类不是a类的友元类。

九 .类模板

1、 声明类模板: template<class 类型参数名>
2、变成实际的类，去定义对象：
3、 类模板名<实际类型名>对象名（参数表）
Comparecmp(3,4)
4、类模板外定义成员函数。
template<class 虚拟类型参数>
函数类型 模板名<虚拟参数类型>::成员函数名（函数形参表）{…}

template<class numptype>
numtype Compare<numtype>::max()
{return(x>y)?x:Y;}

例

template<class numtype>
class Compare
{
	public:
	Compare(numtype a,numtype b)
	{x=a;y=b;}//定义构造函数
	........
	private:....;
 } ;
 int main
 {
     Compare<int>cmpl(3,4);//定义对象cmpl
     ...........
 }