我可以在C ++中实现自治的`self`成员类型吗？

C ++ 缺少等效于PHP的selfkeyword 的关键字，该关键字的值取决于封闭类的类型。

在每个类别的基础上伪造它很容易：

struct Foo
{
   typedef Foo self;
};

但我不得不Foo再次写信。也许有一天我会弄错这个错误，并导致一个无声的错误。

我可以使用和的某种组合decltype来“自动”进行此工作吗？我已经尝试了以下方法，但是this在那个地方无效：

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

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

^{（我不必担心的等效项static，它的作用相同，但绑定较晚。）}

以下是您无需重复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;
    }
};

如果要从中派生，Foo则应按WITH_SELF_DERIVED以下方式使用宏：

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

您甚至可以根据需要使用多个基类进行多重继承（由于可变参数模板和可变参数宏）：

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

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

我已经验证了它可以在gcc 4.8和clang 3.4上工作。

可能的解决方法（因为您仍然必须编写一次类型）：

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

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

对于更安全的版本，我们可以保证T实际上源自Self<T>：

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

请注意， static_assert在成员函数内部可能是检查的唯一方法，因为传递的类型std::is_base_of必须完整。

您可以使用宏代替常规的类声明，这将为您做到这一点。

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

然后用像

CLASS_WITH_SELF(Foo) 
};

#define END_CLASS }; 可能会提高可读性。

您也可以Self使用@Paranaix 并使用它（它开始变得很黑）

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

class WITH_SELF(Foo) {
};

我没有肯定的证据，但我认为这是不可能的。由于与您的尝试相同的原因，以下操作失败了，我认为这是我们可以得到的最远的结果：

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

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

从本质上讲，这表明我们要声明我们的typedef的范围根本没有访问（直接或间接）的权限this，并且没有其他（与编译器无关的）获取类的类型或名称的方法。

在GCC和clang中都起作用的是创建一个typedef，该typedef this通过this在函数typedef的尾随返回类型中使用来引用。由于这不是静态成员函数的声明，因此this可以允许使用。然后，您可以使用该typedef进行定义self。

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

struct Foo {
    DEFINE_SELF();
};

struct Bar {
    DEFINE_SELF();
};

不幸的是，严格阅读该标准表明，这甚至是无效的。clang所做的是检查this在静态成员函数的定义中未使用的。在这里，确实不是。GCC不在乎是否this在尾随返回类型中使用它，而与函数的类型无关，它甚至允许static成员函数使用它。但是，该标准实际要求的是this在非静态成员函数（或非静态数据成员初始化程序）的定义之外不使用。英特尔正确无误，对此予以拒绝。

鉴于：

• this 仅在非静态数据成员初始化程序和非静态成员函数（[expr.prim.general] p5）中允许，
• 非静态数据成员的类型不能从初始化程序（[dcl.spec.auto] p5）推导出，
• 非静态成员函数只能在函数调用的上下文中以不合格的名称引用（[expr.ref] p4）
• 非静态成员函数只能使用不合格的名称进行调用，即使在未this评估的上下文中也可以使用（[over.call.func] p3），
• 通过限定名称或成员访问来引用非静态成员函数需要引用所定义的类型

我想我可以说得出结论，如果没有self在某种程度上在某种地方包含类型名称，则根本没有实现的方法。

编辑：我以前的推理中有一个缺陷。“非静态成员函数只能使用不合格的名称进行调用，即使在未评估的上下文中也可以使用（[over.call.func] p3），”这是不正确的。它实际上是说

如果关键字this（9.3.2）在范围内并且引用类T或类的派生类T，则隐含对象参数为(*this)。如果关键字this不在范围内或引用另一个类，则类型为人为的对象将T成为隐式对象参数。如果参数列表由伪造的对象扩展，并且重载解析选择的非静态成员函数之一T，则调用格式错误。

在静态成员函数内部，this可能不会出现，但仍然存在。

但是，根据注释，在静态成员函数内部，将不会执行f()to 的转换(*this).f()，并且没有执行它，则违反了[expr.call] p1：

[...]对于成员函数调用，后缀表达式应为隐式（9.3.1，9.4）或显式类成员访问（5.2.5），其[...]

因为将没有成员访问权限。因此，即使那样也行不通。

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

这不适用于self_check未调用的模板类型，因此static_assert不会评估。

我们也可以进行一些修改以使其适用于template，但是运行时成本较低。

#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

struct在您的类中创建了一个大小为1字节的空白。如果您的类型被实例化，self则进行测试。

我也认为这是不可能的，这是另一个失败但恕我直言的有趣尝试，它避免了this-access：

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

之所以失败，是因为C ++要求您self_f在获取其地址时符合该类的条件:(

我最近发现*this在大括号或相等初始化器中允许这样做。在第5.1.1节中描述（来自n3337工作草案）：

3 [..]与其他上下文中的对象表达式不同*this，出于成员函数主体外部的类成员访问（5.2.5）的目的，不需要为完整类型。[..]

4否则，如果成员声明器声明了X类的非静态数据成员（9.2），则该表达式this是可选的brace-or-equal-initializer中的 “ pointer to X”类型的prvalue 。它不应出现在成员声明符的其他地方。

5该表达式this不得出现在任何其他上下文中。[ 示例：

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

— 结束示例 ]

考虑到这一点，以下代码：

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

通过Daniel Frey的 static_assert。

Live example

除非类型必须封闭类的成员类型，你可以替换使用的self带decltype(*this)。如果您在代码中的许多地方使用它，则可以定义一个宏SELF，如下所示：

#define SELF decltype(*this)

提供我的版本。最好的是，它的用法与本机类相同。但是，它不适用于模板类。

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

根据hvd的答案，我发现唯一缺少的是删除引用，这就是为什么std :: is_same检查失败的原因（b / c生成的类型实际上是对该类型的引用）。现在，该无参数宏可以完成所有工作。下面的工作示例（我使用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";
}

我将重复“必须自己做”的明显解决方案。这是代码的简洁C ++ 11版本，可用于简单的类和类模板：

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

您可以在ideone上看到它的实际效果。成因，导致此结果如下：

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

struct XYZ {
    DECLARE_SELF(XYZ)
};

这很明显存在将代码复制粘贴到其他类而忘记更改XYZ的问题，如下所示：

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

我的第一种方法不是很原始-创建一个函数，如下所示：

/**
 *  @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 ++ 03中工作，而无需使用decltype该__self_check_helper函数来推导的类型this。同样，没有static_assert，但是使用了sizeof()技巧。您可以将其缩短为C ++ 0x。现在，这不适用于模板。此外，该宏还有一个小问题，即该宏最后不期望使用分号，如果使用pedantic进行编译，它将抱怨多余的分号（或者您会看到一个奇怪的宏，XYZ并且在和的主体中不以分号结尾ABC）。

对Type传递给的进行检查DECLARE_SELF不是一种选择，因为那样只会检查XYZ该类（可以），而不检查ABC（有错误）。然后它就撞到了我。与模板一起使用的无附加存储零成本解决方案：

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 

这只是对唯一的枚举值进行静态声明（或者如果不将所有代码都写在一行上，则至少是唯一的），不使用任何类型比较技巧，并且即使在模板中也可用作静态声明。 。作为奖励-现在需要最后的分号:)。

我要感谢Yakk给我带来了很好的启发。在没有看到他的回答之前，我不会写这个。

已在VS 2008和g ++ 4.6.3中测试。确实，通过XYZ和ABC示例，它抱怨：

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

现在，如果我们将ABC作为模板：

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

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

我们将获得：

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

由于未检查功能检查，因此仅触发了行号检查。

使用C ++ 0x（并且没有下划线），您将只需要：

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

我相信令人遗憾的是，仍然需要CStaticAssert位，因为它会产生一个类型，该类型在模板主体中进行类型定义（我想不能用来完成static_assert）。这种方法的优点仍然是其零成本。

我不完全了解这些古怪的模板，超级简单的东西如何：

#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

完成工作，除非您不能忍受几个宏。您甚至可以使用CLASSNAME来声明您的构造函数（当然还有析构函数）。

现场演示。