Объявление класса

Классы это определяемые пользователем типы, определяемые спецификатором класса, который появляется в последовательности-спецификаторов-объявления синтаксиса объявления.

[править] Синтаксис

Спецификатор класса имеет следующий синтаксис:

[править] Предварительное объявление

Объявление следующей формы

Объявляет тип класса, который будет определён позже в этой области. Пока не появится определение, это имя класса имеет неполный тип. Это позволяет классам ссылаться друг на друга:

class Vector; // предварительное объявление
 
class Matrix
{
    // ...
    friend Vector operator*(const Matrix&, const Vector&);
};
 
class Vector
{
    // ...
    friend Vector operator*(const Matrix&, const Vector&);
};

и если конкретный исходный файл использует только указатели и ссылки на класс, это позволяет уменьшить #include зависимости:

// в MyStruct.h 
#include <iosfwd> // содержит предварительное объявление std::ostream
 
struct MyStruct
{
    int value;
    friend std::ostream& operator<<(std::ostream& os, const S& s);
    // определение предоставлено в файле MyStruct.cpp, который использует
    // #include <ostream>
};

Если предварительное объявление появляется в локальной области видимости, оно скрывает ранее объявленный класс, переменную, функцию и все другие объявления с тем же именем, которые могут появляться в окружающих областях видимости:

struct s { int a; };
struct s; // ничего не делает (s уже определена в этой области видимости)
 
void g()
{
    struct s; // предварительное объявление новой локальной структуры "s"
              // скрывает глобальные структуры до конца этого блока видимости
 
    s* p;     // указатель на локальную структуру s
 
    struct s { char* p; }; // определения локальной структуры s
}

Обратите внимание, что новое имя класса также может быть введено уточнённым спецификатором типа, который появляется как часть другого объявления, но только в том случае, если поиск по имени не может найти ранее объявленный класс с таким же именем.

class U;
 
namespace ns
{
    class Y f(class T p); // объявляет функцию ns::f и объявляет ns::T и ns::Y
 
    class U f();          // U ссылается на ::U
 
    // можно использовать указатели и ссылки на T и Y
    Y* p;
    T* q;
}

[править] Спецификация элемента

Спецификация элемента или тело определения класса представляет собой заключённую в фигурные скобки последовательность любого числа из следующего:

class S
{
    int d1;            // нестатический элемент данных
    int a[10] = {1,2}; // нестатический элемент данных с инициализатором (C++11)
 
    static const int d2 = 1; // статический элемент данных с инициализатором
 
    virtual void f1(int) = 0; // чистая виртуальная функция-элемент
 
    std::string d3, *d4, f2(int); // два элемента данных и функция-элемент
 
    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) {} // определение конструктора
 
    int operator()(std::size_t r, std::size_t c) const // определение функции-элемента
    {
        return data[r * C + c];
    }
 
    int& operator()(std::size_t r, std::size_t c)      // другое определение функции-элемента
    {  
        return data[r * C + c];
    }
};

class S
{
public:
    S();          // открытый конструктор
    S(const S&);  // открытый конструктор копирования
    virtual ~S(); // открытый виртуальный деструктор
private:
    int* ptr; // закрытый элемент данных
};

class Base
{
protected:
    int d;
};
 
class Derived : public Base
{
public:
    using Base::d; // делает защищённый элемент базового класса d
                   // открытым элементом производного
    using Base::Base; // наследует конструкторы всех базовых классов (C++11)
};

template<typename T>
struct Foo
{
    static_assert(std::is_floating_point<T>::value, "Foo<T>: T должен быть с"
                                                    " плавающей запятой");
};

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>;
};

enum class color { red, orange, yellow };
 
struct highlight
{
    using enum color;
};

[править] Локальные классы

Объявление класса может появиться внутри тела функции, и в этом случае оно определяет локальный класс. Имя такого класса существует только внутри области действия функции и недоступно из вне.

• Локальный класс не может иметь статических элементов данных
• Функции-элементы локального класса не имеют связывания
• Функции-элементы локального класса должны быть определены полностью внутри тела класса
• Локальные классы , отличные от типов замыкания, (начиная с C++14) не могут иметь шаблонных элементов
• Локальные классы не могут иметь дружественные шаблоны
• Локальные классы не могут определять дружественные функции внутри определения класса
• Локальный класс внутри функции (включая функцию-элемент) может обращаться к тем же именам, к которым может обращаться включающая функция.

#include <vector>
#include <algorithm>
#include <iostream>
 
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()); // начиная с C++11
 
    for (int n : v)
        std::cout << n << ' ';
}

3 2 1

[править] Отчёты о дефектах

Следующие изменения поведения были применены с обратной силой к ранее опубликованным стандартам C++:

[править] Смотрите также