本旨

ここでは、多重継承を喜んで採用できます。

主なアイデアは、セットにタグを付ける基本クラスを作成し、それをすべてのセットの基本クラスにすることです。次に、必要な各テンプレート引数のセットクラスを明示的にインスタンス化し、セットコンテナとタグ付けインターフェイスの両方からパブリックに継承された空のクラスを作成します。そうすれば、追加するものは何もありません。コードの複製は必要ないようです。

とにかく、すべてのテンプレートの特殊化で機能するいくつかの（おそらく仮想）関数を作成する必要があります。保持するものに関係なく、同じコンテキストで単一の変数を使用できる必要があります。ただしusing、継承のために宣言を増やして一部のコードを減らし、暗黙的な型変換を使用することができます（たとえば、セットに数値のみが含まれている場合）。

#include <set>

class setInterface {
    /* Code common for all set template specializations
       (you have to have some common interface anyway) */
};

template <typename T> class TSet: public setInterface, std::set<T> {
    using std::set<T>::set;
    /* more using-declarations or templated versions of some functions
       You can use SFINAE here to achieve more magical results,
       or use template specializations for specific types. */
};

using intSet = TSet<int>;
using doubleSet = TSet<double>;

class B {
public:
  setInterface values;
};

int main () {
    B b;
    b.values = intSet {1, 2, 3} ;
    b.values = doubleSet {1., 2., 3.};
}

PS：構文を使用したテンプレートを提供してくれた@ Jarod42に感謝します。

実用的な実装

以下の仮定がなされています。

• に変換可能なアイテムのセットのみを使用しlong longます。void*一般的なケースで使用し、利便性/安全性のためにいくつかの追加メソッドを追加できます。
• 私たちは正気であり、異なるタイプのセットのイテレータを比較することは決してありません。結果は予測できません。
• nullptrsのポインタをチェックする必要はありません（まあ、それは私のコードサンプルにそれ以上の価値をもたらさないでしょう、確かにあなたが常に必要とする現実の世界では）。

このソリューションは、非定数の開始/終了を使用し、の新しい光沢のある範囲ベースを使用して、マップを反復処理できます。main;を参照してください。コンパイルして実行し（-std=c++14）、結果を確認します。

#include <set>
#include <memory>
#include <iostream>

using common_denominator_type = long long;

class setInterface {
protected:
    class iterator_impl;
public:
    class iterator {
    public:
        iterator (iterator_impl* impl) : impl (impl) {}

        iterator& operator++ () { ++*impl; return *this; };
        bool operator != (const iterator& rhs) const { return *impl != *rhs.impl; };
        common_denominator_type operator* () const { return **impl; };
    private:
        std::shared_ptr <iterator_impl> impl;
    };
    virtual iterator begin() = 0;
    virtual iterator end() = 0;
    virtual size_t size() const = 0;
protected:
    class iterator_impl {
    public:
        virtual iterator_impl& operator++ () = 0;
        virtual bool operator != (const iterator_impl&) const = 0;
        virtual common_denominator_type operator* () const = 0;
        virtual void* as_std_set_iterator () = 0;
        virtual const void* as_std_set_iterator () const = 0;
    };
};

template <typename T> class TSet: public setInterface, std::set<T> {
public:
    using std::set<T>::set;
    size_t size () const override { return std::set<T>::size(); }
    iterator begin () override { return iterator (new TSet<T>::iterator_impl (std::set<T>::begin())); }
    iterator end   () override { return iterator (new TSet<T>::iterator_impl (std::set<T>::end  ())); }
protected:
    class iterator_impl: public setInterface::iterator_impl {
    public:
        using std_it = typename std::set<T>::iterator;
        iterator_impl (std_it&& _) : m_real_iterator(std::move (_)) {}
        iterator_impl& operator++ () override { ++m_real_iterator; return *this; }
        bool operator != (const setInterface::iterator_impl& rhs) const override {
            return *reinterpret_cast <const std_it*>(as_std_set_iterator())
                    !=
                   *reinterpret_cast <const std_it*>(rhs.as_std_set_iterator());
        }
        common_denominator_type operator* () const override { return *m_real_iterator; }
        void* as_std_set_iterator () override { return &m_real_iterator; }
        const void* as_std_set_iterator () const override { return &m_real_iterator; }
    private:
        std_it m_real_iterator;
    };
};

using intSet = TSet<int>;
using longSet = TSet<long>;

class B {
public:
    std::shared_ptr <setInterface> values;
};

std::ostream& operator<< (std::ostream& str, B& b) {
    str << "[" << b.values->size() << "] [";
    for (auto i = b.values->begin(); i != b.values->end(); ++i)
        str << *i << " ";
    str << "][";
    for (auto i : *b.values)
        str << i << " ";
    return str << "]";
}

int main () {
    B b;
    b.values.reset (new intSet {1, 2, 3});
    std::cout << b << std::endl;
    b.values.reset (new longSet {10l, 20l, 30l});
    std::cout << b << std::endl;
}