Sorting polymorphic classes
Avoid using namespace std. You just don't know what-all symbols that spews into your global namespace, causing lots of grief when you least suspect it.
Your interface should contain protected default-constructor, copy-constructor, and copy-assignment-operator.
You should use =default when you are explicitly defaulting a special-member-function, so it can stay trivial.
If you use a struct, default-access is public instead of private, which would allow you to dispense with some access-specifiers.
Though that can be controversial for classes which have non-public members, or generally any feature not supported by C.




struct Comparable {
    virtual ~Comparable() = default;
    virtual int compare(const Comparable&amp; other) const = 0;
protected:
    Comparable() = default;
    Comparable(const Comparable&amp;) = default;
    Comparable&amp; operator=(const Comparable&amp;) = default;
};



HighScoreElement should be marked final, prohibiting further derivation and thus allowing some optimizations, unless you redesign it for inheritance. Which you actually shouldn't do.
Don't needlessly create copies of non-trivial types on call / return, use constant references.
Only HighScoreElement::getName fails that now.
Consider marking overrides with override, which in contrast to repeating virtual actually is meaningful.
You should bail out immediately if your dynamic_cast fails.
Consider just changing it to a reference-cast so that's automated.
Avoid useless blocks and concomitant further indentation.
After a return, processing leaves the function immediately.




int compare(const Comparable&amp; other) const override {
    auto&amp;&amp; x = dynamic_cast&lt;const HighScoreElement&amp;&gt;(other);
    if(getScore() &lt; x.getScore())
        return -1;
    else if(getScore() &gt; x.getScore())
        return 1;
    if(getName() &lt; x.getName())
        return -1;
    else if(getName() &gt; x.getName())
        return 1;
    return 0;
}



There's std::swap in &lt;utility&gt; for swapping two items.
Insertion-sort isn't the best algorithm there is, but it will get the job done, as long as the vector isn't too big.
You should use a smart-pointer to manage your elements, best-suited is probably std::unique_ptr from &lt;memory&gt;.
You could use list-initialization to initialize your vector instead of adding the elements afterwards one-by-one:

vector&lt;Comparable*&gt; v {
    new HighScoreElement("Kate Bush", 10),
    new HighScoreElement("Peter Gabriel", 20),
    ...
};

return 0; is implicit in C++ and C99+ for main.