> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Local Class A local class in C++ is a class defined within the lexical scope of a function or a block. While its name is only visible within that enclosing block, the type itself can escape the scope in modern C++ (C++14 and later) via `auto` return types, allowing objects of the local class to be instantiated outside the function using `decltype`. ```cpp theme={"dark"} int global_var = 10; auto enclosingFunction() { static int static_local = 20; int non_static_local = 30; constexpr int const_local = 40; // Local Class Declaration class LocalClass { int member_var; public: // Prohibited: Default arguments cannot use local variables of the enclosing function // LocalClass(int val = non_static_local) : member_var(val) {} LocalClass(int val) : member_var(val) {} // Member functions must be defined inline void process() { // Permitted: Accessing global variables global_var++; // Permitted: Accessing static variables of the enclosing function static_local++; // Permitted: Accessing const/constexpr non-odr-used local variables int array[const_local]; // Prohibited: odr-use of non-static local variables // non_static_local++; } // Permitted: Static member functions static void staticMethod() {} // Prohibited: Static data members // static int static_data; }; // Escaping the local scope via auto return type (C++14) return LocalClass(5); } void outsideFunction() { // Instantiating new objects of the local class outside its original lexical scope auto obj = enclosingFunction(); decltype(obj) another_obj(10); } ``` ## Core Technical Constraints **1. Scope and Instantiation** The class name is strictly resolved within the block where it is defined and cannot be forward-declared outside the function. However, since C++14, a function can return a local class type using an `auto` return type. This allows the type to escape its lexical scope, and new instances can be created outside the enclosing block using `decltype`. **2. Member Function Definitions** All member functions must be defined entirely within the class body (implicitly inline). Out-of-line definitions using the scope resolution operator (`::`) outside the class or function block are syntactically invalid. **3. Enclosing Scope Access Rules** A local class has restricted access to the variables of its enclosing function: * **Non-static local variables:** Generally prohibited from being read or modified. However, a local class *is* permitted to access non-static local variables from the enclosing scope if they are usable in constant expressions (e.g., `constexpr` or `const int` variables) and are not odr-used (e.g., used in `sizeof`, `decltype`, or where the lvalue-to-rvalue conversion is immediately applied). * **Static local variables:** Permitted. The class can read and modify `static` variables declared within the enclosing function. * **Global namespace:** Permitted. The class can access global variables, global functions, type names (`typedef` or `using`), and enumerators that are visible at the point of the class definition. **4. Default Arguments** Member functions of a local class can specify default arguments. However, C++ explicitly prohibits these default arguments from evaluating or binding to local variables of the enclosing function. **5. Static Members** Local classes are prohibited from declaring `static` data members. The compiler cannot allocate storage for a static data member of a local class because the class itself has no linkage. Conversely, local classes are permitted to declare `static` member functions. **6. Templates and Linkage** * A local class cannot be a class template. * A local class cannot contain member function templates. * Local classes have no linkage. Prior to C++11, this meant they could not be passed as type arguments to templates. C++11 lifted this restriction, allowing local classes to be used as template type arguments (e.g., `std::vector`), provided the template instantiation occurs within a valid scope where the type is known.
Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More