Neočekávaný výstup v c++ třídy a kopírování objektů do jiného objektu

Tady je jeden příklad, jak k realizaci pěti speciálních členských funkcí v pravidlo 5. První, výchozí konstruktor a konstruktor, přičemž řetězec by mohl být kombinovány tak, že výchozí konstruktor deleguje na jeden, přičemž řetězec:

Robot(const std::string& name) :
    _history(new std::vector<int>()),
    name(name)
{};

Robot() : Robot("DEFAULT") {}   // Delegate

Zde je pravidlo pěti:

// --- rule of five ---
Robot(const Robot& rhs) :                   // copy constructor
    workUnit(rhs.workUnit),
    _history(new std::vector<int>(*rhs._history)),
    name(rhs.name)
{}
Robot(Robot& rhs) noexcept :                // move constructor
    workUnit(rhs.workUnit),
    // use exchange to steal pointer and replace with nullptr:
    _history(std::exchange(rhs._history, nullptr)),
    name(std::move(rhs.name))
{}
Robot& operator=(const Robot& rhs) {        // copy assignment operator
    workUnit = rhs.workUnit;
    *_history = *rhs._history; // use vector's copy assignment operator
    name = rhs.name;
    return *this;
}
Robot& operator=(Robot&& rhs) noexcept {    // move assignment operator
    workUnit = rhs.workUnit;
    // swap pointers, let rhs destroy *this old pointer:
    std::swap(_history, rhs._history);
    name = std::move(rhs.name);
    return *this;
}
~Robot() {                                  // destructor
    std::cout << name << ": Goodbye!\n";
    delete _history;
};
// --- rule of five end ---

Když máte co do činění s raw vlastnit ukazatele, můžete použít std::unique_ptr se dostat některé zdarma. Místo

std::vector<int>* _history;

to:

std::unique_ptr<std::vector<int>> _history;

Takže třída se stává:

Robot(const std::string& name) :
    _history(std::make_unique<std::vector<int>>()),
    name(name)
{};
Robot() : Robot("DEFAULT") {}   // Delegate

A pravidlo pěti stává trochu jednodušší:

// --- rule of five ---
Robot(const Robot& rhs) :                         // copy constructor
    workUnit(rhs.workUnit),
    _history(std::make_unique<std::vector<int>>(*rhs._history)),
    name(rhs.name)
{}

// move constructor handled by unique_ptr, just default it:
Robot(Robot& rhs) noexcept = default;

Robot& operator=(const Robot& rhs) {              // copy assignment operator
    workUnit = rhs.workUnit;
    *_history = *rhs._history;
    name = rhs.name;
    return *this;
}

// move assignment operator handled by unique_ptr, just default it:
Robot& operator=(Robot&& rhs) noexcept = default;

~Robot() {                                        // destructor
    std::cout << name << ": Goodbye!\n";
    // delete _history;                      // no delete needed, unique_ptr does it
};
// --- rule of five end ---

Můžete také chtít vrátit _history odkazem z getHistory(). Níže pracuje pro obě raw ukazatel a unique_ptr verze a dává hezčí rozhraní do třídy:

const std::vector<int>& getHistory() const { return *_history; };
      std::vector<int>& getHistory()       { return *_history; };

Když zničíte robota, zničit jeho pracovní historii. Co se stane při kopírování robot, je, že dostane kopii ukazatel na pracovní historii. Jinými slovy, druhý robot má ukazatel na přesně stejný vektor celých čísel, že první robot vytvořil.

Nyní, když první robot je zničen, to odstraní historie, které je vlastní. To je důvod, proč druhý robot je pracovní historie je neplatný, když vytištěno: že paměť byla uvolněna.

Lze navrhnout dvě možné řešení pro toto. Jeden je zavést "Pravidlo 5", který, mimo jiné, umožňují určit (definovat copy konstruktor a operátor přiřazení), jak jeden robot mohl udělat kopii jiného robota, včetně vytvoření pracovní historii, že by vlastní a které nemohly být odstraněny tím, že první robot. Druhá je použití "Shared ukazatel" řídit životnost pracovní historii.

Vzhledem k tomu, že práce historie zní jako něco, co by nemělo být sdílen více robotů, šel bych pro první možnost.

r2 = r1;

Používá implicitně prohlásil splácet kopírování operátor přiřazení. Vzhledem k tomu, výchozí provádění jednoduše dělá memberwise kopírování, starý _history ukazatel je jednoduše přepsán a vektor je nečekaně ve vlastnictví 2 objekty kromě staré vektor uložen v r2 před úkol není osvobozen správně.

Ty by měly realizovat přesunout konstruktor + přesunout přiřazení operátora, copy constructor + kopie přiřazení operátora, nebo obě dvojice.

To je jen nutné to udělat i když, pokud budete mít _history vektorové syrové ukazatel; mění se std::vector<int> výchozí implementace konstruktérů/operátory přiřazení jsou přítomny a pracujeme, mění na std::unique_ptr<std::vector<int>> výsledkem by v kopírovací operátor přiřazení/copy constructor být odstraněn.

Poznámka: Pro všechny přístupy by jsi měl změnit návrat typů whoAmI a getHistory jak je popsáno v poslední možnost.

Operátor přiřazení kopírování

To udržuje oba objekty, "neporušený", po zadání.

Vlastní implementaci správně zkopírovat ukazatel je nutné.

class Robot{
    ...

public:
    ...

    Robot(Robot const& other)
        : workUnit(other.workUnit), _history(new std::vector<int>(*other._history)), name(other.name)
    {}

    Robot& operator=(Robot const& other)
    {
        workUnit = other.workUnit;
        *_history = *other._history;
        name = other.name;
        return *this;
    }
    ...
};

Přesunout úkol

To ponechává vyžaduje, abyste změnit přiřazení r2 = std::move(r1); na odchodu r1 ve státě, kde pouze destruktor je zaručena do práce. Všimněte si, že to bys neměla tisk name v destructor, od r2jméno bylo přesunuto od.

class Robot{
    ...

public:
    ...

    Robot(Robot && other) noexcept
        : workUnit(other.workUnit), _history(other._history), name(std::move(other.name))
    {
        other._history = nullptr; // prevent double free; we're the sole owner of the vector now
    }

    Robot& operator=(Robot && other) noexcept
    {
        workUnit = other.workUnit;

        delete _history; // old history no longer needed -> free to avoid memory leak
        _history = other->_history;
        other._history = nullptr; // prevent double free; we're the sole owner of the vector now
        
        name = std::move(other.name);
        return *this;
    }
    ...
};

Jednoduchá možnost (Doporučeno)

Jít s std::vector<int> a jít s výchozí konstruktory:

class Robot{

private:
    int workUnit = 0;
    std::vector<int> _history; // pointer to vector of ints (NOT a vector of int pointers)

public:
    Robot() : name("DEFAULT") {}
    Robot(const std::string& name) : name(name){}
    ~Robot(){std::cout << name << ": Goodbye!" << std::endl; }

    Robot(Robot const&) = default;
    Robot& operator=(Robot const&) = default;

    // don't print name in the destructor, if you uncomment the following 2 members
    // Robot(Robot&&) = default;
    // Robot& operator=(Robot&&) = default;

    std::string const& whoAmI() const {return name;} // user should be able to decide, if a copy is needed
    void setName(const std::string& name){this->name = name;}
    void work();
    void printWork() const;
    std::vector<int> const& getHistory() const { return _history; } // don't return raw a pointer here

    std::vector<int>& getHistory() { return _history; } // overload only needed, if the history needs to be modifiable from the outside

protected:
    std::string name;  

      
};

Pokud historie se vrátil musí být modifikovatelné pro const objekt, zvážit _history mutable.