Спринт 15. Конструкторы и деструкторы.

-----------------------------------------------------------------------
main.cpp
-----------------------------------------------------------------------
#include <array>
#include <iostream>
#include <string>

#include "identity_document.h"
#include "passport.h"
#include "driving_licence.h"
#include "international_driving_licence.h"
#include "travel_pack.h"

using namespace std;

void PrintInfo(const IdentityDocument& doc) {doc.PrintID();}
void PrintInfo() {IdentityDocument::PrintUniqueIDCount();}
void PrintInfo(const Passport& pass) {pass.PrintVisa("France"s);}

IdentityDocument PrintInfo(int i) {
    Passport pass;

    cout << "PrintInfo("sv << i << ")"sv << endl;
    pass.PrintID();

    return pass;
}

void PrintDrivingLicence(DrivingLicence dr_lic) {dr_lic.PrintID();}

int main() {

    cout << "Test1"sv << endl;

    Passport pass;
    PrintInfo(pass);
    PrintInfo(3).PrintID();

    cout << "Test2"sv << endl;
    array<IdentityDocument*, 3> docs = {(IdentityDocument*)(new Passport()),
                                        (IdentityDocument*)(new DrivingLicence()),
                                        (IdentityDocument*)(new Passport())};

    for (const auto* doc : docs) {doc->PrintID();}

    for (size_t i = 0; i < docs.size(); ++i) {docs[i]->Delete();}

    cout << "Test3"sv << endl;
    array<IdentityDocument, 3> docs2 = {Passport(),
                                        DrivingLicence(),
                                        IdentityDocument()};

    for (size_t i = 0; i < docs2.size(); ++i) {docs2[i].PrintID();}

    PrintInfo(docs2[0]);

    cout << "Test4"sv << endl;

    IdentityDocument::PrintUniqueIDCount();

    cout << "Test5"sv << endl;

    Passport pass2;
    pass2.PrintUniqueIDCount();
}
-----------------------------------------------------------------------
identity_document.h
-----------------------------------------------------------------------
#pragma once
#include <iostream>
#include <string>

using namespace std::literals;

class IdentityDocument {
public:

    using PRINT_ID = void(*)(const IdentityDocument*);
    using DELETE = void(*)(IdentityDocument*);

    struct Vtable {
        PRINT_ID print_id_;
        DELETE delete_;
    };

    static IdentityDocument::Vtable virtual_table;

    static void set_virtual_table(IdentityDocument* obj) {*(IdentityDocument::Vtable**)obj = &IdentityDocument::virtual_table;}

    const Vtable* get_virtual_table() const {return v_ptr_;}
    Vtable* get_virtual_table() {return v_ptr_;}

    IdentityDocument() : unique_id_(++unique_id_count_) {
        IdentityDocument::set_virtual_table(this);
        std::cout << "IdentityDocument::Ctor() : "sv << unique_id_ << std::endl;
    }

    IdentityDocument(const IdentityDocument& other) : unique_id_(++unique_id_count_) {
        IdentityDocument::set_virtual_table(this);
        std::cout << "IdentityDocument::CCtor() : "sv << unique_id_ << std::endl;
    }

    ~IdentityDocument() {
        unique_id_count_-=1;
        std::cout << "IdentityDocument::Dtor() : "sv << unique_id_ << std::endl;
    }

    IdentityDocument& operator=(const IdentityDocument&) = delete;

    static void PrintUniqueIDCount() {
        std::cout << "unique_id_count_ : "sv << unique_id_count_ << std::endl;
    }

    int GetID() const {return unique_id_;}

    void PrintID() const {get_virtual_table()->print_id_(this);}
    static void PrintID(const IdentityDocument* obj) {
        std::cout << "IdentityDocument::PrintID() : "sv << obj->unique_id_ << std::endl;
    }

    void Delete() {get_virtual_table()->delete_(this);}
    static void Delete(IdentityDocument* obj) {delete obj;}

private:
    IdentityDocument::Vtable* v_ptr_;

    static int unique_id_count_;
    int unique_id_;
};

int IdentityDocument::unique_id_count_ = 0;
IdentityDocument::Vtable IdentityDocument::virtual_table = {IdentityDocument::PrintID,
                                                            IdentityDocument::Delete};
-----------------------------------------------------------------------
passport.h
-----------------------------------------------------------------------
#pragma once
#include <iostream>
#include <string>
#include <ctime>

#include "identity_document.h"

using namespace std::literals;

class Passport {
public:

    using PRINT_ID = void(*)(const Passport*);
    using DELETE = void(*)(Passport*);
    using PRINT_VISA = void(*)(const Passport*, const std::string& country);

    struct Vtable {
        PRINT_ID print_id_;
        DELETE delete_;
        PRINT_VISA print_visa_;
    };

    static Passport::Vtable virtual_table;

    static void set_virtual_table(Passport* obj) {*(Passport::Vtable**)obj = &Passport::virtual_table;}

    const Vtable* get_virtual_table() const {return (const Passport::Vtable*)identity_document_.get_virtual_table();}
    Vtable* get_virtual_table() {return (Passport::Vtable*)identity_document_.get_virtual_table();}

    Passport() : identity_document_()
               , expiration_date_(GetExpirationDate()) {

        Passport::set_virtual_table(this);
        std::cout << "Passport::Ctor()"sv << std::endl;
    }

    Passport(const Passport& other) : identity_document_(other.identity_document_)
                                    , expiration_date_(other.expiration_date_) {
        Passport::set_virtual_table(this);
        std::cout << "Passport::CCtor()"sv << std::endl;
    }

    ~Passport() {
        IdentityDocument::set_virtual_table((IdentityDocument*)this);
        std::cout << "Passport::Dtor()"sv << std::endl;
    }

    int GetID() const {return identity_document_.GetID();}
    operator IdentityDocument() {return identity_document_;}

    void Delete() {get_virtual_table()->delete_(this);}
    static void Delete(Passport* obj) {delete obj;}

    void PrintID() const {get_virtual_table()->print_id_(this);}
    static void PrintID(const Passport* obj) {
        std::cout << "Passport::PrintID() : "sv << obj->GetID();
        std::cout << " expiration date : "sv << obj->expiration_date_.tm_mday
                  << "/"sv << obj->expiration_date_.tm_mon
                  << "/"sv << obj->expiration_date_.tm_year + 1900 << std::endl;
    }

    void PrintVisa(const std::string& country) const {get_virtual_table()->print_visa_(this, country);}
    static void PrintVisa(const Passport* obj, const std::string& country) {
        std::cout << "Passport::PrintVisa("sv << country << ") : "sv << obj->GetID() << std::endl;
    }

    void PrintUniqueIDCount() {IdentityDocument::PrintUniqueIDCount();}

private:
    IdentityDocument identity_document_;
    const tm expiration_date_;

    tm GetExpirationDate() {
        time_t t = time(nullptr);
        tm exp_date = *localtime(&t);
        exp_date.tm_year += 10;
        mktime(&exp_date);
        return exp_date;
    }
};

Passport::Vtable Passport::virtual_table = {Passport::PrintID,
                                            Passport::Delete,
                                            Passport::PrintVisa};
-----------------------------------------------------------------------
driving_licence.h
-----------------------------------------------------------------------
#pragma once
#include <iostream>
#include <string>

#include "identity_document.h"

using namespace std::literals;

class DrivingLicence {
public:

    using DELETE = void(*)(DrivingLicence*);
    using PRINT_ID = void(*)(const DrivingLicence*);

    struct Vtable {
        PRINT_ID print_id_;
        DELETE delete_;
    };

    static DrivingLicence::Vtable virtual_table;

    static void set_virtual_table(DrivingLicence* obj) {*(DrivingLicence::Vtable**)obj = &DrivingLicence::virtual_table;}

    const Vtable* get_virtual_table() const {return (const DrivingLicence::Vtable*)identity_document_.get_virtual_table();}
    Vtable* get_virtual_table() {return (DrivingLicence::Vtable*)identity_document_.get_virtual_table();}

    DrivingLicence() : identity_document_() {
        DrivingLicence::set_virtual_table(this);
        std::cout << "DrivingLicence::Ctor()"sv << std::endl;
    }

    DrivingLicence(const DrivingLicence& other) : identity_document_(other.identity_document_) {
        DrivingLicence::set_virtual_table(this);
        std::cout << "DrivingLicence::CCtor()"sv << std::endl;
    }

    ~DrivingLicence() {
        IdentityDocument::set_virtual_table((IdentityDocument*)this);
        std::cout << "DrivingLicence::Dtor()"sv << std::endl;
    }

    int GetID() const {return identity_document_.GetID();}
    operator IdentityDocument() {return identity_document_;}

    void Delete() {get_virtual_table()->delete_(this);}
    static void Delete(DrivingLicence* obj) {delete obj;}

    void PrintID() const {get_virtual_table()->print_id_(this);}
    static void PrintID(const DrivingLicence* obj) {std::cout << "DrivingLicence::PrintID() : "sv << obj->GetID() << std::endl;}

    void PrintUniqueIDCount() {IdentityDocument::PrintUniqueIDCount();}

private:
    IdentityDocument identity_document_;
};

DrivingLicence::Vtable DrivingLicence::virtual_table = {DrivingLicence::PrintID,
                                                        DrivingLicence::Delete};
-----------------------------------------------------------------------
international_driving_licence.h
-----------------------------------------------------------------------
#pragma once
#include <iostream>
#include <string>

#include "driving_licence.h"

using namespace std::literals;

class InternationalDrivingLicence {
public:

    using DELETE = void(*)(InternationalDrivingLicence*);
    using PRINT_ID = void(*)(const InternationalDrivingLicence*);

    struct Vtable {
        PRINT_ID print_id_;
        DELETE delete_;
    };

    static InternationalDrivingLicence::Vtable virtual_table;

    static void set_virtual_table(InternationalDrivingLicence* obj) {*(InternationalDrivingLicence::Vtable**)obj
                                                                    = &InternationalDrivingLicence::virtual_table;}

    const Vtable* get_virtual_table() const {return (const InternationalDrivingLicence::Vtable*)driving_licence_.get_virtual_table();}
    Vtable* get_virtual_table() {return (InternationalDrivingLicence::Vtable*)driving_licence_.get_virtual_table();}

    InternationalDrivingLicence() : driving_licence_() {
        InternationalDrivingLicence::set_virtual_table(this);
        std::cout << "InternationalDrivingLicence::Ctor()"sv << std::endl;
    }

    InternationalDrivingLicence(const InternationalDrivingLicence& other) : driving_licence_(other.driving_licence_) {
        InternationalDrivingLicence::set_virtual_table(this);
        std::cout << "InternationalDrivingLicence::CCtor()"sv << std::endl;
    }

    ~InternationalDrivingLicence() {
        DrivingLicence::set_virtual_table((DrivingLicence*)this);
        std::cout << "InternationalDrivingLicence::Dtor()"sv << std::endl;
    }

    int GetID() const {return driving_licence_.GetID();}
    operator DrivingLicence() const {return driving_licence_;}

    void Delete() {get_virtual_table()->delete_(this);}
    static void Delete(InternationalDrivingLicence* obj) {delete obj;}

    void PrintID() const {get_virtual_table()->print_id_(this);}
    static void PrintID(const InternationalDrivingLicence* obj) {std::cout << "InternationalDrivingLicence::PrintID() : "sv << obj->GetID() << std::endl;}

private:
    DrivingLicence driving_licence_;
};

InternationalDrivingLicence::Vtable InternationalDrivingLicence::virtual_table = {InternationalDrivingLicence::PrintID,
                                                                                  InternationalDrivingLicence::Delete};
-----------------------------------------------------------------------
travel_pack.h
-----------------------------------------------------------------------
#pragma once
#include <iostream>
#include <string>

#include "identity_document.h"

using namespace std::literals;

class TravelPack {
public:

    using DELETE = void(*)(TravelPack*);
    using PRINT_ID = void(*)(const TravelPack*);

    struct Vtable {
        PRINT_ID print_id_;
        DELETE delete_;
    };

    static TravelPack::Vtable virtual_table;

    static void set_virtual_table(TravelPack* obj) {*(TravelPack::Vtable**)obj = &TravelPack::virtual_table;}

    const Vtable* get_virtual_table() const {return (const TravelPack::Vtable*)identity_document_.get_virtual_table();}
    Vtable* get_virtual_table() {return (TravelPack::Vtable*)identity_document_.get_virtual_table();}

    TravelPack() : identity_document_()
                 , identity_doc1_((IdentityDocument*)(new Passport()))
                 , identity_doc2_((IdentityDocument*)(new DrivingLicence())) {

        TravelPack::set_virtual_table(this);
        std::cout << "TravelPack::Ctor()"sv << std::endl;
    }

    TravelPack(const TravelPack& other) : identity_document_(other.identity_document_)
                                        , identity_doc1_((IdentityDocument*)(new Passport(*(Passport*)(other.identity_doc1_))))
                                        , identity_doc2_((IdentityDocument*)(new DrivingLicence(*(DrivingLicence*)(other.identity_doc2_))))
                                        , additional_pass_(other.additional_pass_)
                                        , additional_dr_licence_(other.additional_dr_licence_) {

        TravelPack::set_virtual_table(this);
        std::cout << "TravelPack::CCtor()"sv << std::endl;
    }

    ~TravelPack() {
        identity_doc1_->Delete();
        identity_doc2_->Delete();
        IdentityDocument::set_virtual_table((IdentityDocument*)this);
        std::cout << "TravelPack::Dtor()"sv << std::endl;
    }

    int GetID() const {return identity_document_.GetID();}
    operator IdentityDocument() {return identity_document_;}

    void Delete() {get_virtual_table()->delete_(this);}
    static void Delete(TravelPack* obj) {delete obj;}

    void PrintID() const {get_virtual_table()->print_id_(this);}
    static void PrintID(const TravelPack* obj) {
        obj->identity_doc1_->PrintID();
        obj->identity_doc2_->PrintID();
        obj->additional_pass_.PrintID();
        obj->additional_dr_licence_.PrintID();
    }

    void PrintUniqueIDCount() {IdentityDocument::PrintUniqueIDCount();}

private:
    IdentityDocument identity_document_;

    IdentityDocument* identity_doc1_;
    IdentityDocument* identity_doc2_;

    Passport additional_pass_;
    DrivingLicence additional_dr_licence_;
};

TravelPack::Vtable TravelPack::virtual_table = {TravelPack::PrintID,
                                                TravelPack::Delete};
-----------------------------------------------------------------------
main_origin.cpp
-----------------------------------------------------------------------

empty