我可以在 C++ 中实现自主的“self”成员类型吗？

Question

C++ lacks 等效于 PHP's self keyword，计算结果为封闭类的类型。

在每个班级的基础上伪造它很容易：

struct Foo
{
   typedef Foo self;
};

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

我可以使用decltype 和朋友的某种组合来“自主”完成这项工作吗？ I tried the following already 但this 在那个地方无效：

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

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

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

Answer 1

下面是你如何在不重复 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 上运行。

Answer 2

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

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 的类型必须是完整的。

Answer 3

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

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

然后用like

CLASS_WITH_SELF(Foo) 
};

#define END_CLASS }; 可能有助于提高可读性。

---

您也可以使用 @Paranaix 的 Self 并使用它（它开始变得非常老套）

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

class WITH_SELF(Foo) {
};

Answer 4

我没有确凿的证据，但我认为这是不可能的。以下失败 - 原因与您的尝试相同 - 我认为这是我们能得到的最远距离：

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

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

本质上，这表明我们想要声明 typedef 的范围只是没有访问（直接或间接）this，并且没有其他（独立于编译器) 获取类的类型或名称的方式。

Answer 5

在 GCC 和 clang 中起作用的是通过在函数 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。

编辑：我之前的推理存在缺陷。 “非静态成员函数只能通过非限定名称调用，即使在未评估的上下文中，当 this 可以使用时（[over.call.func]p3）”是不正确的。它实际上说的是

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

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

但是，根据 cmets，在静态成员函数内部，不会执行 f() 到 (*this).f() 的转换，并且不会执行，那么 [expr.call]p1 被违反：

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

因为没有会员访问权限。所以即使这样也行不通。

Answer 6

#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。

我们可以做一些小技巧让它也适用于templates，但它的运行时间成本很小。

#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

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

Answer 7

我也认为这是不可能的，这是另一个失败但恕我直言的有趣尝试，它避免了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 :(

Answer 8

我最近发现 brace-or-equal-initializer 中允许使用 *this。 § 5.1.1 中描述（来自n3337 working draft）：

3 [..] 与其他上下文中的对象表达式不同，*this 是 就集体成员而言，不需要是完整的类型 在成员函数体之外访问（5.2.5）。 [..]

4 否则，如果 member-declarator 声明了一个非静态数据 类 X 的成员 (9.2)，表达式 this 是类型的纯右值 可选的 brace-or-equal-initializer 中的“指向 X 的指针”。它 不应出现在 member-declarator 的其他位置。

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'sstatic_assert。

Live example

Answer 9

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

#define SELF decltype(*this)

Answer 10

基于 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";
}

Answer 11

提供我的版本。最好的一点是它的用法和原生类一样。但是，它不适用于模板类。

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

Answer 12

终于找到了合适的解决方案！这个想法来自@MitalAshok on github。

#include <type_traits>

namespace SelfType
{
    template <typename T>
    struct Reader
    {
        friend auto adl_GetSelfType(Reader<T>);
    };

    template <typename T, typename U>
    struct Writer
    {
        friend auto adl_GetSelfType(Reader<T>){return U{};}
    };

    inline void adl_GetSelfType() {}

    template <typename T>
    using Read = std::remove_pointer_t<decltype(adl_GetSelfType(Reader<T>{}))>;
}

#define DEFINE_SELF \
    struct _self_type_tag {}; \
    constexpr auto _self_type_helper() -> decltype(::SelfType::Writer<_self_type_tag, decltype(this)>{}, void()) {} \
    using Self = ::SelfType::Read<_self_type_tag>;

然后：

struct A
{
    DEFINE_SELF
    static_assert(std::is_same_v<Self, A>);
};

这使用有状态模板元编程将类型存储在可访问的上下文中（在辅助函数的尾随返回类型中），然后读取否则无法访问的类型（在类范围内）。

这里的关键是编写器是如何实例化的。简单地执行auto _self_type_helper() -> Writer<...> {return {};} 是行不通的：编写器被延迟实例化，使得状态可以在任何成员函数体内访问，但不能在类范围内访问。

但是，如果您使用-> decltype(Writer<...>{}, void())，或者以其他方式使编写器成为影响类型的表达式的一部分，那么它就会开始工作。我不完全确定为什么会这样。

Answer 13

我将重复“必须自己做”的明显解决方案。这是代码的简洁 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

有点长，但请耐心等待。这具有在没有decltype 的情况下在C++03 中工作的优势，因为__self_check_helper 函数用于推断this 的类型。此外，没有static_assert，而是采用了sizeof() 技巧。对于 C++0x，你可以让它更短。现在这不适用于模板。此外，宏的末尾不期望分号还有一个小问题，如果使用 pedantic 编译，它会抱怨额外的不必要的分号（或者您将留下一个看起来很奇怪的宏，在 @ 的正文中不以分号结尾987654331@ 和 ABC)。

检查传递给DECLARE_SELF 的Type 不是一种选择，因为这只会检查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 位仍然是必需的，因为它会生成一个类型，该类型在模板主体中是 typedef-ed（我想 static_assert 不能这样做）。这种方法的优势仍然是它的零成本。

Answer 14

我对这些古怪的模板一无所知，超级简单的东西怎么样：

#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 来声明你的构造函数（当然还有析构函数）。

Live demo.