C++:コンテナをポリモーフィックに枚挙する方法について

生配列やvector等の要素を枚挙することは多いと思います。
その延長線上で、異なる型のコンテナの要素をポリモーフィズム的に枚挙したいのですが、最近のC++なら簡単と思っていたら、意外に難しいです。

しかし、実は私がまだ把握できていない標準ライブラリやboost等にそのような機能をサポートしたクラスがありそうな気もしています。
そのようなクラスをご存知の方、もしくは、簡単な方法をご存知の方がいましたら、是非、ご教授頂けないでしょうか？

詳細

例えば、下記のようなコンテナaFooArray[]とstd::vector<Bar>があるとします。

struct ElementBase
{
    virutal ~ElementBase() { }
    virtual char const* getName() = 0;
};

struct Foo : public ElementBase
{
    std::string const mName;
    char const* getName()
    {
        return mName.c_str();
    }
    :
};
Foo aFooArray[]={ ... };

struct Bar : public ElementBase
{
    char const* mName;
    char const* getName()
    {
        return mName;
    }
    :
};
std::vector<Bar> aBarVector={ ... };

boost:any的なテクニックでそれぞれへのポインタを管理用コンテナに入れてます。
イメージは下記です。（実際にビルドしてないので雰囲気だけ。）

std::vector<any> aContainerList={any(aFooArray), any(aBarVector)};

そして、下記のようなイメージで枚挙処理を行いたいのです。

for (auto&& element : aContainerList[index].getRange())
{
    std::cout << element.getName() << "\n";
}

たぶん、イテレータにboost:anyテクニックを応用すれば可能と思いますが、コピー時にnewすることになります。イテレータはコピー負荷が軽いことが前提な型っぽい（I/Fの多くが参照渡しではなく値渡し）ので、これは避けたいです。

以前、こちらで質問し、その過程で思いついたものの改造版をQiitaへ投稿しました。
そのRangeクラス内にboost::anyテクニックを使って、異なるコンテナ用イテレータを保持することで対応できそうな気がしているのですが、その前に何か良いアイデアがあればと思い、質問させて頂いています。

自作してみました

yohhoyさんに教えていただいたboostの実装を参考にしつつ、自作してみました。
イテレータではなく範囲ベースfor専用のレンジをboost:any的に保持してます。
範囲ベースfor専用のレンジはQiitaへ投稿したrange-based forをより使いやすくするを改造しました。

後、下記ソースではContainerHolderもboost::anyのようにしてますが、こちらは勿体無い気がしてます。コンテナへの参照をunique_ptr<>で保持してます。わざわざヒープ領域に「参照変数領域」を確保していることになるので、なんか違う気がするのですが、良い方法を思いつきませんでした。

poly_range.h

#ifndef POLY_RANGE_H
#define POLY_RANGE_H

#include <memory>

//----------------------------------------------------------------------------
//      範囲ベースforへ渡すリファレンサー(RBForReferencerの特化)
//----------------------------------------------------------------------------

template<class tPolyRangeBase, class tElementBase>
class PolyReferencer
{
    tPolyRangeBase& mPolyRange;
public:
    PolyReferencer(tPolyRangeBase& iPolyRange) : mPolyRange(iPolyRange)
    { }

    tElementBase& operator*()
    {
        return mPolyRange.mHolder->front();
    }
    tElementBase const& operator*() const
    {
        return mPolyRange.mHolder->front();
    }
    void operator++()
    {
        mPolyRange.mHolder->drop_front();
    }
    bool operator!=(PolyReferencer const& iRhs) const
    {
        if (!mPolyRange.mHolder.get())
    return false;
        return !mPolyRange.mHolder->empty();
    }
};

//----------------------------------------------------------------------------
//      枚挙用Range
//----------------------------------------------------------------------------

template<class tElementBase>
class PolyRange
{

//      ---<<< 基底クラス >>>---

    struct HolderBase
    {
        virtual tElementBase      & front()       = 0;
        virtual tElementBase const& front() const = 0;
        virtual void drop_front() = 0;
        virtual bool empty() const = 0;

        // これがないとmsvc 2015の「反復子のデバッグのサポート」用の
        //  イテレータのデストラクタが呼ばれないため、異常動作する。
        virtual ~HolderBase() { }
    };

//      ---<<< 実クラス >>>---

    template<typename tIterator>
    struct Holder : public HolderBase
    {
        tIterator   mBegin;
        tIterator   mEnd;

        Holder(tIterator&& iBegin, tIterator&& iEnd) :
            mBegin(std::forward<tIterator>(iBegin)),
            mEnd  (std::forward<tIterator>(iEnd))
        { }
        ~Holder() = default;

        tElementBase& front()
        {
            return *mBegin;
        }
        tElementBase const& front() const
        {
            return *mBegin;
        }
        void drop_front()
        {
            ++mBegin;
        }
        bool empty() const
        {
            return mBegin == mEnd;
        }
    };

//      ---<<< 各種設定 >>>---

    template<class, class> friend class PolyReferencer;
    typedef PolyReferencer<PolyRange, tElementBase>   PolyReferencer;

//      ---<<< 記録領域 >>>---

    std::unique_ptr<HolderBase> mHolder;

//      ---<<< コンストラクタ >>>---

public:
    PolyRange() { }

    template<typename tIterator>
    PolyRange(tIterator&& iBegin, tIterator&& iEnd) :
        mHolder
        (
            new Holder<tIterator>
            (
                std::forward<tIterator>(iBegin),
                std::forward<tIterator>(iEnd)
            )
        )
    { }

    PolyReferencer begin() {return PolyReferencer(*this);}
    PolyReferencer end()   {return PolyReferencer(*this);}
};

//----------------------------------------------------------------------------
//      コンテナのホルダ
//          保持しているコンテナの範囲ベースfor専用Rangeを獲得する機能を持つ
//----------------------------------------------------------------------------

template<class tElementBase>
class ContainerHolder
{

//      ---<<< 基底クラス >>>---

    struct HolderBase
    {
        virtual ~HolderBase() { }
        virtual PolyRange<tElementBase> getRange() = 0;
    };

//      ---<<< 実クラス >>>---

    template<class tContainer>
    struct Holder : public HolderBase
    {
        tContainer& mContainer;

        Holder(tContainer& iContainer) : mContainer(iContainer)
        { }
        ~Holder() = default;

        PolyRange<tElementBase> getRange()
        {
            return PolyRange<tElementBase>(std::begin(mContainer), std::end(mContainer));
        }
    };

//      ---<<< 記録領域 >>>---

    std::unique_ptr<HolderBase> mHolder;

//      ---<<< コンストラクタ >>>---

public:
    template<typename tContainer>
    ContainerHolder(tContainer& iContainer) :
        mHolder(new Holder<tContainer>(iContainer))
    { }

    PolyRange<tElementBase> getRange()
    {
        return mHolder->getRange();
    }
};

#endif // POLY_RANGE_H

以下、サンプル・ソースです。
main.cpp

#include <iostream>
#include <vector>
#include <string>
#include "poly_range.h"

// 要素の型
struct ElementBase
{
    virtual ~ElementBase() { }
    virtual char const* getName() = 0;
};

struct Foo : public ElementBase
{
    std::string const mName;
    char const* getName()
    {
        return mName.c_str();
    }

    Foo(std::string const& iName) : mName(iName) { }
};

struct Bar : public ElementBase
{
    char const* mName;
    char const* getName()
    {
        return mName;
    }

    Bar(char const* iName) : mName(iName) { }
};

// コンテナ
Foo gFooArray[]={ {"Foo0"}, {"Foo1"}, {"Foo2"} };
std::vector<Bar> gBarVector={ "Bar0", "Bar1", "Bar2" };

// コンテナのリスト
typedef ContainerHolder<ElementBase>    Container;
std::vector<Container> gContainerList;

int main()
{
    std::size_t aFooArrayIndex=gContainerList.size();
    gContainerList.emplace_back(Container(gFooArray));

    std::size_t aBarVectorIndex=gContainerList.size();
    gContainerList.emplace_back(Container(gBarVector));

    std::cout << "--- FooArray ---\n";
    for (auto&& element : gContainerList[aFooArrayIndex].getRange())
    {
        std::cout << element.getName() << "\n";
    }
    std::cout << "\n";

    std::cout << "--- BarVector ---\n";
    for (auto&& element : gContainerList[aBarVectorIndex].getRange())
    {
        std::cout << element.getName() << "\n";
    }
    std::cout << "\n";

    return 0;
}

【補足】
gContainerListへの値設定時、初期化リストを使おうとしたのでずか、ContainerHolderのコピー・コンストラクタが呼び出され、unique_ptrを使っているので暗黙的にdeleteされており、コンパイル・エラーでした。
push_backやemplace_backではムーブだけでよいので、原因はよく分かりませんでした。
もし、分かる方がいらっしゃいましたら、何故初期化リストではコピー・コンストラクタが必要になるのかご教授頂けると幸いです。