类型安全提升::p roperty_tree equivalent.

您可以尝试通过转换器强制数据访问来强制使用类型。

这意味着，您可以创建一个环绕/模拟property_tree接口的类，但添加一些额外的实现功能来尝试控制类型。

我提供了一个简单的类ptree_type_safe，它模仿了property_tree(put((和get(((的一些数据访问接口，但只允许检索某些类型。如果运行代码，则在调用double val3 pt.get<double>("key1")时，它应该打印ptree_bad_data错误消息。

#include<iostream>
#include<boost/property_tree/ptree.hpp>
#include<boost/optional.hpp>

// Wrapper class for boost::property_tree::ptree
class ptree_type_safe
{
public:
    // Constructor
    ptree_type_safe() : m_Internal_tree(boost::property_tree::ptree()) {}
    // Example function wrappers to take special measure will dealing with types
    // put()
    template<class Type>
    boost::property_tree::ptree::self_type& put(const boost::property_tree::ptree::path_type& Path, const Type& Value)
    {
        return m_Internal_tree.put(Path, Value);
    }
    // get()
    template<class Type>
    Type get(const boost::property_tree::ptree::path_type& Path)
    {
        return m_Internal_tree.get<Type>(Path, force_type<Type>());
    }
private:
    boost::property_tree::ptree m_Internal_tree; // ptree
    // force_type is a Translator that can be used to convert types
    // and in this case, enforce calls to get() of only allowed types
    template<typename T>
    struct force_type
    {
        typedef std::string internal_type;
        typedef T external_type;
        boost::optional<T> get_value(const std::string& Key)
        {
            // This function will return the result of return_value<T>() if T is an allowed
            // type, that is T has explicit specialization for struct is_allowed_type<T>
            // and T has explicit specialization for the function return_value<T>().
            return boost::make_optional(is_allowed_type<T>::value, return_value<T>(Key));
        }
        template<typename Arg_type>
        struct is_allowed_type : std::false_type
        {
        };
        template<>
        struct is_allowed_type<std::string> : std::true_type
        {
        };
        template<>
        struct is_allowed_type<const char*> : std::true_type
        {
        };
        template<typename Return_type>
        Return_type return_value(const std::string& Key)
        {
            // This will be called.
            // Shouldn't matter if because get_value<ReturnType>() will throw an error.
            // Will not compile if Return_type has no default constructor.
            // Anyway, this should get the users attention, which is the primary goal.
            return Return_type();
        }
        template<>
        std::string return_value<std::string>(const std::string& Key)
        {
            return Key;
        }
        template<>
        const char* return_value<const char*>(const std::string& Key)
        {
            return Key.c_str();
        }
    }; // force_type
}; //ptree_type_safe
int main()
{
    using boost::property_tree::ptree;
    //ptree pt;
    ptree_type_safe pt; // use wrapper
    pt.put("key1", "1.2"); // insert a string in key1
    std::string val1 = pt.get<std::string>("key1"); // ok
    try
    {
        double val3 = pt.get<double>("key1"); // ideally would throw
    }
    catch (boost::property_tree::ptree_bad_data& Error)
    {
        std::cout << Error.what() << std::endl;
    }
    return 0;
}