كل ما تحتاج لمعرفته حول std :: any

أساسيات

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 :: any

• التهيئة القياسية - الكائن فارغ
• التهيئة المباشرة بالقيمة / الكائن
• تشير مباشرة إلى نوع الكائن - 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 الخطأ
• إرجاع المؤشر إلى قيمة (ثابتة أم لا) أو nullptr في حالة حدوث خطأ

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_othrow_move_constructible_v لها

يجب أن يتجنب التطبيق استخدام الذاكرة الديناميكية للبيانات المخزنة صغيرة الحجم. على سبيل المثال ، عندما يتم إنشاء كائن تخزين فقط int. يجب تطبيق هذا التحسين للأجسام الصغيرة فقط على الأنواع T التي يكون is_othrow_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 يستخدم أمثلية الكائنات الصغيرة ، لذلك لن يقوم بتخصيص ذاكرة ديناميكية للأنواع البسيطة مثل int أو double ، وبالنسبة للأنواع الأكبر ، سيتم استخدام ذاكرة إضافية
• std::any يمكن تسميتها "ثقيلة" ، ولكنها توفر السلامة ومرونة أكبر
• يمكن الحصول على الوصول إلى البيانات std::anyبمساعدة any_castالتي تقدم عدة "وسائط". على سبيل المثال ، في حالة حدوث خطأ ، قد يكون هناك استثناء أو مجرد إرجاع nullptr
• استخدمها عندما لا تعرف بالضبط أنواع البيانات الممكنة ، وإلا فكر في استخدامها std::variant