Classes are user-defined types, defined by class-specifier, which appears indecl-specifier-seq of thedeclaration syntax.

[edit]Syntax

The class specifier has the following syntax:

[edit]Forward declaration

A declaration of the following form

Declares a class type which will be defined later in this scope. Until the definition appears, this class name hasincomplete 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 <iosfwd> // contains forward declaration of std::ostream struct MyStruct{int value;friendstd::ostream& operator<<(std::ostream& os,const S& s);// definition provided in MyStruct.cpp file which uses #include <ostream>};

If forward declaration appears in local scope, ithides 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 anelaborated type specifier which appears as part of another declaration, but only ifname 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 thebody of a class definition, is a brace-enclosed sequence of any number of the following:

class S{int d1;// non-static data memberint a[10]={1,2};// non-static data member with initializer (C++11) staticconstint d2=1;// static data member with initializer virtualvoid 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;};

class M{std::size_t C;std::vector<int> data;public:    M(std::size_t R,std::size_t C): C(C), data(R*C){}// constructor definition int operator()(std::size_t r,std::size_t c)const// member function definition{return data[r* C+ c];} int& operator()(std::size_t r,std::size_t c)// another member function definition{return data[r* C+ c];}};

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

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

template<typename T>struct Foo{    static_assert(std::is_floating_point<T>::value,"Foo<T>: T must be floating point");};

struct S{template<typename T>void f(T&& n); template<class CharT>struct NestedS{std::basic_string<CharT> s;};};

template<typename T>struct identity{using type= T;};

struct S{template<class CharT>struct NestedS{std::basic_string<CharT> s;}; template<class CharT>    NestedS(std::basic_string<CharT>)-> NestedS<CharT>;};

enumclass color{ red, orange, yellow}; struct highlight{usingenum color;};

[edit]Local classes

A class declaration can appear inside the body of a function, in which case it defines alocal 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 arenested classes can also be declared in the nearest enclosingblock 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 thanclosure types(since C++14) cannot have member templates.
• Local classes cannot havefriend templates.
• Local classes cannot definefriend 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 <algorithm>#include <iostream>#include <vector> int main(){std::vector<int> 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';}

3 2 1

[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

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文