C++之破坏封装，数据共享：友元与静态成员

友元函数：

友元函数声明：函数声明前加friend，声明可以放在公有位置，保护位置和私有位置。

1.独立于当前类的外部函数，可以访问类的任何成员，使用时一般被main调用。

#include<iostream>
using namespace std;
class Date
{
	public:
	Date(int h,int m,int s)
	{
		hour=h;
		minute=m;
		second=s;
	 }
	 friend void display(Date &);//友元函数声明 
	 private:
	 int hour;
	 int minute;
	 int second; 
};
void display(Date &d)  //形参d是Date类对象的引用 
{
	cout<<d.hour<<":"<<d.minute<<":"<<d.second<<endl;
 } 
 int main()
 {
 	Date t(15,23,56);
 	display(t);  //实参t传递类对象 
 	return 0;
  } 

2.一个类的成员函数作为另一个类的友元函数，两个类之间的单向通道。

无this指针，所以需要在入口参数传递对象名或者对象指针来引用对象。

#include<iostream>
using namespace std;
#include<string>
class Info;//向前引用声明
class Time
{
	public:
	Time(int h,int m,int s)
	{
		hour=h;
		minute=m;
		second=s;
	 }
	 void display(Info &);
	 private:
	 int hour;
	 int minute;
	 int second; 
};
class Info
{
	public:
	Info(string name,int num)
	{
		this->name=name;
		this->num=num;
	}
	friend void Time::display(Info &);
	private:
		string name;
		int num;
 };
void Time::display(Info &g)
{
	cout<<hour<<":"<<minute<<":"<<second<<endl; 
	 	cout<<g.name<<endl;
	 	cout<<g.num<<endl;
}
 int main()
 {
 	Time t(15,23,56);
    Info k("lili",23);
	t.display(k); 
  	return 0;
  } 

友元类

1.friend 类名，可以放在公有，私有，保护位置。

2.友元关系是单向的，例如在B类中声明 friend A，则A类是B类的友元类，但B类不是A类的友元类;

A类中的所有成员函数都是B类的友元函数，B类可以访问A类的所有成员。

3.友元关系无法传递，也就是说关系只能逐一连接，不能继承。

#include<iostream>
using namespace std;
class Truck;
class Car
{
	public:
		Car(int CarSpeed)
		{
			CarSpeed=CarSpeed;
		}
		friend Truck;  //声明Car是Truck的友元类 
	private:
		 int CarSpeed;
 };
 class Truck
 {
 	public:


 	    Truck(int truckspeed)
 	    {
 	    	TruckSpeed=truckspeed; 
		 } 
		void Compare(Car &c)
		{
			if(c.CarSpeed>TruckSpeed)
			cout<<"Car 快"<<endl;
			else
			cout<<"Truck 快"<<endl;
		 } 
	private:
		int TruckSpeed;
 };

 int main()
 {
 	Car c(100); 
 	Truck t(60);
 	t.Compare(c); 
 	return 0;
 }

静态数据成员：

1.同一类的不同对象之间的数据共享。

2.在所有对象之外单独开辟空间，与对象是否创建无关，所以即使没有实例化类对象，也可以通过类名来访问静态数据成员；如果静态数据成员定义为私有的，则只能通过公有的成员函数访问。

3.静态数据成员只能在类体外初始化。

4.静态数据成员访问：对象名OR类名。

#include<iostream>
using namespace std;
class Account
{
	public:
	Account()
	{
		count++;
	}
	void display()
	{
		cout<<count<<endl;
	}
	static int count;
};
int Account::count =0;//类体外进行初始化 
int main()
{
	Account A;
	Account B;
	Account C;
	Account D;
	Account E;
	E.count;  //通过对象名访问 
	cout<<Account::count<<endl; //通过类名访问 
	return 0;
}

静态成员函数：

1.无this指针，所以不能访问本类中的非静态成员

2.处理静态成员函数。

#include<iostream> 
using namespace std; 
class Count{
	static int i;
public:
	Count()
	{
		i++;
	 } 
	static int getVal(){return i;}
};
int Count::i=0;	
int main()
{  
  Count x;
  Count y;
  cout<<Count::getVal();
  return 0; 
}