C++类与对象学习笔记（三）

一、类作用域

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

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

#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）。局部类只在定义他的局部域内可见；

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

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