Class declaration - cppreference.com (original) (raw)

Classes are user-defined types, defined by class-specifier, which appears in decl-specifier-seq of the declaration syntax.

Contents

• 1 Syntax
• 2 Forward declaration
• 3 Member specification
• 4 Local classes
• 5 Keywords
• 6 Defect reports
• 7 See also

[edit] Syntax

The class specifier has the following syntax:

| | | | | -------------------------------------------------------------------------------------------------------------------------------- | --- | | | class-key attr (optional) class-head-name class-property-specs (optional) base-clause (optional){ member-specification } | (1) | | | | | | | class-key attr (optional) base-clause (optional){ member-specification } | (2) | | | | | |

1. Named class definition

2. Unnamed class definition

[edit] Forward declaration

A declaration of the following form

| | | | | ------------------------------- | | | | class-key attr identifier ; | | | | | | |

Declares a class type which will be defined later in this scope. Until the definition appears, this class name has incomplete type. This allows classes that refer to each other:

class Vector; // forward declaration   class Matrix { // ... friend Vector operator*(const Matrix&, const Vector&); };   class Vector { // ... friend Vector operator*(const Matrix&, const Vector&); };

and if a particular source file only uses pointers and references to the class, this makes it possible to reduce #include dependencies:

// In MyStruct.h #include // contains forward declaration of std::ostream   struct MyStruct { int value; friend std::ostream& operator<<(std::ostream& os, const S& s); // definition provided in MyStruct.cpp file which uses #include };

If forward declaration appears in local scope, it hides previously declared class, variable, function, and all other declarations of the same name that may appear in enclosing scopes:

struct s { int a; }; struct s; // does nothing (s already defined in this scope)   void g() { struct s; // forward declaration of a new, local struct "s" // this hides global struct s until the end of this block   s* p; // pointer to local struct s   struct s { char* p; }; // definitions of the local struct s }

Note that a new class name may also be introduced by an elaborated type specifier which appears as part of another declaration, but only if name lookup can't find a previously declared class with the same name.

class U;   namespace ns { class Y f(class T p); // declares function ns::f and declares ns::T and ns::Y   class U f(); // U refers to ::U   // can use pointers and references to T and Y Y* p; T* q; }

[edit] Member specification

The member specification, or the body of a class definition, is a brace-enclosed sequence of any number of the following:

1. Member declarations of the form

| | | | | ------------------------------------------------------------------------------------- | | | | attr (optional) decl-specifier-seq (optional) member-declarator-list (optional) ; | | | | | | |

This declaration may declare static and non-static data members and member functions, member typedefs, member enumerations, and nested classes. It may also be a friend declaration.

class S { int d1; // non-static data member int a[10] = {1, 2}; // non-static data member with initializer (C++11)   static const int d2 = 1; // static data member with initializer   virtual void f1(int) = 0; // pure virtual member function   std::string d3, *d4, f2(int); // two data members and a member function   enum { NORTH, SOUTH, EAST, WEST };   struct NestedS { std::string s; } d5, *d6;   typedef NestedS value_type, *pointer_type; };

1. Function definitions, which both declare and define member functions or friend functions. A semicolon after a member function definition is optional. All functions that are defined inside a class body are automatically inline, unless they are attached to a named module(since C++20).

2. Access specifiers public:, protected:, and private:

class S { public: S(); // public constructor S(const S&); // public copy constructor virtual ~S(); // public virtual destructor private: int* ptr; // private data member };

1. Using-declarations:

class Base { protected: int d; };   class Derived : public Base { public: using Base::d; // make Base's protected member d a public member of Derived using Base::Base; // inherit all bases' constructors (C++11) };

| | (since C++11) | | ---------------- |

| | (since C++20) | | ---------------- |

[edit] Local classes

A class declaration can appear inside the body of a function, in which case it defines a local class. The name of such a class only exists within the function scope, and is not accessible outside.

• Members of a local class can only be declared in the definition of that class, except that members that are nested classes can also be declared in the nearest enclosing block scope of that class.
• A class nested within a local class is also a local class.
• A local class cannot have static data members.
• Member functions of a local class have no linkage.
• Member functions of a local class have to be defined entirely inside the class body.
• Local classes other than closure types(since C++14) cannot have member templates.
• Local classes cannot have friend templates.
• Local classes cannot define friend functions inside the class definition.
• A local class inside a function (including member function) can access the same names that the enclosing function can access.

#include #include #include   int main() { std::vector v{1, 2, 3};   struct Local { bool operator()(int n, int m) { return n > m; } };   std::sort(v.begin(), v.end(), Local()); // since C++11   for (int n : v) std::cout << n << ' '; std::cout << '\n'; }

Output:

[edit] Keywords

class,struct,union

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also