Czy mogę zaimplementować autonomiczny typ składowy „self” w C ++?

C ++ nie ma odpowiednika słowa kluczowego PHPself , które ocenia typ otaczającej klasy.

Łatwo jest sfałszować to na podstawie klasy:

struct Foo
{
   typedef Foo self;
};

ale musiałem napisać Fooponownie. Może któregoś dnia się pomylę i wywołam cichy błąd.

Czy mogę użyć kombinacji decltypeprzyjaciół i przyjaciół, aby ta praca działała „autonomicznie”? Próbowałem już następujących rzeczy, ale thisnie są one prawidłowe w tym miejscu:

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

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

^{(Nie mam zamiaru martwić się o odpowiednik static, który robi to samo, ale z późnym wiązaniem).}

Oto, jak możesz to zrobić bez powtarzania typu 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;
    }
};

Jeśli chcesz wyprowadzić z Footego makra, powinieneś użyć makra WITH_SELF_DERIVEDw następujący sposób:

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

Możesz nawet zrobić wielokrotne dziedziczenie z dowolną liczbą klas bazowych (dzięki wariadycznym szablonom i wariadycznym makrom):

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

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

Sprawdziłem to, aby działać na gcc 4.8 i clang 3.4.

Możliwe obejście (ponieważ nadal musisz raz wpisać typ):

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

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

Aby uzyskać bezpieczniejszą wersję, możemy zapewnić, że Tfaktycznie pochodzi z Self<T>:

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

Zauważ, że static_assertfunkcja wewnątrz elementu członkowskiego jest prawdopodobnie jedynym sposobem sprawdzenia, ponieważ przekazywane typy std::is_base_ofmuszą być kompletne.

Możesz użyć makra zamiast zwykłej deklaracji klasy, która zrobi to za Ciebie.

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

A potem użyj like

CLASS_WITH_SELF(Foo) 
};

#define END_CLASS }; prawdopodobnie pomogłoby w czytelności.

Możesz także wziąć @ Paranaix Selfi użyć go (zaczyna robić się naprawdę hakerski)

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

class WITH_SELF(Foo) {
};

Nie mam żadnych pozytywnych dowodów, ale myślę, że to niemożliwe. Poniższe zawodzi - z tego samego powodu co twoja próba - i myślę, że to najdalej, co możemy osiągnąć:

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

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

Zasadniczo pokazuje to, że zakres, w którym chcemy zadeklarować naszą typedef, po prostu nie ma dostępu (ani bezpośredniego, ani pośredniego) do thisi nie ma innego (niezależnego od kompilatora) sposobu na dotarcie do typu lub nazwy klasy.

To, co działa zarówno w GCC, jak i clang, polega na utworzeniu typedef, do którego odwołuje się thispoprzez użycie thisw końcowym zwracanym typie funkcji typedef. Ponieważ nie jest to deklaracja statycznej funkcji składowej, użycie thisjest tolerowane. Następnie możesz użyć tego typu do zdefiniowania self.

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

struct Foo {
    DEFINE_SELF();
};

struct Bar {
    DEFINE_SELF();
};

Niestety, ścisła lektura normy mówi, że nawet to nie jest ważne. Clang sprawdza, thisczy nie jest używany w definicji statycznej funkcji składowej. A tutaj rzeczywiście tak nie jest. GCC nie ma nic przeciwko, jeśli thisjest używane w typie końcowym zwracanym niezależnie od rodzaju funkcji, pozwala na to nawet dla staticfunkcji składowych. Jednak standard faktycznie wymaga tego, aby thisnie był używany poza definicją niestatycznej funkcji składowej (lub niestatycznego inicjatora składowej danych). Intel ma rację i odrzuca to.

Jeśli się uwzględni:

• this jest dozwolone tylko w statycznych inicjatorach składowych danych i niestatycznych funkcjach składowych ([wyr.prim.general] p5),
• niestatyczne składowe danych nie mogą mieć ich typu wywnioskowanego z inicjatora ([dcl.spec.auto] p5),
• do niestatycznych funkcji składowych można się odwoływać tylko przez niekwalifikowaną nazwę w kontekście wywołania funkcji ([wyraż.ref] p4)
• niestatyczne funkcje składowe mogą być wywoływane tylko przez niekwalifikowaną nazwę, nawet w niedocenianych kontekstach, kiedy thismożna ich użyć ([over.call.func] p3),
• odwołanie do niestatycznej funkcji składowej przez nazwę kwalifikowaną lub dostęp do elementu członkowskiego wymaga odwołania do definiowanego typu

Myślę, że mogę definitywnie powiedzieć, że nie ma żadnego sposobu na zaimplementowanie selfbez dołączenia gdzieś nazwy typu.

Edycja : W moim wcześniejszym rozumowaniu jest błąd. „Niestatyczne funkcje składowe mogą być wywoływane tylko przez niekwalifikowaną nazwę, nawet w niedocenianych kontekstach, kiedy można tego użyć ([over.call.func] p3)” jest niepoprawne. To, co faktycznie mówi, to

Jeśli słowo kluczowe this(9.3.2) znajduje się w zakresie i odnosi się do klasy Tlub klasy pochodnejT , to domniemany argument obiektu jest (*this). Jeśli słowo kluczowe thisnie znajduje się w zakresie lub odnosi się do innej klasy, to wymyślony obiekt typu Tstaje się niejawnym argumentem obiektu. Jeśli lista argumentów jest powiększona przez wymyślony obiekt, a rozwiązanie przeciążenia wybiera jedną z niestatycznych funkcji składowych T, wywołanie jest źle sformułowane.

Wewnątrz statycznej funkcji składowej thismoże się nie pojawiać, ale nadal istnieje.

Jednak zgodnie z komentarzami wewnątrz statycznej funkcji składowej transformacja f()(*this).f() składowej do nie zostanie wykonana, a jeśli nie zostanie wykonana, naruszone jest [wyrażenie] p1:

[...] W przypadku wywołania funkcji składowej wyrażenie przyrostkowe powinno być niejawnym (9.3.1, 9.4) lub jawnym dostępem do elementu członkowskiego klasy (5.2.5), którego [...]

ponieważ nie byłoby dostępu dla członków. Więc nawet to nie zadziała.

#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
};

to nie działa na typach szablonów, ponieważ self_checknie jest nazywany, więcstatic_assert nie jest oceniane.

Możemy zrobić kilka hacków, aby działało również przez templates, ale ma to niewielki koszt w czasie wykonywania.

#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

structw klasie tworzony jest pusty bajt o rozmiarze 1. Jeśli tworzony jest typ, selfjest testowany przeciwko.

Myślę też, że to niemożliwe, oto kolejna nieudana, ale interesująca próba IMHO, która pozwala uniknąć this-dostępu:

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, "" );
}

co kończy się niepowodzeniem, ponieważ C ++ wymaga zakwalifikowania self_fsię do klasy, jeśli chcesz zająć jej adres :(

Niedawno odkryłem, że *thisjest to dozwolone w inicjatorze nawiasów klamrowych lub równych . Opisane w § 5.1.1 ( z projektu roboczego n3337 ):

3 [..] W przeciwieństwie do wyrażenia obiektowego w innych kontekstach, *thisnie wymaga się, aby był kompletnym typem dla celów dostępu do składowej klasy (5.2.5) poza treścią funkcji składowej. [..]

4 W przeciwnym razie, jeśli deklarator elementu członkowskiego deklaruje niestatyczną składową danych (9.2) klasy X, wyrażenie thisjest wartością parametru „wskaźnik do X” w opcjonalnym inicjatorze nawiasu klamrowego lub równego . Nie pojawia się w innym miejscu w składniku deklaracji .

5 Wyrażenie thisnie pojawia się w żadnym innym kontekście. [ Przykład:

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
        };
    }
};

- przykład końca ]

Mając to na uwadze, poniższy kod:

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, "" );
}

mija Daniel Frey's static_assert .

Live example

Chyba że typ musi być typu członkiem klasy otaczającej można wymienić zastosowanie selfprzy decltype(*this). Jeśli używasz go w wielu miejscach w kodzie, możesz zdefiniować makro SELFw następujący sposób:

#define SELF decltype(*this)

Podaj moją wersję. Najlepsze jest to, że jego użycie jest takie samo jak w klasie natywnej. Jednak nie działa w przypadku klas szablonów.

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); }
};

Opierając się na odpowiedzi hvd, stwierdziłem, że jedyną rzeczą, której brakowało, było usunięcie odwołania, dlatego sprawdzenie std :: is_same kończy się niepowodzeniem (b / c typ wynikowy jest w rzeczywistości odniesieniem do typu). Teraz to bez parametrów makro może wykonać całą pracę. Przykład roboczy poniżej (używam 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";
}

Powtórzę oczywiste rozwiązanie polegające na „konieczności zrobienia tego samemu”. To jest zwięzła wersja kodu w C ++ 11, która działa zarówno z prostymi klasami, jak i szablonami klas:

#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")

Możesz to zobaczyć w akcji w ideone . Geneza prowadząca do tego wyniku jest poniżej:

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

struct XYZ {
    DECLARE_SELF(XYZ)
};

Ma to oczywisty problem z kopiowaniem i wklejaniem kodu do innej klasy i zapominaniem o zmianie XYZ, jak tutaj:

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

Moje pierwsze podejście nie było zbyt oryginalne - stworzenie funkcji takiej jak ta:

/**
 *  @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

To trochę długie, ale proszę o wyrozumiałość. Ma to tę zaletę, że pracuje w C ++ 03 bez decltype, ponieważ __self_check_helperfunkcja służy do wywnioskowania typu this. Nie ma też static_assert, ale sizeof()zamiast tego stosuje się sztuczkę. Możesz go znacznie skrócić dla C ++ 0x. Teraz to nie zadziała w przypadku szablonów. Istnieje również niewielki problem z makrem, które nie oczekuje średnika na końcu, jeśli kompiluje się z pedantycznym, będzie narzekać na dodatkowy niepotrzebny średnik (lub pozostanie z dziwnie wyglądającym makrem nie kończącym się średnikiem w treści XYZi ABC).

Sprawdzenie tego, Typeco jest przekazywane, DECLARE_SELFnie jest opcją, ponieważ sprawdzałoby tylko XYZklasę (która jest w porządku), nieświadoma ABC(która ma błąd). I wtedy do mnie dotarło. Bezkosztowe rozwiązanie do magazynowania bez dodatkowych kosztów, które współpracuje z szablonami:

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 

To po prostu tworzy statyczne potwierdzenie na unikalnej wartości wyliczenia (lub przynajmniej unikalne w przypadku, gdy nie piszesz całego kodu w jednym wierszu), nie jest stosowana żadna sztuczka porównująca typy i działa jako asercja statyczna, nawet w szablonach . I jako bonus - ostatni średnik jest teraz wymagany :).

Chciałbym podziękować Yakkowi za dobrą inspirację. Nie napisałbym tego bez uprzedniego zobaczenia jego odpowiedzi.

Testowane z VS 2008 i g ++ 4.6.3. Rzeczywiście, z przykładem XYZi ABCnarzeka:

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>â

Teraz, jeśli zrobimy ABC szablonem:

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

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

Dostaniemy:

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>â

Wyzwolono tylko sprawdzenie numeru wiersza, ponieważ kontrola funkcji nie została skompilowana (zgodnie z oczekiwaniami).

W C ++ 0x (i bez złych znaków podkreślenia) wystarczyłoby:

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

Uważam, że bit CStaticAssert jest niestety nadal wymagany, ponieważ tworzy typ, który jest wpisany w treści szablonu (przypuszczam, że tego samego nie można zrobić static_assert). Zaletą tego podejścia jest nadal zerowy koszt.

Nie wiem wszystkiego o tych zwariowanych szablonach, a może coś super prostego:

#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

Praca wykonana, chyba że nie możesz znieść kilku makr. Możesz nawet użyć CLASSNAMEdo zadeklarowania konstruktora (-ów) (i oczywiście destruktora).

Demo na żywo .