Semua yang perlu Anda ketahui tentang std :: any

Dasar

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

Kapan menggunakannya?

• Di perpustakaan - saat perpustakaan Anda perlu menyimpan atau mentransfer beberapa data, dan Anda tidak tahu tipe data ini
• Saat mem-parsing file - jika Anda benar-benar tidak dapat menentukan jenis apa yang didukung
• Olahpesan
• Interaksi Bahasa Scripting
• Membuat penerjemah untuk bahasa skrip
• Antarmuka Pengguna - Bidang Dapat Menyimpan Apa Pun

Buat std :: any

• inisialisasi standar - objek kosong
• inisialisasi langsung dengan nilai / objek
• langsung menunjukkan jenis objek - std::in_place_type
• melalui 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");

Ubah nilai

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

Siklus Hidup Obyek

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

MyType::MyType
MyType::~MyType
100

Mendapatkan akses ke suatu nilai

• mengembalikan salinan nilai dan berhenti std::bad_any_castkarena kesalahan
• mengembalikan tautan ke nilai dan berhenti std::bad_any_cast karena kesalahan
• mengembalikan pointer ke nilai (konstan atau tidak) atau nullptr jika terjadi kesalahan

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

Performa dan penggunaan memori

Implementasi harus menghindari penggunaan memori yang dialokasikan secara dinamis untuk nilai yang terkandung kecil. Contoh: di mana objek yang dibangun hanya memegang int. Optimalisasi objek kecil seperti itu hanya akan diterapkan pada tipe T yang is_nothrow_move_constructible_v benar

Implementasi harus menghindari penggunaan memori dinamis untuk data tersimpan berukuran kecil. Misalnya, ketika sebuah objek dibuat hanya menyimpan int. Optimalisasi seperti itu untuk objek kecil seharusnya hanya diterapkan pada tipe T yang is_nothrow_move_constructible_v benar.

Bermigrasi dari boost :: any

Contoh penggunaan std :: any

Penguraian file

Olahpesan

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

Properti

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

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

typedef std::vector<property> properties;

Kami melewati perbatasan

Intinya adalah std :: any memungkinkan Anda untuk mentransfer hak atas data sewenang-wenang lintas batas yang tidak tahu jenisnya.

• di perpustakaan untuk antarmuka: Anda tidak tahu jenis apa yang ingin digunakan klien di sana
• olahpesan: ide yang sama - memberikan fleksibilitas pelanggan
• parsing file: untuk mendukung semua jenis

Total

• std::any bukan kelas templat
• std::any menggunakan pengoptimalan objek kecil, sehingga tidak akan secara dinamis mengalokasikan memori untuk tipe sederhana seperti int atau double, dan untuk tipe yang lebih besar, memori tambahan akan digunakan
• std::any bisa disebut "berat", tetapi menawarkan keamanan dan fleksibilitas yang lebih besar
• Akses ke data std::anydapat diperoleh dengan bantuan any_cast, yang menawarkan beberapa "mode". Misalnya, jika terjadi kesalahan, ini dapat menimbulkan pengecualian atau hanya mengembalikan nullptr
• menggunakannya ketika Anda tidak tahu persis tipe data apa yang mungkin, jika tidak pertimbangkan untuk menggunakannya std::variant