Object loses data of its members when referred to as pointer to parent class

Question

This program's output is missing the intended values for name and Some string.

Name: , Age: 4, Some string:

Name: , Age: 3, Some string:

If I dynamically allocate memory for each item for myVector in Source.cpp then it works out okay. I'm just wondering why this works out as it does, and what mistakes I have made.

Worth noting is I'm using Visual Studio 2015 C++ compiler.

Parent.h

#pragma once

#include <string>

class Parent
{
public:
    explicit Parent(std::string name, int age)
        : m_name(name), m_age(age) {};

    virtual const std::string toString() const
    {
        return "Name: " + m_name + ", Age: " + std::to_string(m_age);
    }

private:
    std::string m_name;
    int m_age;
};

Child.h

#pragma once

#include "Parent.h"

class Child : public Parent
{
public:
    explicit Child(std::string name, int age, std::string someString)
        : Parent(name, age), m_someString(someString) {};

    virtual const std::string toString() const
    {
        return Parent::toString() + ", Some string: " + m_someString;
    }
private:
    std::string m_someString;
};

Source.cpp

#include <vector>
#include <iostream>

#include "Parent.h"
#include "Child.h"

int main()
{
    std::vector<Parent*> myVector;

    myVector.push_back(&Child("Foo", 4, "Test"));
    myVector.push_back(&Child("Bar", 3, "Test"));

    for (auto p : myVector)
    {
        std::cout << p->toString() << std::endl;
    }

    return 0;
}

Answer 1

When you write

myVector.push_back(&Child("Foo", 4, "Test"));

you create a temporary object of type Child and save its pointer in the vector.

But it's a temporary object that is immediately destroyed when push_back() ends; so the value of the pointer memorized in the vector point to an area of memory that is free and, probably, recycled.

When you use this pointer

std::cout << p->toString() << std::endl;

the behavior is undefined.

Is different when you allocate the memory of the object because the object isn't destroyed immediately after the push_back() call and the object is still available when you call toString() [but remember to call delete, at the end, or (better) use smart pointers].

-- EDIT --

You ask for

care to add how smart pointers fit in this problem

so I show a simple simplified example using std::unique_ptr.

Observe that you have to use emplace_back() instead of push_back(); this is because the isn't a copy constructor (for evident reasons) for std::unique_ptr [anyway, I suggest to use emplace_back(), when possible, instead push_back()].

#include <vector>
#include <memory>
#include <iostream>

struct foo
 { std::string str; };

int main ()
 {
   std::vector<std::unique_ptr<foo>> myV;

   myV.emplace_back(new foo{"one"});
   myV.emplace_back(new foo{"two"});

   for ( auto const & p : myV )
      std::cout << p->str << std::endl;

   return 0;
 }

-- EDIT 2 --

As pointed by Daniel Schepler (thanks!), adding values in the std::vector with

myV.emplace_back(new foo{"one"});

can generate a memory leak in case the new element in myV cause a new allocation of the internal memory of the vector and this allocation fail.

It's an unlikely case but it's possible so I think it's better to avoid the risk (the paranoia is an asset).

A way to solve this problem is call reserve() before emplace_back(), so there is no need to reallocate the internal memory after the new

myV.reserve(2U); // or more
myV.emplace_back(new foo{"one"});
myV.emplace_back(new foo{"two"});

but, to solve this sort of problem, C++14 introduced std::make_unique, so in C++14 can be used together push_back() (but this example require a foo(std::string const &) constructor for the struct foo)

myV.push_back(std::make_unique<foo>("one"));
myV.push_back(std::make_unique<foo>("two"));

Another way, also for C++11, is moving in myV a temporary std::unique_ptr

myV.push_back(std::unique_ptr<foo>{ new foo{"one"} });
myV.push_back(std::unique_ptr<foo>{ new foo{"two"} });

so can be called the move constructor of std::unique_ptr and, in case of failure reallocating the vector, the destructor of the temporary std::unique_ptr free the allocated memory.

Answer 2

When you use std::vector<Parent*> myVector; vector of pointers you have to allocate memory for the object:

   myVector.push_back( new Child("Foo", 4, "Test"));

To avoid dynamic creation of objects use:

std::vector<Parent> myVector

   myVector.push_back(Child("Foo", 4, "Test"));

Since you are asking how to get rid of the allocated objects this is a suggestion below:

clearAndDestroy(&myVector);

And the function is:

template <typename V>
void clearAndDestroy( std::vector<V*> *&myV)
{
    if(myV == NULL)
        return;

    std::set<V*> mySet;

    typename std::vector<V*>::iterator itr;
    typename std::set<V*>::iterator sitr;

    itr = myV->begin();
    while (itr != myV->end())
    {
        mySet.insert(*itr);
        ++itr;
    }

    sitr = mySet.begin();
    while (sitr != mySet.end())
    {
        delete(*sitr);
        ++sitr;
    }

    myV->clear(); // Removes all elements from the vector leaving the container with a size of 0.
}