一、类作用域
每个类都定义了自己的作用域成为类作用域
类作用域中说明的标识符只在类中可见
#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两个标识符的作用域为函数的原型作用域;
int main(void)
{
int num_ = 30; //num_为块作用域;
{
int num_=100; //num_为块作用域;
}
cout << num_<<endl; //输出 30;
cout <<::num_<<endl; //输出 20;
return 0;
}
int add(int a,int b) //a,b也是块作用域
{
return a+b;
}
int test()
{
LABEL1: //函数作用域
cout<<"label1"<<endl;
goto LABEL3;
LABEL2:
cout<<"label2"<<endl;
goto LABEL1;
LABEL3:
cout<<"label3"<<endl;
goto LABEL2;
}
二、前向声明
C++中类必须先定义,才能够进行实例化
两个类需要相互引用形成一个“环形”引用时,无法先定义使用。这个时候需要用到前向声明;
前向声明的类不能实例化;
A.h
#ifndef _A_H
#define _A_H
Class A
{
public:
void A();
void ~A();
B b_;
}
#endif //_A_H
B.h/
#ifndef _B_H
#define _B_H
Class A;
Class B
{
public:
void B();
void ~B();
A* a_; //前向声明的类不能实例化对象;,不能是对象,只能是指针或者引用;
}
#endif //_B_H
三、嵌套类
外围类需要使用嵌套类对象作为底层实现,并且该嵌套类只用于外围类的实现,并且同时可以对用户隐藏该底层实现
从作用域的角度来看,嵌套类被隐藏在外围类之中,该类名只能在外围类中使用。如果在外围类的作用域使用该类名时,需要加名字限定;
嵌套类中的成员函数可以在他的类体外定义;
嵌套类的成员函数对外围类的成员没有访问权限,反之亦然;
嵌套类仅仅只是语法上的嵌入;
#include<iostream>
using namespace std;
class Outer
{
public:
Class Inner
{
public:
void Func();
//{
// cout<<"Inner::Fun..."<<endl;
//}
}
public:
Inner obj_;
void Fun()
{
count<<"Outer::Fun..."<<endl;
obj_.Fun();
}
}
void Outer::Inner::Fun() //加两个限定;
{
cout<<"Inner::Fun..."<<endl;
}
void Fun()
{
class LocalClass
{
public:
int num_;
void Init(int num) //局部类的函数实现只能在类中实现
{
num=num_;
}
void Display()
{
cout<<"num="<<num<<endl;
}
// static int num2; Error,局部类中不允许定义静态成员变量
}
LocalClass Lc;
Lc.Init(10);
Lc.Display();
}
int main(void)
{
Outer o;
o.Fun();
/*
Outer::Fun...
Inner::Fun...
*/
Outer::Inner i;
i.Fun();
Fun();
//LocalClass Lc; Error,局部类只能在定义他的函数中使用;
retrun 0;
}
四、局部类
类也可以定义在函数体内,这样的类被称为局部类(local class)。局部类只在定义他的局部域内可见;
局部类的成员函数必须被定义在类体中;
局部类中不能有静态成员;