Question

I have class like this

class variable
{
    public:
        variable(int _type=0) : type(_type), value(NULL), on_pop(NULL)
        {
        }

        virtual ~variable()
        {
            if (type)
            {
                std::cout << "Variable Deleted" <<std::endl;
                on_pop(*this);
                value=NULL;
            }
        }

        int     type;
        void*   value;
        typedef void(*func1)(variable&);
        func1 on_pop;
}

And then I push instances into a std::vector like this:

stack.push_back(variable(0));

I expect that the destructor of variable will be called but the if won’t enter until a value is assigned to type because I expect the constructor I provide will be called when the instance is copied into the vector. But for some reason it is not.

After calling stack.push_back the destructor (of the copy?) is ran and type has some random value like if the constructor was never called.

I can’t seem to figure what I am doing wrong. Please help! ^_^

EDIT:

Ok here is a self contained example to show what I mean:

#include <iostream>
#include <vector>

class variable
{
    public:
        variable(int _type=0) : type(_type), value(NULL), on_pop(NULL)
        {
        }

        ~variable()
        {
            if (type)
            {
                std::cout << "Variable Deleted" <<std::endl;
                on_pop(*this);
                value=NULL;
            }
        }

        int     type;
        void*   value;

        typedef void(*func1)(variable&);
        func1 on_pop;
};

static void pop_int(variable& var)
{
    delete (int*)var.value;
}

static void push_int(variable& var)
{
    var.type = 1;
    var.value = new int;
    var.on_pop = &pop_int;
}

typedef void(*func1)(variable&);
func1 push = &push_int;

int main()
{
    std::vector<variable>   stack;

    stack.push_back(variable(0));
    push(stack[stack.size()-1]);

    stack.push_back(variable(0));
    push(stack[stack.size()-1]);

    stack.push_back(variable(0));
    push(stack[stack.size()-1]);

    return 0;
}

The program above outputs the following:

Variable Deleted
Variable Deleted
Variable Deleted
Variable Deleted
Variable Deleted
Variable Deleted

Process returned 0 (0x0)   execution time : 0.602 s
Press any key to continue.

Answer 1

Welcome to RVO and NRVO. This basically means that the compiler can skip creating an object if it’s redundant- even if it’s constructor and destructor have side effects. You cannot depend on an object which is immediately copied or moved to actually exist.

Edit: The actual value in the vector cannot be ellided at all. Only the intermediate variable variable(0) can be ellided. The object in the vector must still be constructed and destructed as usual. These rules only apply to temporaries.

Edit: Why are you writing your own resource management class? You could simply use unique_ptr with a custom deleter. And your own RTTI?

Every object that was destructed must have been constructed. There is no rule in the Standard that violates this. RVO and NRVO only become problematic when you start, e.g., modifying globals in your constructors/destructors. Else, they have no impact on the correctness of the program. That’s why they’re Standard. You must be doing something else wrong.

Ultimately, I’m just not sure exactly WTF is happening to you and why it’s not working or what “working” should be. Post an SSCCE.

Edit: In light of your SSCCE, then absolutely nothing is going wrong whatsoever. This is entirely expected behaviour. You have not respected the Rule of Three- that is, you destroy the resource in your destructor but make no efforts to ensure that you actually own the resource in question. Your compiler-generated copy constructor is blowing up your logic. You must read about the Rule of Three, copy and swap and similar idioms for resource handling in C++, and preferably, use a smart pointer which is already provided as Standard like unique_ptr which does not have these problems.

After all, you create six instances of variable– three temporaries on the stack, and three inside the vector. All of these have their destructors called. The problem is that you never considered the copy operation or what copying would do or what would happen to these temporaries (hint: they get destructed).

Consider the equal example of

int main()
{
    variable v(0);
    push_int(v);
    variable v2 = v;
    return 0;
}

Variable v is constructed and allocates a new int and everything is dandy. But wait- then we copy it into v2. The compiler-generated constructor copies all the bits over. Then both v2 and v are destroyed- but they both point to the same resource because they both hold the same pointer. Double delete abounds.

You must define copy (shared ownership – std::shared_ptr) or move (unique ownership – std::unique_ptr) semantics.

Edit: Just a quick note. I observe that you actually don’t push into items until after they’re already in the vector. However, the same effect is observed when the vector must resize when you add additional elements and the fundamental cause is the same.

The destructor is called 6 times. A constructor is called six times. Just not the one you intended.