【C++】C++17中可以存储任意类型数据的对象——any类的使用与设计思想

东洛的克莱斯韦克

于 2024-09-26 11:05:33 发布

阅读量519

点赞数 54

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/2301_79796701/article/details/142546906

版权

C++ 专栏收录该内容

22 篇文章 2 订阅

订阅专栏

个人主页：东洛的克莱斯韦克-CSDN博客

C++专栏：C++_东洛的克莱斯韦克的博客-CSDN博客

引言

一提到存储任意类型，第一时间想到的可能就是STL容器，这种容器都是模板。但是，模板类在实例化对象是都要指定类型，例如std::vector<int> v 。那么模板实例化的对象存储的数据类型就是固定的。

C++17提供了std::any类，头文件是<any>。any类实例化的对象可以存储任意类型的数据，本文会为大家介绍如何使用any类以及any类是如何实现的。

any类的使用

构造

any类最常用的构造

1.空构造 2.用任意类型数据构造 3.用any容器构造

    std::any a; //空构造
    std::any a1(43);  //任意类型数据构造
    std::any a2(a1);  //any容器构造

也可以用std::make_any构造，返回值为std::any

    std::any b = std::make_any<int>(43);

=号运算符重载

1.any对象允许被另一个any对象赋值

2.any对象允许被一个任意类型的数据赋值

   std::any a; 
   std::any a1 = a;  //对象赋值
   std::any a2 = "ccc";  //任意类型的数据赋值

std::any::swap

std::any::swap交换两个any对象中存储的数据


    std::any b = std::make_any<int>(43);
    a = std::string("ccc");
    b.swap(a); //交换数据

std::any::has_value

std::any::has_value查看any对象中是否有数据，返回值是bool类型

 if (b.has_value())
    {
        std::cout << "b对象中有数据" << std::endl;
    }

std::any::type

std::any::type判断any类中的数据类型，返回值是const std::type_info& 。要使用这个成员函数，需要搭配一个运算符——typeid。typeid操作符返回一个对std::type_info对象的引用，该对象表示了操作数的类型。

std::type_info对象中重载了== 和!=运算符，用来比较两个类型是否一致

std::any b = std::make_any<int>(43);
 const std::type_info &t1 = b.type();
    if (t1 == typeid(int))
    {
        std::cout << "b对象存的是整型" << std::endl;
    }

std::any::reset

std::any::reset销毁对象（自己）

std::any_cast

std::any_cast进行对所含有对象的类型安全访问。

参数和返回值：

1.any对象的引用，返回any对象中存储数据的拷贝

2.any对象的指针，返回any对象中存储数据的指针

要确保接收的typeid与any对象中数据的typeidy一致。

 int c = std::any_cast<int>(b);
    std::cout << "c的值是:" << c << std::endl;

any类的设计思想

设计的大体思路：

any类中存一个anyptr类的指针，而anyptr类是anydate类的父类，any类和anyptr类都是普通的类，而anydate类是模板类，在anydate类中存储数据。

当我们实例化any类时，无需指定类型。

如下是any类实现样例

#include <algorithm>
#include <any>
#include <iostream>
#include <string>
#include <typeinfo>

class Any
{
private:
    class AnyPtr
    {
    public:
        virtual std::type_info GetType() = 0;
        virtual AnyPtr *clong() = 0;
    };

    template <class T>
    class AnyDate : public AnyPtr
    {
    public:
        T _val;
        AnyDate(const T &val)
            : _val(val)
        {
        }
        virtual std::type_info GetType()
        {
            return typeid(_val);
        }
        virtual AnyPtr *clong()
        {
            return new AnyDate(_val);
        }
    };

    AnyPtr *_anyptr;
    Any &Swap(Any &any)
    {
        std::swap(_anyptr, any._anyptr);
        return *this;
    }

public:
    Any()
        : _anyptr(nullptr)
    {
    }
    Any(const Any &any)
        : _anyptr(any._anyptr->clong())
    {
    }
    template <class T>
    Any(const T &val)
        : _anyptr(new AnyDate(val))
    {
    }
    ~Any()
    {
        if (_anyptr != nullptr)
            delete _anyptr;
    }
    Any &operator=(const Any &any)
    {
        Any(any).Swap(*this);
        return *this;
    }
    template <class T>
    Any &operator=(const T &val)
    {
        if (_anyptr->GetType() != typeid(T))
        {
            Any a;
            return a;
        }
        Any(val).Swap(*this);
        return *this;
    }
    template <class T>
    T *Get()
    {
        if (_anyptr->GetType() != typeid(T))
            return nullptr;
        return &(((AnyDate<T> *)_anyptr)->_val);
    }
};