试图理解 int main c++ 中删除对象的行为

Question

If I remove either one of the line delete Jim; or delete DiamondWeapon; it works, but Why? What I meant here is, If I just use delete DiamondWeapon; it will work but If I also just use delete Jim; and I remove delete DiamondWeapon; it will work too. I am having hard time wrapping my head around it any help will really be appreciated

#include<iostream>
#include<string>

// Strategy pattern IBehaviour (Iweapon)
// Context Character ( will access this.strategy_.Function() ) ( his.strategy will be Iweapon )
// Concrete Strategies ( Each weapon will have a unique Algorithms for each weapon ).


class Iweapon // ( interface Ibehaviour strategy )
{
public:
    virtual ~Iweapon() { }
    virtual void Use() const = 0; /* Search Results Featured snippet from the web
                                    The const member functions are the functions which are declared as constant in the program.
                                    The object called by these functions cannot be modified.It is recommended
                                    to use const keyword so that accidental changes to object are avoided.A const member function can be called by any type of object.*/
};

class Character // its Context as per UML diagram
{
private:
    Iweapon* iweapon_Strat;
public:
    Character(Iweapon* iweaponStrat = nullptr) :iweapon_Strat(iweaponStrat) { }
    /*{
        this->iweapon_Strat = iweaponStrat;
    }*/
    ~Character() {
        delete  this->iweapon_Strat;
    }

    void SetStrategy(Iweapon* iweaponstrat) {
        delete this->iweapon_Strat;
        this->iweapon_Strat = iweaponstrat;
    }

    void Attack() const //DoSomeLogic() 
    {
        this->iweapon_Strat->Use();
    }
};

// following are ConcreteStrategies(A,B,C ... ) 

class Sword :public Iweapon {
public:
    void Use() const override {
        std::cout << "\n\nSword is Attacking\n\n";
    }
};

class Axe : public Iweapon {
public:
    void Use() const override {
        std::cout << "\n\nAxe is Attacking\n\n";
    }
};

int main() {
    //this work
    {
        Character* Mike = new Character(new Sword);
        Mike->Attack();
        Mike = new Character(new Axe);
        Mike->Attack();

        delete Mike;
    }
    //this work too
    {

        Character* Ryan = new Character();
        Iweapon* SilverWeapon = NULL;

        SilverWeapon = new Sword;
        Ryan->SetStrategy(SilverWeapon);
        Ryan->Attack();

        SilverWeapon = new Axe;
        Ryan->SetStrategy(SilverWeapon);
        Ryan->Attack();

        delete Ryan;
    }
    //this doesn't work but if I remove either one of the line *** delete Jim; *** or *** delete DiamondWeapon; *** it work, But Why
    // i meant here is : Alone if I just have delete DiamondWeapon; it will work
    // but if Alone i also just have delete Jim; and I remove delete DiamondWeapon; it will work too.
    //I am having hard time wraping my head around it any help will really be appreciated
    {
        Iweapon* DiamondWeapon = new Sword();
        Character* Jim = new Character();

        DiamondWeapon = new Sword();
        Jim->SetStrategy(DiamondWeapon);
        Jim->Attack();

        DiamondWeapon = new Axe();
        Jim->SetStrategy(DiamondWeapon);
        Jim->Attack();

        delete DiamondWeapon;
        delete Jim;
    }
    //This also doesn't work
    {
        Iweapon* WoodenWepon = new Sword();
        Character Kim;

        //WoodenWepon = new Sword();
        Kim.SetStrategy(WoodenWepon);
        Kim.Attack();

        WoodenWepon = new Axe();
        Kim.SetStrategy(WoodenWepon);
        Kim.Attack();

        delete WoodenWepon;
        //delete Kim;
    }
    //this Work
    {
        Character* Denzel = new Character();
        Iweapon* weapon = new Sword;
        Denzel->SetStrategy(weapon);
        Denzel->Attack();

        Denzel->SetStrategy(new Axe);
        Denzel->Attack();

        //delete weapon;
        delete Denzel;
    }
    // This also work
    {
        Iweapon* GoldWeapon = NULL;
        Character* Jhon = new Character();

        GoldWeapon = new Sword;
        Jhon->SetStrategy(GoldWeapon);
        Jhon->Attack();

        GoldWeapon = new Axe;
        Jhon->SetStrategy(GoldWeapon);
        Jhon->Attack();

        delete GoldWeapon;
        //delete Jhon;
    }


    //following is just for system pause
    std::string end;
    std::cin >> end;
    return 0;
}

Answer 1

When you do:

void Character::SetStrategy(Iweapon* iweaponstrat) 
{
    delete this->iweapon_Strat;
    this->iweapon_Strat = iweaponstrat;
}

Character takes ownership of the pointer. Your code will handle deletion of the iweaponstrat . It's not clear if it's by design or accident, but since the delete is there, we can say that it dos act as an owner.

Now, when you do:

DiamondWeapon = new Axe();
Jim->SetStrategy(DiamondWeapon); // allows deletes DiamondWeapon
Jim->Attack();

delete DiamondWeapon; // deletes DiamondWeapon

You give an Axe to Jim, giving him ownership and you also delete it yourself. This is asking for trouble, which eventually occurs.

You have two paths from here:

• Use shared_ptr or unique_ptr , strongly recommended.
• Define clear ownership, respect it, and only delete owned objects. Very tough to pull off. C programmers have to deal with this all the time, it saves the overhead of smart pointers, but really not worth the effort at your level.

Answer 2

The problem you have is multiple copies of the same pointer value.

When you

delete DiamondWeapon;
delete Jim; 

The destructor ~Character tries to delete the object that DiamondWeapon also pointed to. This is incorrect C++, and your program's behaviour is undefined.

Rather than passing around raw ( * ) pointers, you should use std::unique_ptr , so that you know there is only ever one pointer pointing to each Weapon and Character

class Character // its Context as per UML diagram
{
private:
    std::unique_ptr<Iweapon> iweapon_Strat;
public:
    Character(std::unique_ptr<Iweapon> iweaponStrat) :iweapon_Strat(iweaponStrat) {}

    void SetStrategy(std::unique_ptr<Iweapon> iweaponstrat) 
    {
        iweapon_Strat = iweaponstrat;
    }

    void Attack() const
    {
        iweapon_Strat->Use();
    }
};

Then you will have a compile time error when you hold extra pointers. As a bonus, your dynamic-storage-duration ("Heap") objects are cleaned up when the scope defining the pointer ends.

int main() 
{
    //this work
    {
        auto Mike = std::make_unique<Character>(std::make_unique<Sword>());
        Mike->Attack();
        Mike = std::make_unique<Character>(std::make_unique<Axe>());
        Mike->Attack();
    }
    //this work too
    {
        
        auto Ryan = std::make_unique<Character>Character();
        std::unique_ptr<Iweapon> SilverWeapon;
    
        SilverWeapon = std::make_unique<Sword>();
        // Ryan->SetStrategy(SilverWeapon); // Error, can't copy SilverWeapon
        Ryan->SetStrategy(std::move(SilverWeapon)); // SilverWeapon is now null
        Ryan->Attack();
    
        SilverWeapon = std::make_unique<Axe>();
        // Ryan->SetStrategy(SilverWeapon); // Error, can't copy SilverWeapon
        Ryan->SetStrategy(std::move(SilverWeapon)); // SilverWeapon is now null
        Ryan->Attack();
    }
    {
        std::unique_ptr<Iweapon> DiamondWeapon = std::make_unique<Sword>();
        auto Jim = std::make_unique<Character>Character();
    
        DiamondWeapon = std::make_unique<Sword>();
        // Jim->SetStrategy(DiamondWeapon); // Error, can't copy DiamondWeapon
        Jim->SetStrategy(std::move(DiamondWeapon)); // DiamondWeapon is now null
        Jim->Attack();
    
        DiamondWeapon = std::make_unique<Axe>();
        // Jim->SetStrategy(DiamondWeapon); // Error, can't copy DiamondWeapon
        Jim->SetStrategy(std::move(DiamondWeapon)); // DiamondWeapon is now null
        Jim->Attack();
    }
    {
        std::unique_ptr<Iweapon> WoodenWepon = std::make_unique<Sword>();
        Character Kim;
    
        // Kim.SetStrategy(WoodenWepon); // Error, can't copy WoodenWeapon
        Kim.SetStrategy(std::move(WoodenWepon)); // WoodenWeapon is now null
        Kim.Attack();
    
        WoodenWepon = std::make_unique<Axe>();
        // Kim.SetStrategy(WoodenWepon); // Error, can't copy WoodenWeapon
        Kim.SetStrategy(std::move(WoodenWepon)); // WoodenWeapon is now null
        Kim.Attack();
    }
    // etc.        
    
    //following is just for system pause
    std::string end;
    std::cin >> end;
    return 0;
}