C++友元与动态内存

一、友元

       友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。
       类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。

目 的：提高程序的运行效率
缺 点：破坏了类的封装性和隐藏性

1、友元函数

类中私有和保护的成员在类外不能被访问。友元函数是一种定义在类外部的普通函数，其特点是能够访问类中私有成员和保护成员，即类的访问权限的限制对其不起作用。

友元函数需要在类体内进行说明，在前面加上关键字friend。
一般格式为：

friend  <type> FuncName(<args>);

       友元函数不是成员函数，用法也与普通的函数完全一致，只不过它能访问类中所有的数据。友元函数破坏了类的封装性和隐蔽性，使得非成员函数可以访问类的私有成员。

       一个类的友元可以自由地用该类中的所有成员。
示例：

#include <iostream>
using namespace std;class CTestFriend
{
public:CTestFriend() // 默认的构造函数{cout << "调用默认的构造函数CTestFriend::CTestFriend().\n";}CTestFriend(int a, int b){x = a;y = b;}int getx() {return x;}int gety(){return y;}int sum(){return x + y;}friend int sum(CTestFriend &obj);private:int x, y;
};int sum(CTestFriend &obj)
{return obj.x + obj.y;
}int sumxy(CTestFriend &obj)
{return obj.getx() + obj.gety();
}int main()
{CTestFriend obj1(10, 20), obj2(100, 200), obj3(1000, 2000);cout << "\nobj1.sum():" << obj1.sum() << endl << endl;cout << "\nobj2.sum():" << sum(obj2) << endl << endl;cout << "\nobj3.sumxy():" << sumxy(obj3) << endl << endl;return 0;
}

       有关友元函数的使用，说明如下：

• 友元函数不是类的成员函数
• 友元函数近似于普通的函数，它不带有this指针，因此必须将对象名或对象的引用作为友元函数的参数，这样才能访问到对象的成员。

       友元函数与一般函数的不同点在于：
1、友元函数必须在类的定义中说明，其函数体可在类内定义，也可在类外定义；
2、它可以访问该类中的所有成员（公有的、私有的和保护的），而一般函数只能访问类中的公有成员。
示例：

#include <iostream>
using namespace std;class CTestFriend
{
public:CTestFriend() // 默认的构造函数{cout << "调用默认的构造函数CTestFriend::CTestFriend().\n";}CTestFriend(int a, int b) // 带有参数的构造函数{x = a;y = b;cout << "x=" << x << "," << "y=" << y << endl;}int mulxy()   // 普通成员函数{return x * y;}friend int sumxy(CTestFriend &obj);  // 友元函数 访问私有成员和保护成员private:int x, y;
};int sumxy(CTestFriend &obj)
{return obj.x + obj.y;
}int main()
{CTestFriend obja;CTestFriend objb(50, 100);cout << "\n两个数字之积为:" << objb.mulxy() << endl << endl;cout << "\n两个数字之和为:" << sumxy(objb) << endl << endl;return 0;
}

       友元函数不受类中访问权限关键字的限制，可以把它放在类的私有部分，放在类的公有部分或放在类的保护部分，其作用都是一样的。换言之，在类中对友元函数指定访问权限是不起作用的。

       友元函数的作用域与一般函数的作用域相同。谨慎使用友元函数。通常使用友元函数来取对象中的数据成员值，而不修改对象中的成员值，则肯定是安全的。

2、友元类

       友元除了函数以外，还可以是类，即一个类可以作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。
       定义友元类的语句格式如下：friend class 类名（即友元类的类名）;
示例：

#include <iostream>
using namespace std;class CTestFClassA
{
public:CTestFClassA(double a, double b) {x = a;y = b;}double getx() {return x;}double gety() {return y;}friend class CTestFClassB; // 定义类CTestFClassB为类CTestFClassA友元
private:double x, y;
};class CTestFClassB
{
public:CTestFClassB(int n = 1){k = n;}void disp(CTestFClassA &obj) {cout <<"结果为:"<< obj.x + obj.y + k;} // 求类CTestFClassA的某个数据成员到这边来操作。private:int k;
};int main()
{CTestFClassA obj1(1, 2), obj2(3, 4);CTestFClassB objb(5);objb.disp(obj1);cout << endl;objb.disp(obj2);return 0;
}

注意事项

(1) 友元关系不能被继承。
(2)友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。
(3)友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。

二、动态内存

       在定义变量或数组的同时即在内存为其开辟了指定的固定空间。
int n, a[10];
char str[100];

       一经定义，即为固定地址的空间，在内存不能被别的变量所占用。
       在程序内我们有时需要根据实际需要开辟空间，如输入学生成绩，但每个班的学生人数不同，一般将人数定得很大，这样占用内存。
示例：

#define   N    1000
......
float    score[N][5];
cin>>n;
for(int i=0;i<n;i++)for(j=0;j<5;j++)cin>>score[i][j];
......

无论班级中有多少个学生，程序均在内存中开辟1000×5个实型数空间存放学生成绩，造成内存空间的浪费。

       利用 new 运算符可以在程序中动态开辟内存空间。

new 数据类型[单位数];
new int[4];

       在内存中开辟了4个int型的数据空间，即16个字节。
       new 相当于一个函数，在内存开辟完空间后，返回这个空间的首地址，这时，这个地址必须用一个指针保存下来，才不会丢失。
       同样，利用new运算符也可以开辟连续的多个空间(数组)。
       注意：用new开辟的内存单元没有名字，指向其首地址的指针是引用其的唯一途径，若指针变量重新赋值，则用new开辟的内存单元就在内存中“丢失”了，别的程序也不能占用这段单元，直到重新开机为止。

       用 new 运算符分配的空间，不能在分配空间时进行初始化。

       同样，用new开辟的内存单元如果程序不“主动”收回，那么这段空间就一直存在，直到重新开机为止。

       delete运算符用来将动态分配到的内存空间归还给系统，使用格式为：delete p；
示例：

#include <iostream>
using namespace std;class CNewDelete
{
public:CNewDelete() {cout << "\n调用默认的构造函数CNewDelete::CNewDelete()." << endl;str = new char[10];}~CNewDelete() {cout << "\n调用析构函数CNewDelete::~CNewDelete()." << endl;delete[]str;}
private:char *str;
};int main()
{char buffer[100]; CNewDelete *pobj = new(buffer) CNewDelete();pobj->~CNewDelete();  // 主动调用析构函数，避免内存泄漏char *buffer2 = new char[100];CNewDelete *pobj2 = new(buffer2) CNewDelete();pobj2->~CNewDelete(); // 必须记住，主动调用析构函数delete[]buffer2; // 堆内存需要主动释放操作return 0;
}

注意，定位 new 的基本语法如下：
Type ptr = new (address) Type(constructor_arguments);*

• Type 是要创建的对象的类型。
• address 是一个指向已分配内存的指针
• constructor_arguments
• 是可选的，传递给构造函数的参数。