Boost库学习笔记（四）any类型

Boost库学习笔记（四）any类型

一、简介

boost的本模块提供了一个泛型的类型，这个泛型类型不同于传统意义上基于模板的编程，他可以被视为一个真正可变自由的变量，而不是被固定类型静态指定，一般有以下三种用法：

• 可以在不同的数据类型之间灵活转换，例如将int的5解释为string的"5"，反之亦然，boost::lexical_cast支持这样的转换需求。
• 可以容纳不同类型的值，但是不对其在不同的类型之间进行转换，比如5保持严格的int类型，不能够隐式的转换为“5”或者5.0，对其值的解释不关心，对类型的认识有效地使它们成为安全的、通用的单一值容器，不会因模棱两可的转换而产生意外。
• 可以随意的引用任何能够引用的东西，不关系其类型，将所有的对底层的解释交给开发人员，利用void*，可以对未定义的行为提供了充足的空间。

二、引用

<boost/any.hpp>

namespace boost {
  class any;
  void swap(any &, any &);
  template<typename T> T any_cast(any &);
  template<typename T> T any_cast(any &&);
  template<typename T> T any_cast(const any &);
  template<typename ValueType> const ValueType * any_cast(const any *);
  template<typename ValueType> ValueType * any_cast(any *);
}

<boost/any/bad_any_cast.hpp>

namespace boost {
  class bad_any_cast;
}

<boost/any/basic_any.hpp>

namespace boost {
  namespace anys {
    template<std::size_t OptimizeForSize, std::size_t OptimizeForAlignment> 
      class basic_any;
    void swap(basic_any &, basic_any &);
    template<typename T> T any_cast(basic_any &);
    template<typename T> T any_cast(basic_any &&);
    template<typename T> T any_cast(const basic_any &);
    template<typename ValueType> const ValueType * any_cast(const basic_any *);
    template<typename ValueType> ValueType * any_cast(basic_any *);
  }
}

三、实例

#include <list>
#include <boost/any.hpp>
#include <algorithm>
#include <iostream>

using boost::any_cast;
typedef std::list<boost::any> many;

void append_int(many& values, int value) {
	boost::any to_append = value;
	values.push_back(to_append);
}

void append_string(many& values, const std::string& value) {
	values.push_back(value);
}

void append_char_ptr(many& values, const char* value) {
	values.push_back(value);
}

void append_any(many& values, const boost::any& value) {
	values.push_back(value);
}

void append_noting(many& values) {
	values.push_back(boost::any());
}

bool is_empty(const boost::any& operand)
{
    return operand.empty();
}

bool is_int(const boost::any& operand)
{
    return operand.type() == typeid(int);
}

bool is_char_ptr(const boost::any& operand)
{
    try
    {
        any_cast<const char*>(operand);
        return true;
    }
    catch (const boost::bad_any_cast&)
    {
        return false;
    }
}

bool is_string(const boost::any& operand)
{
    return any_cast<std::string>(&operand);
}

void count_all(many& values, std::ostream& out)
{
    out << "#empty == "
        << std::count_if(values.begin(), values.end(), is_empty) << std::endl;
    out << "#int == "
        << std::count_if(values.begin(), values.end(), is_int) << std::endl;
    out << "#const char * == "
        << std::count_if(values.begin(), values.end(), is_char_ptr) << std::endl;
    out << "#string == "
        << std::count_if(values.begin(), values.end(), is_string) << std::endl;
}

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

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

property::property(const std::string& name, const boost::any& value)
{
    this->name = name;
    this->value = value;
}

typedef std::list<property> properties;

class consumer
{
public:
    virtual void notify(const boost::any&) = 0;
    std::string name;
};

class school_consumer :public consumer {
public:
    school_consumer() = default;
    void notify(const boost::any& object) {
        std::cout << "notify:   "<< std::endl;
    }
};

int main(int argc, char** argv) {
    std::list<boost::any> myList;
    append_int(myList, 1);
    append_string(myList, "test");
    append_any(myList, 4);
    char cs = 's';
    const char* ptr = &cs;
    append_char_ptr(myList, ptr);
    append_noting(myList);
    //对所有类型计数
    count_all(myList,std::cout);
    //利用any的特性做配置的存储
    properties pros;
    property pro1("url", "https://xxx.com");
    property pro2("ConnnectionCount", 8);
    pros.push_back(pro1);
    pros.push_back(pro2);
    school_consumer scConsumer;
    scConsumer.notify(5);
    return 0;
}

运行结果：