Comment suis-je fortement typé de types non primitifs?

Peut-être que vous pourriez utiliser l'héritage privé et certains en utilisant code> S?

class Gadget : Widget { using Widget::Widget; using Widget::foo; ... };

En gros, vous avez besoin de deux classes non liées avec le même comportement. J'utiliserais un modèle paramétré pour cela:

template<int tag> class WidgetGadget { ... };
typedef WidgetGadget<0> Widget;
typedef WidgetGadget<1> Gadget;

boost_strong_typedf suppose en fait que les types sont équatables ( == code>), assignable ( = code>) et moins que comparable ( ).

Si votre type n'est pas, la macro donne le code de code qui ne compile pas, comme vous avez été témoin. Vous pouvez faire rouler votre propre macro ou fournir des implémentations pour les opérations requises. P>

Vous pouvez trouver un personnalisé_strong_typef code> dans cette réponse de Februari 2012: Comment utiliser des opérateurs de comparaison sur la variante avec des types contenus? strong>, qui évite explicitement l'obtention du comportement de comparaison par défaut P>

Mise à jour forte> a rendu l'exemple plus explicite pour votre cas d'utilisation, le voir Vivez sur Coliru strong> p>

//a user defined type
class Widget{};
class Frobnicator{};

/////////////////////////////////////////////////////
// copied and reduced from boost/strong_typedef.hpp
#define CUSTOM_STRONG_TYPEDEF(T, D)                                 \
struct D                                                            \
    /*: boost::totally_ordered1< D           */                     \
    /*, boost::totally_ordered2< D, T        */                     \
    /*> >                                    */                     \
{                                                                   \
    T t;                                                            \
    explicit D(const T t_) : t(t_) {};                              \
    D(){};                                                          \
    D(const D & t_) : t(t_.t){}                                     \
    D & operator=(const D & rhs) { t = rhs.t; return *this;}        \
    D & operator=(const T & rhs) { t = rhs; return *this;}          \
    explicit operator const T & () const {return t; }               \
    explicit operator T & () { return t; }                          \
    /*bool operator==(const D & rhs) const { return t == rhs.t; } */\
    /*bool operator<(const D & rhs) const { return t < rhs.t; }   */\
};

CUSTOM_STRONG_TYPEDEF(Widget, Gadget)
CUSTOM_STRONG_TYPEDEF(Frobnicator, Normalcy)

void acceptWidget(Widget){}
void acceptGadget(Gadget){}
void acceptFrobnicator(Frobnicator){}
void acceptNormalcy(Normalcy){}

int main(){

    //make the two "different types" (well.. they're not really different as you will see)
    Widget w;
    Gadget g;

    //call a function that should ONLY accept Widgets
    acceptWidget(w); //works (good)
    acceptGadget(g);

    //acceptWidget(g); // Error
    //acceptGadget(w); // Error
    // but we can enjoy conversions if we summon them
    acceptWidget(static_cast<Widget&>(g));

    Frobnicator f;
    Normalcy n;
    acceptFrobnicator(f);
    acceptNormalcy(n);

}