संरचना के भीतर एक नया प्रकार बनाने के लिए एक अनाम नाम के प्रकार को निकालने के लिए कैसे?

Question

एक अज्ञात संरचना के प्रकार पर एक विधि/फ़ंक्शन parametrized बनाना आसान है। संरचना की परिभाषा के बाद टाइप करना भी आसान है।

struct Foo { 
    template <typename T> Foo(T*) { /* we have access to T here */ } 
} 
template <typename T> void baz(T*) { /* we have access to T here */ } 

template<typename T> struct Bar { 
    /* we have access to T here */ 
}; 

void test() { 
    struct { 
    Foo foo { this }; // access in a constructor 
    void test() { baz(this); } // access in a function 
    } unnamed; 
    Bar<decltype(unnamed)> bar; // access after definition 
} 

लेकिन वहाँ किसी भी "जादू" कि struct दायरे में unnamed के प्रकार के उपयोग की अनुमति सकता है, या एक स्थिर विधि में है - नहीं इसके निर्माता/उदाहरण विधि के भीतर या के बाद एक उदाहरण घोषित किया जाता है केवल? यह तुच्छ जब struct नाम पर है है:

// How to make it work with S absent (an unnamed struct) ? 
struct S { 
    Bar<S> foo; // how to get our type in an unnamed struct? 
    static void wrapper(void * instance) { 
    static_cast<S*>(instance)->method(); // how to get our type in an unnamed struct? 
    } 
    void method() { ... } 
} would_be_unnamed; 

यह सवाल एक question about how to implement a destructor in an unnamed struct से प्रेरित हुआ। तुच्छ समाधान वहाँ एक अनाम से एक में एक नामित struct रैप करने के लिए था - इस तरह के आवरण, आदि

struct { struct S { ... } s; } unnamed; 

तो किसी भी अन्य प्रकार के साथ संघर्ष के बिना मैक्रो में इस्तेमाल किया जा सकता प्रकार का उपयोग पहेली को सुलझाने के लिए एक अलग समाधान की अनुमति होगी प्रेरणादायक सवाल।

Answer 1

ऐसा कुछ, हो सकता है?

विचार यह है कि आपके पास वास्तव में दो अज्ञात structs हैं। सबसे पहले, unnamed में सभी वास्तविक कोड/डेटा और सामान शामिल हैं। फिर unnamedWrapper है, unnamed से अधिक unnamed पर उपयोग करने में सक्षम होने के कारण, unnamed के आस-पास एक पूरी तरह से अग्रेषण (यहां तक ​​कि कन्स्ट्रक्टर के लिए भी) रैपर है, जिसमें एक विशेष विशेषता है कि यह unnamed के टाइप टाइपिफ़ के माध्यम से निर्यात करता है।

#include <cstddef> 

template<typename T> 
size_t templatedSizeof() { 
    return sizeof(T); 
} 

struct { 
    char something; 
    short somethingElse; 
    int  moreGargabe; 
    long evenMoreUselessGarbage; 
} unnamed; 

struct : public decltype(unnamed) { 
    typedef decltype(unnamed) TheType; 

    using TheType::TheType; // Use same constructors 
} unnamedWrapper;