类于对象（三）

######C++课程网笔记，感谢Mr.J老师

1）类作用域

2）前向声明

3）嵌套类

4）局部类

1、类作用域

每个类都定义了自己的作用域称为类作用域。

类作用域中说明的标识符只有类中可见。

#include <iostream>
using namespace std;

class Test
{public:
	int num_;

};
//num_ = 20; error num_的作用域在类内部
int num_ = 20;  //num_的作用域是文件作用域，与类中的num_是不同的作用域，可行

int main(void)
{
	return 0;
}

（1）块作用域

（2）文件作用域

（3）函数原型作用域

（4）函数作用域

（5）类作用域

#include <iostream>
using namespace std;

class Test
{public:
	int num_;

};
//num_ = 20; error num_的作用域在类内部
int num_ = 20;  //num_的作用域是文件作用域，从定义位置开始到文件结束有效，与类中的num_是不同的作用域，可行

int add(int a,int b); //函数原型作用域，a,b两个标识符的作用域为函数声明的这条语句内有效。定义函数时可以使用a,b,标识符。

int main(void)
{
	int num_ = 30; //num_为块作用域
	{
		int num_ = 100; //num_为块作用域，所谓块作用域是指{}内的代码。
	}

	cout << num_ << endl;   //输出为：30   因此块作用域只对块内的有效
	cout << ::num_ << endl;  //输出为：20  使用::，域运算符指定文件作用域下的num_

	return 0;
}

int add(int a, int b) //形参a,b也可以看成块作用域。
{
	return a + b;

}

int test()
{
LABEL1:
	cout << "label1" << endl;
	goto LABEL3;				//函数作用域是针对goto语句来讲的，这里LABEL3还未定义就可以使用，因为函数作用域下，goto语句可以使用函数内的内容。
LABEL2:
	cout << "label2" << endl;
	goto LABEL1;
LABEL3:
	cout << "label3" << endl;
	goto LABEL2;
}

2）前向声明

        C++中的类必须先定义，才能够实例化。

        两个类需要相互引用形成一个“环形”引用时，无法先定义使用，这个时候需要用到前向声明。

        前向声明的类不能实例化。

为说明这个概念，我们定义了两个类，一个A，一个B，这里再A类中包含B类，在B类中包含A类，这样相互包含是不允许的，

#ifndef _A_H_
#define _A_H_

#include "B.h"

class A
{
public:
	A(void);
	~A(void);
    //B b_; error,//这里需要定义一个B类对象，要包含B.h
};

#endif

#ifndef _B_H_
#define _B_H_

//#include "A.h"
class A;//前向声明

class B
{
public:
	B(void);
	~B(void);
    //A a_;  error，尽管定义了前向声明，也是错误，不能实例化对象，可以定义指针或者引用//B类中需                
      //要            
      //定义一个A对象，要包含A.h
	A* a;

};


#endif // !_B_H_

 在B.cpp文件中使用到A类中的内容要包含A.h文件。如下

#include "B.h"
#include "A.h"

	B::B(void)
	{
		A* a;
	}

	B::~B(void)
	{

	}

3）嵌套类

外围类需要使用嵌套对象作为底层实现，并且该嵌套类只用于外围类的实现，且同时可以对用户隐藏该底层实现。

#include <iostream>

using namespace std;

class Outer
{
	class Inter
	{
	public:
		void Fun()
		{
			cout << "Inter::Fun..." << endl;
		}

	};
	Inter obj_;

public:
	void Fun()
	{
		cout << "Outer::Fun.." << endl;
		obj_.Fun();
	}

};

int main(void)
{
	Outer o;
	o.Fun();
	return 0;
}

/*
输出：
Outer::Fun..
Inter::Fun...
*/

从作用域的角度，嵌套类被隐藏在外围类之中，该类名只能在外围类中使用，如果在外围类的作用域外使用该类名时，需要加名字限定。

嵌套类中的成员函数可以在它的类体外定义。

嵌套类的成员函数对外围类的成员没有访问权，反之亦然。

嵌套类仅仅只是语法上的嵌套。

#include <iostream>

using namespace std;

class Outer
{
public:
	class Inter
	{
	public:
		void Fun();
		/* {
			cout << "Inter::Fun..." << endl;
		}*/

	};
	Inter obj_;

public:
	void Fun()
	 {
		cout << "Outer::Fun.." << endl;
		obj_.Fun();
	}

};
void Outer::Inter::Fun()   //嵌套类的实现放在类外
{
	cout << "Inter::Fun..." << endl;
}
int main(void)
{
	Outer o;
	o.Fun();
	Outer::Inter i;   //外部也可以定义嵌套类的对象i
	i.Fun();
	
	return 0;
}

/*
输出：
Outer::Fun..
Inter::Fun...
*/

4）局部类

类也可以定义在函数体内，这样的类被称为局部类（local class）.局部类只在定义它的局部域内可见。

局部类的成员函数必须被定义在类体中。

局部类中不能有静态成员。

#include <iostream>

using namespace std;

class Outer
{
public:
	class Inter
	{
	public:
		void Fun();
		/* {
			cout << "Inter::Fun..." << endl;
		}*/

	};
	Inter obj_;

public:
	void Fun()
	 {
		cout << "Outer::Fun.." << endl;
		obj_.Fun();
	}

};
void Outer::Inter::Fun()   //嵌套类的实现放在类外
{
	cout << "Inter::Fun..." << endl;
}

void Fun()
{
	class LocalClass    //局部类，只能在定义它的函数体使用。
	{
	public:
		int num_;
		void Init(int num)
		{
			num_ = num;  //局部类的实现只能在类体中实现。

		}
		void Display()
		{
			cout << "num_ = " << num_ << endl;
		}
		//static int num2_;不能在局部类中定义静态成员。

	};

	LocalClass lc;
	lc.Init(10);
	lc.Display();
}
int main(void)
{
	Outer o;
	o.Fun();
	Outer::Inter i;   //外部也可以定义嵌套类的对象i
	i.Fun();

	Fun();

	
	return 0;
}

/*
输出：
Outer::Fun..
Inter::Fun...
*/