有元

使用有元就可以突破封装，可以直接对类当中私有的成员成员函数等等进行访问，在某一次上提供了遍历，但是这增大的耦合性，破坏了封装，所以建议有元不要多用。

所谓耦合性就是，某两个东西的关系，越紧密，耦合性就越大。其实，我们要实现封装的话，关系紧密不是好的结果。

有元函数

在类当中使用 friend 关键字修饰一个在类外的普通函数（这个函数不属于任何类），也就是用 friend 关键字在类当中进行声明，在类外面进行定义，那么这个函数就是这个类的友元函数，这个函数就可以访问这个类当中的私有的成员。

如下面这个例子，因为成员函数的第一个参数是对应对象的 this 指针，那么如果我们在类当中定义重载运算符，第一个参数就必须是这个对象的this指针，那我们在调用这个函数的时候，左边的变量只能是对象，比如我们重载 "<<" ，那么我们就只能 d1 << cout ，这样写，如果 cout << d1 ，这样写就会报错。

但是第一种方式不是我们平常的书写习惯，所以我们想到在类外定义，然后为了这个 "<<" 重载函数能访问到类当中的成员，我们就可以把这个重载运算符的函数，声明为有元函数，即代表着，这个函数是这个类的朋友，那么这个函数就可以访问其中私有的成员。

定义在类中：

class Date
{
public:
	Date(int year, int month, int day)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
	// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
	// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
	ostream & operator<<(ostream& _cout)
	{
		_cout << _year << "-" << _month << "-" << _day << endl;
		return _cout;
	}
private:
	int _year;
	int _month;
	int _day;
};

定义在类外：

class Date
{
	friend ostream& operator<<(ostream& _cout, const Date& d);
	friend istream& operator>>(istream& _cin, Date& d);
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

【注意】：

有元函数可以访问私有的受保护的成员，但是不能访问成员函数。
有元函数不能用const 修饰，因为它不能在类当中定义，没有 this 指针。
有元函数可以在类当中的任何地方进行声明，不受类访问限定符的限制
一个函数可以和多个类进行有元
有元函数的调用和普通函数的调用是相同的

有元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

【注意】：

有元是单向的，比如 D1类是 D2类的有元类，那么D1类就可以访问其中的成员函数等等，但是 D2就不能访问 D1 当中的成员函数。
有元不能传递，比如 C 是 B 的有元，B 是 A的有元，但是 C 不是 A的有元。
有元关系不能继承。

class A
{
	friend class B;
public:
	int Get_a()
	{
		return _a;
	}
protected:
	int _a = 1;
};

class B
{
public:
	int GetA_a()
	{
		// 直接访问 A类当中的私有成员
		return a._a;
	}
protected:
	int _b = 0;
	A a;

};

内部类

定义在类当中的类的就是这个类的内部类，这个内部类，就是一个类，通过外部的类是没办法访问内部类中的私有的成员的，也就是说内部类不属于外部类。

我们先来计算一下一个下列代码当中 A类的大小：

我们发现是4，这个4只计算了 _a 这个成员的大小，因为 A 当中的 _b 是静态的，我们说类当中只是的成员只是声明，而定义是在对象当中，但是静态的成员不存储在对象当中，而是在全局当中进行定义。那么类A 当中的类B 也是如此，A 中没有 B对象，所以不计算 B 的大小。如果我们在 A的成员中定义了 B 这个对象那么大小就是 8 了：

像上述的 B 类定义的在 A类的外面，和 B类定义在 A类当中的区别就是，前者是在全局域当中定义，后者是在 A这个类域当中定义。

形象的说，如果类是图纸，对象是对应建造的房子，那么像上述 B是A的内部类，我们创建A类的对象当中是没有B类的空间的，也此时就是在 A的房子中放了 B的图纸。

那么既然是在 A的类域当中定义，那么这个 B类就可以访问A类当中的私有成员，也就是内部类就是外部类的友元类。但是外部类不是内部类的友元。

class A
{
public:

	class B
	{
	public:
		int GetA_a()
		{
			return a._a;
		}

	protected:
		int _b = 0;
		A a;
	};

protected:
	int _a = 1;
	static int _b;
	B b;
};

1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系

只有是定义出来的才受到访问限定符的限制，向上述只是声明，所以是不会限制的。

匿名对象

class A
{
public:
	int Get_a()
	{
		return _a;
	}
protected:
	int _a;
};

int main()
{
	// 匿名创建对象
	A();
}

如上述就是使用匿名对象的创建一个对象。

使用匿名对象来调用成员函数：

int main()
{
	// 匿名创建对象
	A().Get_a();
}

我们可以使用这样的方式来一次性调用类当中的成员函数，如果是多次，那么我们就得使用普通的创建对象的方式来调用成员函数了。

之所以这样说，是因为匿名对象是即用即销毁。

有名对象的生命周期是在函数局部域，匿名函数的生命周期是在当前行。

【注意】：

我们不能这样去调用成员函数：

A::Get_a();

这样调用的前提是这个函数是静态的，如果这样调用这个函数就必须没有 this 指针。而成员函数是必须有 this 指针的。

匿名对象和临时对象一样，具有常性，所以，我们不能创建匿名对象的普通引用：

所以要加一个 const 才能编译通过：

	const A& pa = A();

而且当我们使用 const 引用这个匿名对象之后，这个匿名对象的生命周期会被延长，延长的时间是引用的生命周期。

如下面这个例子：

class A
{
public:
	A()
	{
		cout << "A()" << endl;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

	int Get_a()
	{
		return _a;
	}
protected:
	int _a;
};

class AAAAAAAAA
{
public:
	AAAAAAAAA()
	{
		cout << "AAAAAAAAA()" << endl;
	}

	~AAAAAAAAA()
	{
		cout << "~AAAAAAAAA()" << endl;
	}
};

int main()
{

	const A& pa = A();

	AAAAAAAAA aaaaaaaa;
}

我们把两个类的构造函数和析构函数只要已调用就打印一下，表明调用了这个函数，我们来看输出结果：

我们发现， A(）这个匿名函数是在 AAAAAAAAA（）这个对象销毁之后才销毁的。

匿名函数的使用场景：

void Print_string(const string& st)
{
	cout << st << endl;
}

int main()
{
	string str("11111");  // 1
	Print_string(str);    // 2

	return 0;
}

上述的代码 1 和 2 可以使用匿名对象写成一行代码：

Print_string(string("11111"));

此时就使用了匿名对象进行传参。

C++ 有元内部类匿名对象

有元

有元函数

有元类

内部类

匿名对象

猜你喜欢

C++ 有元 内部类 匿名对象

有元

有元函数

有元类

内部类

匿名对象

猜你喜欢

C++ 有元内部类匿名对象