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
- 是可选的，传递给构造函数的参数。