Puis-je implémenter un type de membre autonome `self` en C ++?

C ++ n'a pas l'équivalent du mot - selfclé PHP , qui évalue le type de la classe englobante.

Il est assez facile de le simuler par classe:

struct Foo
{
   typedef Foo self;
};

mais je devais écrire Foo nouveau. Peut-être que je vais me tromper un jour et provoquer un bug silencieux.

Puis-je utiliser une combinaison de decltypeet d'amis pour faire ce travail "de manière autonome"? J'ai déjà essayé ce qui suit mais ce thisn'est pas valide à cet endroit:

struct Foo
{
   typedef decltype(*this) self;
};

// main.cpp:3:22: error: invalid use of 'this' at top level
//     typedef decltype(*this) self;

^{(Je ne vais pas m'inquiéter de l'équivalent de static, qui fait la même chose mais avec une liaison tardive.)}

Voici comment vous pouvez le faire sans répéter le type de Foo:

template <typename...Ts>
class Self;

template <typename X, typename...Ts>
class Self<X,Ts...> : public Ts...
{
protected:
    typedef X self;
};

#define WITH_SELF(X) X : public Self<X>
#define WITH_SELF_DERIVED(X,...) X : public Self<X,__VA_ARGS__>

class WITH_SELF(Foo)
{
    void test()
    {
        self foo;
    }
};

Si vous souhaitez dériver de, Foovous devez utiliser la macro WITH_SELF_DERIVEDde la manière suivante:

class WITH_SELF_DERIVED(Bar,Foo)
{
    /* ... */
};

Vous pouvez même faire plusieurs héritages avec autant de classes de base que vous le souhaitez (grâce aux modèles variadiques et aux macros variadiques):

class WITH_SELF(Foo2)
{
    /* ... */
};

class WITH_SELF_DERIVED(Bar2,Foo,Foo2)
{
    /* ... */
};

J'ai vérifié que cela fonctionne sur gcc 4.8 et clang 3.4.

Une solution de contournement possible (car vous devez toujours écrire le type une fois):

template<typename T>
struct Self
{
protected:
    typedef T self;
};

struct Foo : public Self<Foo>
{
    void test()
    {
        self obj;
    }
};

Pour une version plus sûre, nous pourrions nous assurer que Tdérive réellement de Self<T>:

Self()
{
    static_assert(std::is_base_of<Self<T>, T>::value, "Wrong type passed to Self");
}

Notez qu'une static_assertfonction à l'intérieur d'une fonction membre est probablement le seul moyen de vérifier, car les types passés std::is_base_ofdoivent être complets.

Vous pouvez utiliser une macro au lieu d'une déclaration de classe ordinaire, qui le fera pour vous.

#define CLASS_WITH_SELF(X) class X { typedef X self;

Et puis utilisez comme

CLASS_WITH_SELF(Foo) 
};

#define END_CLASS }; aiderait probablement la lisibilité.

Vous pouvez également prendre @ Paranaix's Selfet l'utiliser (cela commence à devenir vraiment hackish)

#define WITH_SELF(X) X : public Self<X>

class WITH_SELF(Foo) {
};

Je n'ai aucune preuve positive mais je pense que c'est impossible. Ce qui suit échoue - pour la même raison que votre tentative - et je pense que c'est le plus loin possible:

struct Foo {
    auto self_() -> decltype(*this) { return *this; }

    using self = decltype(self_());
};

Essentiellement, cela démontre que la portée à laquelle nous voulons déclarer notre typedef n'a tout simplement aucun accès (direct ou indirect) à this, et il n'y a pas d'autre moyen (indépendant du compilateur) d'accéder au type ou au nom de la classe.

Ce qui fonctionne à la fois dans GCC et clang est de créer un typedef qui se réfère à thisen utilisant thisdans le type de retour de fin d'une fonction typedef. Comme il ne s'agit pas de la déclaration d'une fonction membre statique, l'utilisation de thisest tolérée. Vous pouvez ensuite utiliser ce typedef pour définir self.

#define DEFINE_SELF() \
    typedef auto _self_fn() -> decltype(*this); \
    using self = decltype(((_self_fn*)0)())

struct Foo {
    DEFINE_SELF();
};

struct Bar {
    DEFINE_SELF();
};

Malheureusement, une lecture stricte de la norme indique que même cela n'est pas valable. Ce que fait clang est de vérifier que ce thisn'est pas utilisé dans la définition d'une fonction membre statique. Et ici, ce n'est en effet pas. GCC ne se soucie pas de savoir s'il thisest utilisé dans un type de retour de fin quel que soit le type de fonction, il le permet même pour staticles fonctions membres. Cependant, ce que la norme exige réellement, c'est quethis n'est pas utilisée en dehors de la définition d'une fonction membre non statique (ou d'un initialiseur de membre de données non statique). Intel a raison et rejette cela.

Étant donné que:

• this n'est autorisé que dans les initialiseurs de membres de données non statiques et les fonctions membres non statiques ([expr.prim.general] p5),
• Les membres de données non statiques ne peuvent pas avoir leur type déduit de l'initialiseur ([dcl.spec.auto] p5),
• Les fonctions membres non statiques ne peuvent être désignées que par un nom non qualifié dans le contexte d'un appel de fonction ([expr.ref] p4)
• les fonctions membres non statiques ne peuvent être appelées que par un nom non qualifié, même dans des contextes non évalués, lorsqu'elles thispeuvent être utilisées ([over.call.func] p3),
• une référence à une fonction membre non statique par un nom qualifié ou un accès membre nécessite une référence au type en cours de définition

Je pense que je peux dire de manière concluante qu'il n'y a aucun moyen de mettre en œuvre self sans inclure d'une manière ou d'une autre, quelque part, le nom du type.

Edit : Il y a un défaut dans mon raisonnement antérieur. "Les fonctions membres non statiques ne peuvent être appelées que par un nom non qualifié, même dans des contextes non évalués, lorsque cela peut être utilisé ([over.call.func] p3)", est incorrect. Qu'est-ce que c'est réellement dit en est

Si le mot-clé this(9.3.2) est dans la portée et fait référence à la classe T, ou à une classe dérivée de T, alors l'argument d'objet implicite est (*this). Si le mot clé thisn'est pas dans la portée ou fait référence à une autre classe, alors un objet artificiel de type Tdevient l'argument d'objet implicite. Si la liste d'arguments est augmentée par un objet artificiel et que la résolution de surcharge sélectionne l'une des fonctions membres non statiques de T, l'appel est mal formé.

À l'intérieur d'une fonction membre statique, this peut ne pas apparaître, mais elle existe toujours.

Cependant, d'après les commentaires, à l'intérieur d'une fonction membre statique, la transformation de f()en(*this).f() ne serait pas effectuée, et si elle n'est pas effectuée, alors [expr.call] p1 est violé:

[...] Pour un appel de fonction membre, l'expression de suffixe doit être un accès de membre de classe implicite (9.3.1, 9.4) ou explicite (5.2.5) dont [...]

car il n'y aurait pas d'accès aux membres. Donc même ça ne marcherait pas.

#define SELF_CHECK( SELF ) void self_check() { static_assert( std::is_same< typename std::decay<decltype(*this)>::type, SELF >::value, "self wrong type" ); }
#define SELF(T) typedef T self; SELF_CHECK(T)

struct Foo {
  SELF(Foo); // works, self is defined as `Foo`
};
struct Bar {
  SELF(Foo); // fails
};

cela ne fonctionne pas sur les types de modèle, comme self_checkon ne l'appelle pas, donc le static_assertn'est pas évalué.

Nous pouvons également faire des hacks pour que cela fonctionne pour templates, mais cela a un coût d'exécution mineur.

#define TESTER_HELPER_TYPE \
template<typename T, std::size_t line> \
struct line_tester_t { \
  line_tester_t() { \
    static_assert( std::is_same< decltype(T::line_tester), line_tester_t<T,line> >::value, "test failed" ); \
    static_assert( std::is_same< decltype(&T::static_test_zzz), T*(*)() >::value, "test 2 failed" ); \
  } \
}

#define SELF_CHECK( SELF ) void self_check() { static_assert( std::is_same< typename std::decay<decltype(*this)>::type, SELF >::value, "self wrong type" ); }

#define SELF(T) typedef T self; SELF_CHECK(T); static T* static_test_zzz() { return nullptr; }; TESTER_HELPER_TYPE; line_tester_t<T,__LINE__> line_tester

un structoctet vide de taille 1 est créé dans votre classe. Si votre type est instancié, selfest testé.

Je pense aussi que c'est impossible, voici une autre tentative intéressante mais échouée à thismon humble avis qui évite l' accès:

template<typename T>
struct class_t;

template<typename T, typename R>
struct class_t< R (T::*)() > { using type = T; };

struct Foo
{
   void self_f(); using self = typename class_t<decltype(&self_f)>::type;
};

#include <type_traits>

int main()
{
    static_assert( std::is_same< Foo::self, Foo >::value, "" );
}

qui échoue car C ++ vous oblige à vous qualifier self_favec la classe lorsque vous voulez prendre son adresse :(

J'ai récemment découvert que cela *thisest autorisé dans un initialiseur d'accolade ou d'égalité . Décrit au § 5.1.1 (à partir du projet de travail n3337 ):

3 [..] Contrairement à l'expression d'objet dans d'autres contextes, il *thisn'est pas nécessaire d'être de type complet pour les besoins de l'accès aux membres de classe (5.2.5) en dehors du corps de la fonction membre. [..]

4 Sinon, si un membre-déclarateur déclare un membre de données non statique (9.2) d'une classe X, l'expression thisest une prvalue de type «pointeur vers X» dans l' initialiseur optionnel accolades ou égales . Il ne doit pas figurer ailleurs dans le membre-déclarant .

5 L'expression thisne doit apparaître dans aucun autre contexte. [ Exemple:

class Outer {
    int a[sizeof(*this)];               // error: not inside a member function
    unsigned int sz = sizeof(*this);    // OK: in brace-or-equal-initializer

    void f() {
        int b[sizeof(*this)];           // OK
        struct Inner {
            int c[sizeof(*this)];       // error: not inside a member function of Inner
        };
    }
};

- fin d'exemple ]

Dans cet esprit, le code suivant:

struct Foo
{
    Foo* test = this;
    using self = decltype(test);

    static void smf()
    {
        self foo;
    }
};

#include <iostream>
#include <type_traits>

int main()
{
    static_assert( std::is_same< Foo::self, Foo* >::value, "" );
}

dépasse Daniel Frey static_assert .

Live example

À moins que le type ne doive être le type de membre de la classe englobante, vous pouvez remplacer l'utilisation de selfpar decltype(*this). Si vous l'utilisez à de nombreux endroits dans votre code, vous pouvez définir une macro SELFcomme suit:

#define SELF decltype(*this)

Fournissez ma version. La meilleure chose est que son utilisation est la même que la classe native. Cependant, cela ne fonctionne pas pour les classes de modèles.

template<class T> class Self;

#define CLASS(Name) \
class Name##_; \
typedef Self<Name##_> Name; \
template<> class Self<Name##_>

CLASS(A)
{
    int i;
    Self* clone() const { return new Self(*this); }
};

CLASS(B) : public A
{
    float f;
    Self* clone() const { return new Self(*this); }
};

En me basant sur la réponse de hvd, j'ai trouvé que la seule chose qui manquait était la suppression de la référence, c'est pourquoi la vérification std :: is_same échoue (b / c le type résultant est en fait une référence au type). Maintenant, cette macro sans paramètre peut faire tout le travail. Exemple de travail ci-dessous (j'utilise GCC 8.1.1).

#define DEFINE_SELF \
    typedef auto _self_fn() -> std::remove_reference<decltype(*this)>::type; \
    using self = decltype(((_self_fn*)0)())

class A {
    public:
    DEFINE_SELF;
};

int main()
{
    if (std::is_same_v<A::self, A>)
        std::cout << "is A";
}

Je vais répéter la solution évidente de "devoir le faire vous-même". Il s'agit de la version succincte du code C ++ 11, qui fonctionne à la fois avec des classes simples et des modèles de classes:

#define DECLARE_SELF(Type) \
    typedef Type TySelf; /**< @brief type of this class */ \
    /** checks the consistency of TySelf type (calling it has no effect) */ \
    void self_check() \
    { \
        static_assert(std::is_same<decltype(*((TySelf*)(0))), \
            decltype(*this)>::value, "TySelf is not what it should be"); \
    } \
    enum { static_self_check_token = __LINE__ }; \
    static_assert(int(static_self_check_token) == \
        int(TySelf::static_self_check_token), \
        "TySelf is not what it should be")

Vous pouvez le voir en action chez ideone . La genèse menant à ce résultat est ci-dessous:

#define DECLARE_SELF(Type) typedef Type _TySelf; /**< @brief type of this class */

struct XYZ {
    DECLARE_SELF(XYZ)
};

Cela pose le problème évident de copier-coller le code dans une classe différente et d'oublier de changer XYZ, comme ici:

struct ABC {
    DECLARE_SELF(XYZ) // !!
};

Ma première approche n'était pas très originale - créer une fonction, comme celle-ci:

/**
 *  @brief namespace for checking the _TySelf type consistency
 */
namespace __self {

/**
 *  @brief compile-time assertion (_TySelf must be declared the same as the type of class)
 *
 *  @tparam _TySelf is reported self type
 *  @tparam _TyDecltypeThis is type of <tt>*this</tt>
 */
template <class _TySelf, class _TyDecltypeThis>
class CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE;

/**
 *  @brief compile-time assertion (specialization for assertion passing)
 *  @tparam _TySelf is reported self type (same as type of <tt>*this</tt>)
 */
template <class _TySelf>
class CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE<_TySelf, _TySelf> {};

/**
 *  @brief static assertion helper type
 *  @tparam n_size is size of object being used as assertion message
 *      (if it's a incomplete type, compiler will display object name in error output)
 */
template <const size_t n_size>
class CStaticAssert {};

/**
 *  @brief helper function for self-check, this is used to derive type of this
 *      in absence of <tt>decltype()</tt> in older versions of C++
 *
 *  @tparam _TyA is reported self type
 *  @tparam _TyB is type of <tt>*this</tt>
 */
template <class _TyA, class _TyB>
inline void __self_check_helper(_TyB *UNUSED(p_this))
{
    typedef CStaticAssert<sizeof(CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE<_TyA, _TyB>)> _TyAssert;
    // make sure that the type reported as self and type of *this is the same
}

/**
 *  @def __SELF_CHECK
 *  @brief declares the body of __self_check() function
 */
#define __SELF_CHECK \
    /** checks the consistency of _TySelf type (calling it has no effect) */ \
    inline void __self_check() \
    { \
        __self::__self_check_helper<_TySelf>(this); \
    }

/**
 *  @def DECLARE_SELF
 *  @brief declares _TySelf type and adds code to make sure that it is indeed a correct one
 *  @param[in] Type is type of the enclosing class
 */
#define DECLARE_SELF(Type) \
    typedef Type _TySelf; /**< @brief type of this class */ \
    __SELF_CHECK

} // ~self

C'est un peu long, mais veuillez rester avec moi ici. Cela présente l'avantage de travailler en C ++ 03 sans decltype, car la __self_check_helperfonction est utilisée pour déduire le type de this. En outre, il n'y a pas static_assert, mais l' sizeof()astuce est utilisée à la place. Vous pouvez le rendre beaucoup plus court pour C ++ 0x. Maintenant, cela ne fonctionnera pas pour les modèles. De plus, il y a un problème mineur avec la macro qui n'attend pas de point-virgule à la fin, si elle compile avec pedantic, elle se plaindra d'un point-virgule supplémentaire inutile (ou vous vous retrouverez avec une macro étrange ne se terminant pas par un point-virgule dans le corps de XYZet ABC).

Faire une vérification sur le Typequi est passé DECLARE_SELFn'est pas une option, car cela ne vérifierait que la XYZclasse (ce qui est ok), inconscient de ABC(qui a une erreur). Et ensuite ça m'a frappé. Une solution zéro coût de stockage sans stockage supplémentaire qui fonctionne avec des modèles:

namespace __self {

/**
 *  @brief compile-time assertion (_TySelf must be declared the same as the type of class)
 *  @tparam b_check is the asserted value
 */
template <bool b_check>
class CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE2;

/**
 *  @brief compile-time assertion (specialization for assertion passing)
 */
template <>
class CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE2<true> {};

/**
 *  @def DECLARE_SELF
 *  @brief declares _TySelf type and adds code to make sure that it is indeed a correct one
 *  @param[in] Type is type of the enclosing class
 */
#define DECLARE_SELF(Type) \
    typedef Type _TySelf; /**< @brief type of this class */ \
    __SELF_CHECK \
    enum { __static_self_check_token = __LINE__ }; \
    typedef __self::CStaticAssert<sizeof(CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE2<int(__static_self_check_token) == int(_TySelf::__static_self_check_token)>)> __static_self_check

} // ~__self 

Cela rend simplement une assertion statique sur une valeur d'énumération unique (ou au moins unique dans le cas où vous n'écrivez pas tout votre code sur une seule ligne), aucune supercherie de comparaison de type n'est utilisée, et cela fonctionne comme une assertion statique, même dans les modèles . Et en prime - le point-virgule final est maintenant requis :).

Je tiens à remercier Yakk de m'avoir donné une bonne inspiration. Je n'écrirais pas cela sans avoir d'abord vu sa réponse.

Testé avec VS 2008 et g ++ 4.6.3. En effet, avec l' exemple XYZet ABC, il se plaint:

ipolok@ivs:~$ g++ self.cpp -c -o self.o
self.cpp:91:5: error: invalid application of âsizeofâ to incomplete type â__self::CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE2<false>â
self.cpp:91:5: error: template argument 1 is invalid
self.cpp: In function âvoid __self::__self_check_helper(_TyB*) [with _TyA = XYZ, _TyB = ABC]â:
self.cpp:91:5:   instantiated from here
self.cpp:58:87: error: invalid application of âsizeofâ to incomplete type â__self::CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE<XYZ, ABC>â

Maintenant, si nous faisons d'ABC un modèle:

template <class X>
struct ABC {
    DECLARE_SELF(XYZ); // line 92
};

int main(int argc, char **argv)
{
    ABC<int> abc;
    return 0;
}

Nous allons obtenir:

ipolok@ivs:~$ g++ self.cpp -c -o self.o
self.cpp: In instantiation of âABC<int>â:
self.cpp:97:18:   instantiated from here
self.cpp:92:9: error: invalid application of âsizeofâ to incomplete type â__self::CSELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE2<false>â

Seule la vérification du numéro de ligne s'est déclenchée, car la vérification de la fonction n'a pas été compilée (comme prévu).

Avec C ++ 0x (et sans les mauvais traits de soulignement), vous auriez juste besoin de:

namespace self_util {

/**
 *  @brief compile-time assertion (tokens in class and TySelf must match)
 *  @tparam b_check is the asserted value
 */
template <bool b_check>
class SELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE;

/**
 *  @brief compile-time assertion (specialization for assertion passing)
 */
template <>
class SELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE<true> {};

/**
 *  @brief static assertion helper type
 *  @tparam n_size is size of object being used as assertion message
 *      (if it's a incomplete type, compiler will display object name in error output)
 */
template <const size_t n_size>
class CStaticAssert {};

#define SELF_CHECK \
    /** checks the consistency of TySelf type (calling it has no effect) */ \
    void self_check() \
    { \
        static_assert(std::is_same<TySelf, decltype(*this)>::value, "TySelf is not what it should be"); \
    }

#define DECLARE_SELF(Type) \
    typedef Type TySelf; /**< @brief type of this class */ \
    SELF_CHECK \
    enum { static_self_check_token = __LINE__ }; \
    typedef self_util::CStaticAssert<sizeof(SELF_TYPE_MUST_BE_THE_SAME_AS_CLASS_TYPE<int(static_self_check_token) == int(TySelf::static_self_check_token)>)> static_self_check

} // ~self_util

Je crois que le bit CStaticAssert est malheureusement toujours nécessaire car il produit un type, qui est typé dans le corps du modèle (je suppose que la même chose ne peut pas être faite avec static_assert). L'avantage de cette approche est toujours son coût nul.

Je ne sais pas tout sur ces modèles farfelus, que diriez-vous de quelque chose de super simple:

#define DECLARE_TYPEOF_THIS typedef CLASSNAME typeof_this
#define ANNOTATED_CLASSNAME(DUMMY) CLASSNAME

#define CLASSNAME X
class ANNOTATED_CLASSNAME (X)
{
public:
    DECLARE_TYPEOF_THIS;
    CLASSNAME () { moi = this; }
    ~CLASSNAME () { }
    typeof_this *moi;
    // ...
};    
#undef CLASSNAME

#define CLASSNAME Y
class ANNOTATED_CLASSNAME (Y)
{
    // ...
};
#undef CLASSNAME

Travail terminé, sauf si vous ne supportez pas quelques macros. Vous pouvez même utiliser CLASSNAMEpour déclarer votre (vos) constructeur (s) (et, bien sûr, destructeur).

Démo en direct .