在C++中，嵌套类是指在一个类的内部定义另一个类。嵌套类分为两种类型：静态嵌套类和动态嵌套类。

1. 静态嵌套类：
静态嵌套类在类的内部静态地定义另一个类，它可以在类的成员函数外部定义。静态嵌套类在类的成员函数中可以直接访问，但无法在类的外部访问。

示例代码：

class OuterClass {  
public:  
    class NestedClass {  
    public:  
        int x;  
        NestedClass(int val) : x(val) {}  
    };  
      
    void func() {  
        NestedClass obj(10); // 在成员函数中访问嵌套类  
    }  
};

2. 动态嵌套类：
动态嵌套类是在类的内部动态地定义另一个类，它只能在类的成员函数内部定义。动态嵌套类在类的成员函数中无法直接访问，需要在类的外部定义一个指针或引用，并通过指针或引用来访问嵌套类的成员。

示例代码：

class OuterClass {  
public:  
    void func() {  
        class NestedClass {  
        public:  
            int x;  
            NestedClass(int val) : x(val) {}  
        };  
        NestedClass* ptr = new NestedClass(10); // 在成员函数中定义嵌套类并创建对象指针  
        cout << ptr->x << endl; // 在成员函数外部通过指针访问嵌套类的成员  
        delete ptr; // 释放对象指针  
    }  
};

C++中的联合（union）是一种特殊的数据类型，它允许在相同的内存位置存储不同的数据类型。联合使用相同的内存空间来存储不同的值，但是在任何时间点，只能存储其中一个值，而不是多个值。

下面是一个使用C++联合的示例：

#include <iostream>  
  
union MyUnion {  
    int intVal;  
    float floatVal;  
    char charVal;  
};  
  
int main() {  
    MyUnion myUnion;  
    myUnion.intVal = 10; // 在这个时间点，myUnion中存储了一个整数  
    std::cout << "myUnion.intVal: " << myUnion.intVal << std::endl;  
  
    myUnion.floatVal = 3.14f; // 现在，myUnion中存储了一个浮点数  
    std::cout << "myUnion.floatVal: " << myUnion.floatVal << std::endl;  
  
    myUnion.charVal = 'A'; // 最后，myUnion中存储了一个字符  
    std::cout << "myUnion.charVal: " << myUnion.charVal << std::endl;  
  
    return 0;  
}

在这个示例中，定义了一个名为MyUnion的联合，它有三个成员：intVal、floatVal和charVal。在main函数中，创建了一个MyUnion类型的变量myUnion，并分别使用不同的成员来存储整数值、浮点数值和字符值。在任何时间点，myUnion中只能存储其中一个值，而不是多个值。因此，使用不同的成员来存储不同的值时，之前存储的值将会被覆盖。

在C++中，局部类是指在函数内部定义的类。由于它们的作用域是局部的，因此只能在定义它们的函数内部访问它们。

以下是一个示例：

#include <iostream>  
  
void myFunction() {  
    class MyLocalClass {  
    public:  
        int x;  
        MyLocalClass(int val) : x(val) {}  
        void print() {  
            std::cout << "Value of x: " << x << std::endl;  
        }  
    };  
  
    MyLocalClass obj(5);  
    obj.print(); // 输出 "Value of x: 5"  
}  
  
int main() {  
    myFunction();  
    return 0;  
}

在这个示例中，定义了一个名为MyLocalClass的局部类，并在myFunction函数内部创建了一个该类的对象obj。由于MyLocalClass的作用域是局部的，因此它只能在myFunction函数内部访问。在main函数中调用myFunction函数时，它会正常工作并输出"Value of x: 5"。