重生之我要学C++第七天(匿名对象、内部类)

构造函数的隐式类型转化

1.单参数构造函数隐式类型转换

来看下面的代码

cpp 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	A(int x)
	{
		_a = x;
	}
private:
	int _a;
};
int main()
{
	A a = 3;
	return 0;
}

此处这句代码

cpp 复制代码

A a = 3;

对于这里，编译完全正确，而且a对象的成员变量_a会被初始化为3。这是为什么？

原理：当执行上面那条语句，编译器会自动检查等号右边的类型，由于类型不匹配（int），3会出现隐式类型转换，此时等号右边相当于A(3)，生成临时对象，再用这个对象拷贝构造 a。

当然，这是原理，编译器会进行优化：用3直接构造a对象。

2.多参数构造函数隐式类型转换

来看下面代码

cpp 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	A(int x,int y)
	{
		_a = x;
		_b = y;
	}
private:
	int _a;
	int _b;
};
int main()
{
	A a = { 3,4 };
	return 0;
}

此处这句代码

cpp 复制代码

A a = { 3,4 };

a对象的成员变量_a，_b会被初始化为3，4。用3，4直接构造a对象。

需要用{ }把多个参数括起来。

匿名对象

当我们只想调用一次类里面的成员方法时，就需要专门创建一个对象，用对象来使用成员方法，未免太过麻烦。

cpp 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	void print()
	{
		cout << "hello cpp" << endl;
	}
private:
	int _a;
};
int main()
{
	A a;//专门创建一个对象
	a.print();
	return 0;
}

这时，匿名对象闪亮登场。顾名思义，匿名对象就是没有名字的对象。

cpp 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	void print()
	{
		cout << "hello cpp" << endl;
	}
private:
	int _a;
};
int main()
{
    A().print();//A()是匿名对象
	return 0;
}

匿名对象特性：具有常性，生命周期只有一行，所在行结束自动调用析构销毁。

例如：

这样的代码会报错，原因是A()匿名对象具有常性，等号左边是A类型的引用，这样涉及权限的放大。

上图便是权限的平移。

内部类

**概念：**如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。

**特性：**内部类是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象来访问外部类中的所有成员。但是外部类不是内部类的友元(外部类不能定义内部类对象来访问内部类成员)。

cpp 复制代码

#include<iostream>
using namespace std;
class A
{
public:
	
	class B
	{
	public:
		void funcb()
		{
			A a;//内部类创建对象访问外部类可无视权限（天生是外部类的友元类）
			a._a=2;
		}
	private:
		int _b;
	};
private:
	int _a;
};
int main()
{
    A:: B b;//内部类对象的创建
    b.funcb();
	return 0;
}