友元、隐式类型转化_代码007(未授权)

本文介绍: 友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。友元分为：友元函数和友元类。

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

友元函数不是类的成员函数，就相当于你的朋友再亲密也不是你的家人，既然不是类成员函数，那和普通成员函数调用一样，不需要通过对象调用

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

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

1. 内部类可以定义在外部类的public、protected、private都是可以的。

class A
{
public:
	A(int a)
		:_a(a)
	{}

private:
	int _a; 
};
int main()
{
	A a1(1);

	A a2 = 3;
	return 0;
}

class A
{
public:
	A(int a)
		:_a(a)
	{}

private:
	int _a; 
};
int main()
{
	A a2 = 3;
	int* p = nullptr;
	A a3 = p;
	return 0;
}

class A
{
public:
	A(int a)
		:_a(a)
	{}
	A(int* a)
	{}
private:
	int _a;
};
int main()
{
	A a2 = 3;
	int* p = nullptr;
	A a3 = p;
	return 0;
}

class A
{
public:
	A(int a)
		:_a(a)
	{}

private:
	int _a; 
};
int main()
{
	A a1(1);

	A a2 = 3;
	A& a3 = 3; // 临时变量具有常性
	return 0;
}

class A
{
public:
	explicit A(int a)
		:_a(a)
	{}
private:
	int _a; 
};
int main()
{
	A a2 = 3;
	return 0;
}

class A
{
public:
	explicit A(int a)
		:_a(a)
	{}
private:
	int _a; 
};
int main()
{
	A a2 = (A)3; // 显式转化
	return 0;
}

class A
{
public:
	A(int a)
		:_a(a)
	{}
private:
	int _a; 
};

class Date
{
public:
	Date(int year = 2024, int month = 1, int day = 16)
		:_year(year), _month(month), _day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 单参数类型转化
	list<A>lt;
	A aa1(1);
	lt.push_back(aa1); // 第一种

	lt.push_back(A(2)); // 第二种

	lt.push_back(3); // 第三种

	// 多参数类型转化
	list<Date>lt1;
	Date d6(2023, 11, 2);
	lt1.push_back(d6); // 第一种

	lt1.push_back(Date(2023, 11, 2)); // 第二种

	lt1.push_back({ 2023,11,2 }); // 第三种
	return 0;
}

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& c)
		:_a(c._a)
	{
		cout << "A(A&)" << endl;
	}
private:
	int _a; 
};

int main()
{
	A aa1 = 1;
	return 0;
}

void func(A aa)
{}
int main()
{
	A aa(1); // 构造函数
	func(aa); // 拷贝构造函数
	return 0;
}

int main()
{
	func(A(2));
	return 0;
}

int main()
{
	func(3);
	return 0;
}

A func()
{
	A aa; // 构造函数
	return aa; // 拷贝构造
}

int main()
{
	A ret = func(); // 拷贝构造
	return 0;
}

void func(A aa) // 传参-拷贝构造
{
	
}

int main()
{
	func(A(2)); // 构造
	return 0;
}

显示所有内容

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。

函数友元封装

（一）友元函数

特征：

（二）友元类

特征：

（三）内部类

特性：

（四）隐式类型转化

explicit

隐式类型转化的应用

（五）编译器对拷贝构造和构造函数的优化

构造+拷贝构造->构造

拷贝构造+拷贝构造->拷贝构造

构造+拷贝构造->优化为一个构造

发表回复取消回复