类模板/友元

最新推荐文章于 2023-06-24 17:58:06 发布

—Miss. Z—

最新推荐文章于 2023-06-24 17:58:06 发布

阅读量895

点赞数 2

分类专栏： C++程序设计文章标签：类模板友元 C++

本文链接：https://blog.csdn.net/weixin_42071236/article/details/122433292

版权

C++程序设计专栏收录该内容

36 篇文章 18 订阅

订阅专栏

友元

友元可以访问与其有好友关系的类中的私有成员。友元包括友元函数和友元类。在C++中，这种关系以关键字friend声明。

友元函数

如果在本类以外的其他地方定义了一个函数(这个函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数)，在类体中用friend对其进行声明，此函数就称为本类的友元函数。友元函数可以访问这个类中的私有成员。

将普通函数声明为友元函数

例：

#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，minute，sec赋初值
{
    hour = h;
    minute = m;
    sec = s;
}
void display(Time& t) //这是友元函数，形参t是Time类对象的引用
{
    cout << t.hour << ":" << t.minute << ":" << t.sec << endl;
}
int main()
{
    Time t1(10, 13, 56);
    display(t1); //调用display函数，实参t1是Time类对象
    return 0;
}

程序分析：

display是一个在类外定义的且未用类Time作限定的函数，它是非成员函数，不属于任何类。它的作用是输出时间(时、分、秒)。如果在Time类的定义体中未声明display函数为friend函数，它是不能引用Time中的私有成员hour，minute，sec。
由于声明了display是Time类的friend函数，所以display函数可以引用Time中的私有成员hour，minute，sec。但注意在引用这些私有数据成员时，必须加上对象名。因为display函数不是Time类的成员函数，不能默认引用Time类的数据成员，必须指定要访问的对象。

友元成员函数

友元函数可以是另一个类的成员函数，称为友元成员函数。

例：

#include <iostream>
using namespace std;
class Date; //对Date类的提前引用声明
class Time //定义Time类 
{
public:
    Time(int, int, int);
    void display(const Date&); //display是成员函数，形参是Date类对象的引用
private:
    int hour;
    int minute;
    int sec;
};
class Date //声明Date类
{
public:
    Date(int, int, int); //声明Data类
    friend void Time::display(const 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(const Date& d) //display函数的作用是输出年、月、日和时、分、秒
{
    cout << d.month << "/" << d.day << "/" << d.year << endl; //引用Date类对象中私有数据
    cout << hour << ":" << minute << ":" << sec << endl; //引用本类对象中的私有数据
} 

Date::Date(int m, int d, int y) //类Date的构造函数
{
    month = m;
    day = d;
    year = y;
}

int main()
{
    Time t1(10, 13, 56); //定义Time类对象t1
    Date d1(12, 25, 2004); //定义Date类对象d1
    t1.display(d1); //调用t1中的display函数，实参是Date类对象d1
    return 0;
}

运行结果：

将上述程序中的display函数不放在Time类中，而作为类外的普通函数，然后分别在Time和Data类中将display声明为友元函数。在主函数中调用display函数，display函数分别引用Time和Data两个类的对象的私有数据，输出年、月、日和时、分、秒

#include <iostream>
using namespace std;
class Date; //对Date的声明，它是对Data的预引用
class Time //定义Time类 
{
public:
    Time(int, int, int);
    friend void display(const Date&,const Time &); //将普通函数display声明为朋友
private:
    int hour;
    int minute;
    int sec;
};
Time::Time(int h, int m, int s) //定义类Time的构造函数
{
    hour = h;
    minute = m;
    sec = s;
}
class Date //声明Date类
{
public:
    Date(int, int, int); //声明Data类
    friend void display(const Date& ,const Time&); //将普通函数display声明为朋友
private:
    int month;
    int day;
    int year;
};
Date::Date(int m, int d, int y) //类Date的构造函数
{
    month = m;
    day = d;
    year = y;
}
void display(const Date& d,const Time& t) //是Time和Data两个类的朋友
{
    cout << d.month << "/" << d.day << "/" << d.year << endl; //引用Date类对象t1中的数据成员
    cout << t.hour << ":" << t.minute << ":" << t.sec << endl; //引用Time类对象t1中的数据成员
}
int main()
{
    Time t1(10, 13, 56); //定义Time类对象t1
    Date d1(12, 25, 2004); //定义Date类对象d1
    display(d1, t1); //调用display函数，用对象名作实参
    return 0;
}

友元类

不仅可以将一个函数声明为一个类的"朋友"，而且可以将一个类(例如B类)声明为另一个类(例如A类)的"朋友"。这时B类就是A类的友元类。友元类B中的所有函数都是A类的友元函数，可以访问A类中的所有成员。
声明友元类的一般形式为：friend 类名;

将上例中的Time类声明为Data类的友元类，通过Time类中的display函数引用Data类对象的私有数据，输出年、月、日和时、分、秒

#include <iostream>
using namespace std;
class Time;
class Date
{
public:
    Date(int, int, int); //构造函数
    friend Time; //将Time类声明为朋友类
private:
    int month; //月
    int day; //日
    int year; //年
};
Date::Date(int m, int d, int y) :month(m), day(d), year(y) {}

class Time
{
public:
    Time(int, int, int); //构造函数
    void display(const Date&);
private:
    int hour; //时
    int minute; //分
    int sec; //秒
};
Time::Time(int h, int m, int s) :hour(h), minute(m), sec(s) {}

void Time::display(const Date& d)
{
    cout << d.month << "/" << d.day << "/" << d.year << endl; //引用Date类对象d1中的数据成员
    cout << hour << ":" << minute << ":" << sec << endl; //引用Time类对象t1中的数据成员
}
int main()
{
    Time t1(19, 28, 56);
    Date d1(1, 11, 2022);
    t1.display(d1);
    return 0;
}

由于Time类是Data类的友元类，因此Time类中的成员函数都是Data类的友元函数，它既可以引用Time类对象的数据成员，又可以引用Data类对象的数据成员。在引用本类(Time类)的数据成员时，不必在数据成员前面加对象名，而在引用Data类的数据成员时必须在数据成员名前加上对象名

关于友元，有两点需要说明:

友元的关系是单向的而不是双向的。如果声明了B类是A类的友元类，不等于A类是B类的友元类，A类中的成员函数不能访问B类中的私有数据
友元的关系不能传递，如果B类是A类的友元类，C类是B类的友元类，不等于C类是A类的友元类

友元利弊的分析：面向对象程序设计的一个基本原则是封装性和信息隐蔽，而友元函数却可以访问其他类的私有成员，不能不说这是对封装原则的一个小的破坏。但是它能有助于数据共享，能提高程序的效率，在使用友元时，要注意到它的副作用，不要过多地使用友元，只有在使用它能使程序精炼，较大地提高程序效率时才用友元。也就是说，要在数据共享与信息屏蔽之间选择一个恰当的平衡点。

类模板

函数模板：对于功能相同而数据类型不同的一些函数，不必一一定义各个函数，可以定义一个可对任何类型变量进行操作的函数模板，在调用函数时，系统会根据实参的类型，取代函数模板中的类型参数，得到具体的函数。
对于两个或多个类，其功能是相同的，仅仅是数据类型不同，C++在发展的过程中增加了模板(template)的功能，提供了解决这类问题的途径。

例：对两个整数作比较与对两个浮点数作比较需要声明不同类型的类

class Compare_int
{
public:
    Compare_int(int a, int b) //定义构造函数
    {
        x = a; y = b;
    }
    int max()
    {
        return (x > y) ? x : y;
    }
    int min()
    {
        return (x < y) ? x : y;
    }
private:
    int x, y;
};

class Compare_float
{
public:
    Compare_float(float a, float b) //定义构造函数
    {
        x = a; y = b;
    }
    float max()
    {
        return (x > y) ? x : y;
    }
    float min()
    {
        return (x < y) ? x : y;
    }
private:
    float x, y;
};

可以声明一个通用的类模板，它可以有一个或多个虚拟的类型参数，对以上两个类可以综合写出以下的类模板：

template <class numtype> //声明一个模板，虚拟类型名为numtype
class Compare //类模板名为Compare
{
public:
    Compare(numtype a, numtype b) //定义构造函数
    {
        x = a; y = b;
    }
    numtype max()
    {
        return (x > y) ? x : y;
    }
    numtype min()
    {
        return (x < y) ? x : y;
    }
private:
    numtype x, y;
};

声明类模板：template<class 类型参数名>
由于类模板包含类型参数，因此又称为参数化的类。如果说类是对象的抽象，对象是类的实例，则类模板是类的抽象，类是类模板的实例。
类模板使用方法：类模板名<实际类型名> 对象名(参数表);

例：

#include<iostream>
using namespace std;
template<class numtype> //声明类模板，虚拟类型名为numtype
class Compare //类模板名为Compare
{
public:
	Compare(numtype a, numtype b) //定义构造函数
	{
		x = a; y = b;
	}
	numtype max() //函数类型暂定为numtype
	{
		return x > y ? x : y;
	}
	numtype min()
	{
		return x < y ? x : y;
	}
private:
	numtype x, y; //数据类型暂定为numtype
};
int main()
{
	Compare<int> cmp1(3, 7); //定义对象cmp1，用于两个整数的比较
	cout << cmp1.max() << " is the Maximum of two interger numbers." << endl;
	cout << cmp1.min() << " is the Minimum of two interger numbers." << endl << endl;

	Compare<float> cmp2(45.78,93.6); //定义对象cmp2，用于两个浮点数的比较
	cout << cmp2.max() << " is the Maximum of two float numbers." << endl;
	cout << cmp2.min() << " is the Minimum of two float numbers." << endl << endl;

	Compare<char> cmp3('a', 'A'); //定义对象cmp3，用于两个字符的比较
	cout << cmp3.max() << " is the Maximum of two characters." << endl;
	cout << cmp3.min() << " is the Minimum of two characters." << endl << endl;
}

运行结果

如果类模板中的成员函数所在类模板外定义的，应当写成类模板的形式：

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

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

可以这样声明和使用类模板：

先写出一个实际的类。由于其语义明确，含义，一般不会出错。
将此类中准备改变的类型名(如int要改变为float或char)改用一个自己指定的虚拟类型名(如上例中的numtype)。
在类声明前面加入一行，格式为：template <class 虚拟类型参数> //注意末尾无分号
用类模板定义对象时用以下形式：

类模板名<实际类型名> 对象名;
类模板名<实际类型名> 对象名(实参表列);

如果在类模板外定义成员函数，应写成类模板形式：

template <class 虚拟类型参数>
函数类型 类模板名<虚拟类型参数>::成员函数名(函数形参表列) {…}

声明：

类模板的类型参数可以有一个或多个，每个类型前面都必须加class，如

template <class T1,class T2>
class someclass
{…};

在定义对象时分别代入实际的类型名，如：someclass<int,double> obj;

和使用类一样，使用类模板时要注意其作用域，只能在其有效作用域内用它定义对象。
模板可以有层次，一个类模板可以作为基类，派生出派生模板类。

—Miss. Z—

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
类模板/友元

友元：友元可以访问与其有好友关系的类中的私有成员。友元包括友元函数和友元类。在C++中，这种关系以关键字friend声明。友元函数：如果在本类以外的其他地方定义了一个函数(这个函数可以是不属于任何类的非成员函数，也可以是其他类的成员函数)，在类体中用friend对其进行声明，此函数就称为本类的友元函数。友元函数可以访问这个类中的私有成员。
复制链接

扫一扫