सब कुछ आप के बारे में पता करने की आवश्यकता है :: कोई भी

मूल बातें

class MyAny
{
    void* _value;
    TypeInfo _typeInfo;
};

std::any a(12);

//    :
a = std::string("Hello!");
a = 16;
//   :

//    a  
std::cout << std::any_cast<int>(a) << '\n'; 

//    :
try 
{
    std::cout << std::any_cast<std::string>(a) << '\n';
}
catch(const std::bad_any_cast& e) 
{
    std::cout << e.what() << '\n';
}

//        - :
a.reset();
if (!a.has_value())
{
    std::cout << "a is empty!" << "\n";
}

//    any  :
std::map<std::string, std::any> m;
m["integer"] = 10;
m["string"] = std::string("Hello World");
m["float"] = 1.0f;

for (auto &[key, val] : m)
{
    if (val.type() == typeid(int))
        std::cout << "int: " << std::any_cast<int>(val) << "\n";
    else if (val.type() == typeid(std::string))
        std::cout << "string: " << std::any_cast<std::string>(val) << "\n";
    else if (val.type() == typeid(float))
        std::cout << "float: " << std::any_cast<float>(val) << "\n";
}

16
bad any_cast
a is empty!
float: 1
int: 10
string: Hello World

• std::any — std::optional std::variant
• , .has_value()
• .reset()
• std::decay
• ,
• std::any_cast, bad_any_cast, «T»
• .type(), std::type_info

कब इस्तेमाल करें?

• पुस्तकालयों में - जब आपके पुस्तकालय को कुछ डेटा संग्रहीत या स्थानांतरित करने की आवश्यकता होती है, और आपको नहीं पता कि यह डेटा किस प्रकार का हो सकता है
• फ़ाइलों को पार्स करते समय - यदि आप वास्तव में यह निर्धारित नहीं कर सकते हैं कि किस प्रकार का समर्थन किया जाता है
• संदेश
• स्क्रिप्टिंग भाषा इंटरैक्शन
• स्क्रिप्टिंग भाषा के लिए दुभाषिया बनाना
• यूजर इंटरफेस - फील्ड्स कुछ भी स्टोर कर सकते हैं

एसटीडी बनाएँ :: कोई भी

• मानक आरंभीकरण - वस्तु खाली है
• मूल्य / वस्तु के साथ प्रत्यक्ष आरंभीकरण
• सीधे वस्तु के प्रकार का संकेत - std::in_place_type
• के जरिए std::make_any

//  :
std::any a;
assert(!a.has_value());

//   :
std::any a2(10); // int
std::any a3(MyType(10, 11));

// in_place:
std::any a4(std::in_place_type<MyType>, 10, 11);
std::any a5{std::in_place_type<std::string>, "Hello World"};

// make_any
std::any a6 = std::make_any<std::string>("Hello World");

बदलते सिद्धांत बदलते मूल्य, बदलती कीमत

std::any a;

a = MyType(10, 11);
a = std::string("Hello");

a.emplace<float>(100.5f);
a.emplace<std::vector<int>>({10, 11, 12, 13});
a.emplace<MyType>(10, 11);

वस्तु जीवन चक्र

std::any var = std::make_any<MyType>();
var = 100.0f;
std::cout << std::any_cast<float>(var) << "\n";

MyType::MyType
MyType::~MyType
100

किसी मान पर पहुँच प्राप्त करना

• मान की एक प्रति लौटाएं और std::bad_any_castत्रुटि पर छोड़ दें
• मान के लिए लिंक लौटाएं और std::bad_any_cast त्रुटि पर छोड़ दें
• किसी त्रुटि के मामले में एक पॉइंटर को एक मान (स्थिर या नहीं) या नल्ट्रप्र पर लौटाएं

struct MyType
{
    int a, b;

    MyType(int x, int y) : a(x), b(y) { }

    void Print() { std::cout << a << ", " << b << "\n"; }
};

int main()
{
    std::any var = std::make_any<MyType>(10, 10);
    try
    {
        std::any_cast<MyType&>(var).Print();
        std::any_cast<MyType&>(var).a = 11; // /
        std::any_cast<MyType&>(var).Print();
        std::any_cast<int>(var); // throw!
    }
    catch(const std::bad_any_cast& e) 
    {
        std::cout << e.what() << '\n';
    }

    int* p = std::any_cast<int>(&var);
    std::cout << (p ? "contains int... \n" : "doesn't contain an int...\n");

    MyType* pt = std::any_cast<MyType>(&var);
    if (pt)
    {
        pt->a = 12;
        std::any_cast<MyType&>(var).Print();
    }
}

प्रदर्शन और स्मृति उपयोग

कार्यान्वयन एक छोटे निहित मूल्य के लिए गतिशील रूप से आवंटित स्मृति के उपयोग से बचना चाहिए। उदाहरण: जहां निर्मित वस्तु केवल एक इंट पकड़ रही है। इस तरह की छोटी-वस्तु अनुकूलन केवल T के लिए लागू होगी, जिसके लिए is_nothrow_move_constructible_v सच है

एक कार्यान्वयन को छोटे आकार के संग्रहीत डेटा के लिए गतिशील मेमोरी का उपयोग करने से बचना चाहिए। उदाहरण के लिए, जब किसी वस्तु को केवल int का भंडारण किया जाता है। छोटी वस्तुओं के लिए ऐसा अनुकूलन केवल T पर लागू होना चाहिए जिसके लिए is_nothrow_move_constructible_v सत्य है।

बढ़ावा देने से पलायन :: कोई भी

Std :: any का उपयोग करने के उदाहरण

फ़ाइल पार्सिंग

संदेश

LRESULT CALLBACK WindowProc(
  _In_ HWND   hwnd,
  _In_ UINT   uMsg,
  _In_ WPARAM wParam,
  _In_ LPARAM lParam
);

class Message
{
public:
    enum class Type 
    {
        Init,
        Closing,
        ShowWindow,        
        DrawWindow
    };

public:
    explicit Message(Type type, std::any param) :
        mType(type),
        mParam(param)
    {   }
    explicit Message(Type type) :
        mType(type)
    {   }

    Type mType;
    std::any mParam;
};

class Window
{
public:
    virtual void HandleMessage(const Message& msg) = 0;
};

Message m(Message::Type::ShowWindow, std::make_pair(10, 11));
yourWindow.HandleMessage(m);

switch (msg.mType) {
// ...
case Message::Type::ShowWindow:
    {
    auto pos = std::any_cast<std::pair<int, int>>(msg.mParam);
    std::cout << "ShowWidow: "
              << pos.first << ", " 
              << pos.second << "\n";
    break;
    }
}

गुण

struct property
{
    property();
    property(const std::string &, const std::any &);

    std::string name;
    std::any value;
};

typedef std::vector<property> properties;

हम सीमाओं से गुजरते हैं

लब्बोलुआब यह है कि एसटीडी :: कोई भी आपको सीमाओं के मनमाने डेटा पर अधिकार स्थानांतरित करने की अनुमति देता है जो इसके प्रकार के बारे में नहीं जानते हैं।

• इंटरफ़ेस के लिए लाइब्रेरी में: आपको नहीं पता कि क्लाइंट किस प्रकार का उपयोग करना चाहता है
• मैसेजिंग: एक ही विचार - ग्राहक को लचीलापन दें
• फ़ाइल पार्सिंग: किसी भी प्रकार का समर्थन करने के लिए

संपूर्ण

• std::any टेम्पलेट क्लास नहीं
• std::any छोटी वस्तुओं के अनुकूलन का उपयोग करता है, इसलिए यह गतिशील रूप से सरल प्रकार जैसे इंट या डबल के लिए मेमोरी आवंटित नहीं करेगा, और बड़े प्रकार के लिए, अतिरिक्त मेमोरी का उपयोग किया जाएगा।
• std::any "भारी" कहा जा सकता है, लेकिन यह सुरक्षा और अधिक लचीलापन प्रदान करता है
• डेटा की पहुंच std::anyकी मदद से प्राप्त किया जा सकता है any_cast, जो कई "मोड" प्रदान करता है। उदाहरण के लिए, एक त्रुटि के मामले में, यह एक अपवाद फेंक सकता है या बस nullptr वापस कर सकता है
• इसका उपयोग तब करें जब आपको पता न हो कि डेटा प्रकार क्या संभव है, अन्यथा उपयोग करने पर विचार करें std::variant