第007课 C++ 友元与动态内存

一、友元：

     友元是一种定义在类外部的普通函数或类，但它需要在类体内进行说明，为了与该类的成员函数加以区别，在说明时前面加以关键字friend。友元不是成员函数，但是它可以访问类中的私有成员。     

     类具有封装和信息隐藏的特性。只有类的成员函数才能访问类的私有成员，程序中的其他函数是无法访问私有成员的。非成员函数可以访问类中的公有成员，但是如果将数据成员都定义为公有的，这又破坏了隐藏的特性。另外，应该看到在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递，类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。     

目    的：提高程序的运行效率

缺    点：破坏了类的封装性和隐藏性

1、友元函数     

    类中私有和保护的成员在类外不能被访问。友元函数是一种定义在类外部的普通函数，其特点是能够访问类中私有成员和保护成员，即类的访问权限的限制对其不起作用。 友元函数需要在类体内进行说明，在前面加上关键字friend。     

    一般格式为：

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

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

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

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

 例： 

#include <iostream>
using namespace std;

class TestFriend
{
	int x, y;
public:
	TestFriend()//默认构造函数
	{
		cout << " 调用默认的构造函数" << endl;
	}
	TestFriend(int a, int b)//带有参数的构造函数
	{
		x = a;
		y = b;
		cout << "  x=" << x << ", y=" << y << endl;
	}
	int mul_xy()//普通成员函数
	{
		return x * y;
	}
	friend int add_xy(TestFriend& test_friend);//友元函数在类中声明，友元函数不是类的成员函数
};

int add_xy(TestFriend& test_friend)//友元函数定义，可以访问私有成员和保护成员
{
	return test_friend.x + test_friend.y;
}

int main()
{
	TestFriend test;//创建对象，调用默认构造函数
	TestFriend test1(50,100);//调用带参构造函数
	cout << "  两个数之积：" << test1.mul_xy() << endl;
	cout << "  两个数之和：" << add_xy(test1) << endl;//可以访问 类的私有成员和保护成员
	return 0;
}

输出结果：

 友元函数与一般函数的不同点在于：     

1、友元函数必须在类的定义中说明，其函数体可在类内定义，也可在类外定义；     

2、友元函数可以访问该类中的所有成员（公有的、私有的和保护的），而一般函数只能访问类中的公有成员。     

3、友元函数不受类中访问权限关键字的限制，可以把它放在类的私有部分，放在类的公有部分或放在类的保护部分，其作用都是一样的。换言之，在类中对友元函数指定访问权限是不起作用的。 4、友元函数的作用域与一般函数的作用域相同。谨慎使用友元函数。通常使用友元函数来读取对象中的数据成员值，而不修改对象中的成员值，则肯定是安全的。

例：

#include <iostream>
using namespace std;

class TestFriend
{
	int x, y;
public:
	TestFriend(int a, int b)//带有参数的构造函数
	{
		x = a;
		y = b;
	}
	int get_x()
	{
		return x ;
	}
	int get_y()
	{
		return y;
	}
	int add_xy()//成员函数
	{
		return x+y;
	}
	friend int add_xy(TestFriend& test_friend);//友元函数在类中声明，友元函数不是类的成员函数
};

int add_xy(TestFriend& test_friend)//友元函数定义，可以访问私有成员和保护成员
{
	return test_friend.get_x() + test_friend.get_y();//调用类的成员函数
}

int main()
{
	TestFriend test1(10, 20), test2(50, 100), test3(200, 500);
	cout << " test1.add_xy()= " << test1.add_xy() << endl;
	cout << " add_xy(test2)= " << add_xy(test2) << endl;
	cout << " add_xy(test3)= " << add_xy(test3) << endl;
	return 0;
}

输出结果：

 2、友元类     

     友元除了函数以外，还可以是类，即一个类可以作另一个类的友元。当一个类作为另一个类的友元时，这就意味着这个类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。     

  定义友元类的语句格式如下：friend class 类名（即友元类的类名）;

例：

//友元类操作
#include <iostream>
using namespace std;

class TestClassA  //类 TestClassA
{
	int x, y;
public:
	TestClassA(int a, int b)//带有参数的构造函数
	{
		x = a;
		y = b;
	}
	int get_x()
	{
		return x;
	}
	int get_y()
	{
		return y;
	}
	int add_xy()//成员函数
	{
		return x + y;
	}
	friend class TestClassB;//说明类TestClassB 为 类TestClassA 的友元类
};

class TestClassB  //类 TestClassB
{
	int k;
public:
	TestClassB(int n = 1) //带有参数的构造函数
	{
		k = n;
	}
	void dis(TestClassA& test)
	{
		cout << " test.x + .y + k = " << test.x + test.y + k << endl;
	}   // 引用类TestClassA中的x、y 的值的求和操作
};

int main()
{
	TestClassA testClass_a1(100,200), testClass_a2(300,400);
	TestClassB testClass_b1(10);
	testClass_b1.dis(testClass_a1);
	testClass_b1.dis(testClass_a2);
	return 0;
}

输出结果：

 【注意事项】

(1) 友元关系不能被继承。     

(2) 友元关系是单向的，不具有交换性。若类B是类A的友元，类A不一定是类B的友元，要看在类中是否有相应的声明。     

(3) 友元关系不具有传递性。若类B是类A的友元，类C是B的友元，类C不一定是类A的友元，同样要看类中是否有相应的申明。

二、动态内存new/delete：

   在定义变量或数组的同时即在内存为其开辟了指定的固定空间。 如：

int test; //定义变量test，为其开辟4的字节内存空间(int型在32bit为4字节)
char cTest[40]; //定义字符数组，为其开辟40个字节

   一经定义，即为固定地址的空间，在内存不能被别的变量所占用。

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

new   数据类型[单位数];     
new  int[4]; //在内存中开辟了4个int型的数据空间，即16个字节 

     new 相当于一个函数，在内存开辟完空间后，返回这个空间的首地址，这时，这个地址必须用一个指针保存下来，才不会丢失。 

 可以用*p对这个空间进行运算。

同样，利用new运算符也可以开辟连续的多个空间(数组)。

for(int i=0; i<n; i++) //可以用p[i]的形式来引用新开辟的内存单元
	cin>>p[i];  

【注意】：用new开辟的内存单元没有名字，指向其首地址的指针是引用其的唯一途径，若指针变量重新赋值，则用new开辟的内存单元就在内存中“丢失”了，别的程序也不能占用这段单元，直到重新开机为止。

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

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

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

int  *point;
point = new int; //注意：在此期间，point指针不能重新赋值，
......
delete   point; //只有用new开辟的空间才能用delete收回

delete也可以收回用new开辟的连续的空间。

int *point;
cin>>n;
point = new int[n];
.......
delete  []point；

 当内存中没有足够的空间给予分配时，new 运算符返回空指针NULL（0）。