Что такое construct?

Что такое construct в C++?

Основное определение

Construct в C++ — это, прежде всего, конструктор (constructor) — специальный метод класса, который вызывается при создании объекта для инициализации его состояния.

Однако в более широком смысле слово "construct" может относиться к различным языковым конструкциям (языковым инструментам и синтаксическим структурам).

Конструктор (Constructor)

Конструктор — это метод, который:

• Вызывается автоматически при создании объекта
• Инициализирует данные члены класса
• Имеет то же имя, что и класс
• Не имеет типа возвращаемого значения

class Person {
private:
    std::string name;
    int age;

public:
    // Конструктор
    Person(const std::string& n, int a) : name(n), age(a) {
        std::cout << "Person создан: " << name << std::endl;
    }
    
    ~Person() {  // Деструктор
        std::cout << "Person удален: " << name << std::endl;
    }
};

// Использование
Person p("Alice", 30);  // Вызывается конструктор
// Вывод: Person создан: Alice

Типы конструкторов

1. Конструктор по умолчанию (Default Constructor)

Вызывается без параметров:

class Box {
public:
    Box() : width(0), height(0) {}  // Default constructor
private:
    double width, height;
};

Box b;  // Вызывается конструктор по умолчанию

2. Параметризованный конструктор

class Box {
public:
    Box(double w, double h) : width(w), height(h) {}
private:
    double width, height;
};

Box b(5.0, 3.0);  // Вызывается параметризованный конструктор

3. Конструктор копирования (Copy Constructor)

Создает копию существующего объекта:

class Vector {
public:
    Vector(const Vector& other) : data(other.data) {
        std::cout << "Copy constructor called" << std::endl;
    }
private:
    std::vector<int> data;
};

Vector v1;
Vector v2 = v1;  // Вызывает конструктор копирования

4. Конструктор перемещения (Move Constructor) — C++11

Перемещает ресурсы из временного объекта:

class Vector {
public:
    Vector(Vector&& other) noexcept : data(std::move(other.data)) {
        std::cout << "Move constructor called" << std::endl;
    }
private:
    std::vector<int> data;
};

Vector v1;
Vector v2 = std::move(v1);  // Вызывает конструктор перемещения

Инициализация членов (Member Initialization List)

Список инициализации — лучший способ инициализировать данные члены:

class Employee {
private:
    std::string name;
    int id;
    double salary;

public:
    // Правильно: используем список инициализации
    Employee(const std::string& n, int i, double s) 
        : name(n), id(i), salary(s) {}
    
    // Неправильно: присвоение в теле конструктора
    // Employee(const std::string& n, int i, double s) {
    //     name = n;  // КОПИРОВАНИЕ, не инициализация
    //     id = i;
    //     salary = s;
    // }
};

Делегирование конструкторов — C++11

Один конструктор может вызвать другой:

class Point {
private:
    int x, y;

public:
    Point() : Point(0, 0) {}  // Делегирование
    
    Point(int x_, int y_) : x(x_), y(y_) {}
};

Явное удаление конструктора

class NonCopyable {
public:
    NonCopyable() = default;
    
    // Запрещаем копирование
    NonCopyable(const NonCopyable&) = delete;
    NonCopyable& operator=(const NonCopyable&) = delete;
    
    // Но разрешаем перемещение
    NonCopyable(NonCopyable&&) = default;
};

Construct в контексте Allocator

В STL есть функция std::construct_at() — создает объект на заданном адресе памяти (важна для allocator'ов):

#include <memory>

int main() {
    // Выделяем сырую память
    char buffer[sizeof(int)];
    
    // Конструируем объект в этой памяти
    int* ptr = std::construct_at(reinterpret_cast<int*>(buffer), 42);
    
    std::cout << *ptr;  // 42
    
    // Разрушаем объект
    std::destroy_at(ptr);
    
    return 0;
}

Важные правила

Rule of Five (C++11 и позже):

Если определяешь деструктор, конструктор копирования или оператор присваивания, рассмотри все пять:

class Resource {
public:
    // 1. Конструктор
    Resource() { ptr = new int(0); }
    
    // 2. Деструктор
    ~Resource() { delete ptr; }
    
    // 3. Конструктор копирования
    Resource(const Resource& other) : ptr(new int(*other.ptr)) {}
    
    // 4. Оператор присваивания
    Resource& operator=(const Resource& other) {
        if (this != &other) {
            delete ptr;
            ptr = new int(*other.ptr);
        }
        return *this;
    }
    
    // 5. Конструктор перемещения
    Resource(Resource&& other) noexcept : ptr(other.ptr) {
        other.ptr = nullptr;
    }
    
private:
    int* ptr;
};

Заключение

Construct — это фундаментальная концепция в C++:

• Конструкторы отвечают за правильную инициализацию объектов
• Различные типы конструкторов (копирование, перемещение, делегирование) обеспечивают гибкость
• Правильное использование Member Initialization List критично для производительности
• Rule of Five помогает избежать утечек ресурсов и неопределенного поведения