Rendering the periodic table in C++ using SFML I have created this as an example. It uses SFML as its core dependency along with JSON for modern C++ to load the elements from a file.

Basically what happens is when an object that contains an instance of sf::Drawable is created, its constructor will be responsible for adding it to the draw list.  Its destructor is responsible for removing it from the list.

I am interested in if this is a good approach to dealing with the objects in my program that will need to be rendered or if I should be extending sf::Drawable class directly.

I am also interested in the overall code quality of the entire project. I am aware of the assignment and copy constructors that do nothing.  I am relatively new to C++ (1 semester).

Drawables.cpp

#include "Drawables.hpp"

namespace {
    std::vector&lt;std::shared_ptr&lt;sf::Drawable&gt;&gt; drawList;
}

std::vector&lt;std::shared_ptr&lt;sf::Drawable&gt;&gt;&amp; getDrawList()
{
    return drawList;
}


Element.cpp constructor and destructor

#include "Element.hpp"

#include &lt;exception&gt;

Element::Element()
{
    drawable = std::shared_ptr&lt;sf::RectangleShape&gt;( new sf::RectangleShape(sf::Vector2f{49, 49}) );
    drawable-&gt;setFillColor(sf::Color::Green);
    getDrawList().push_back(drawable);
}

Element::~Element()
{
    // Remove it's drawable from the drawList
    for(int i = getDrawList().size() - 1; i &gt;= 0; --i) {
        if(dynamic_cast&lt;sf::RectangleShape*&gt;(getDrawList()[i].get()) == drawable.get())
        {
            getDrawList().erase(getDrawList().begin() + i);
        }
    }
}


Client.cpp draw function

void Client::draw()
{
    while(window.isOpen()) {
        window.clear();
        for(std::shared_ptr&lt;sf::Drawable&gt; obj : getDrawList()) {
            window.draw(*obj);
        }

        window.display();
    }
}
Looking at the code you've posted here, it's pretty straightforward and I'm able to understand what it does. That's great! I have a few suggestions on how to improve it.
Named Types
One common complaint about the standard template library and templates in general in C++ is the ridiculously long type names that result from using them. I see that in your code here. It's easily solved by creating new named types that represent the common types you use. For example:
std::vector&lt;std::shared_ptr&lt;sf::Drawable&gt;&gt;

uses 3 types with namespaces. If you did this:
typedef std::shared_ptr&lt;sf::Drawable&gt; sharedDrawable;

Then your new type becomes:
std::vector&lt;sharedDrawable&gt;

Or even better, use the new using directive in C++11:
using sharedDrawableVector = std::vector&lt;std::shared_ptr&lt;sf::Drawable&gt;&gt;;

Or something along those lines.
Use C++!
You're writing in C++, but you're using older methods of iterating through containers. In the destructor of Element you're going through the list manually when you could use a std::find() method instead.
Magic Numbers
In the constructor of Element you create a vector with coordinates &lt;49, 49&gt;. What does it mean? What is it? Why &lt;49, 49&gt;? You should create a constant with a name that describes what this represents:
const sf::Vector2f kRectOriginVector {49, 49}; // Or whatever it means

Then use that in the constructor.