C++ 如何在C+中对称地实现模板函数的序列化和反序列化+；

我想编写一系列模板函数来序列化和反序列化对象。我已经完成了序列化部分，一切正常：

#ifndef SERIALIZE_H
#define SERIALIZE_H

#include <string>
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <memory>

inline std::string to_json(int value) {
    return std::to_string(value);
}


inline std::string to_json(long value) {
    return std::to_string(value);
}


inline std::string to_json(double value) {
    return std::to_string(value);
}


inline std::string to_json(const std::string& myStr) {
    return "\"" + myStr + "\"";
}


template <typename T>
std::string to_json(const std::vector<T>& vec) {
    std::string json("[");

    for(auto &i : vec) {
        json += to_json(i);
        json += ",";
    }

    if (!vec.empty()) json.pop_back();
    json += "]";
    return json;
}


template <typename T>
std::string to_json(const std::unordered_set<T>& mySet) {
    std::string json("[");

    for(const auto& i : mySet) {
        json += to_json(i);
        json += ",";
    }

    if (!mySet.empty()) json.pop_back();
    json += "]";
    return json;
}


template <typename K, typename V>
std::string to_json(const std::unordered_map<K, V>& myMap) {
    std::string json("{");

    for(const auto& i : myMap) {
        json += to_json(i.first);
        json += ":";
        json += to_json(i.second);
        json += ",";
    }

    if (!myMap.empty()) json.pop_back();
    json += "}";
    return json;
}

#endif //SERIALIZE_H

<代码> RAPIDJSON//COD>是C++ JSON库，

然后，如果我尝试反序列化JSON字符串：

#include "deserialize.h>

int main() {
    auto vec1 = from_json<std::vector<int>>(std::string("[1,2,3]"));
    return 0;
}

似乎没有办法像序列化那样轻松地实现反序列化功能

---

有什么想法吗？

您每次都试图用相同的参数和不同的返回类型重载相同的函数（来自_json（…））。这是不合法的。 对于重载，您需要不同的参数类型或参数编号

Instead of
template<>
double from_json(const std::string &json) {
    return std::stod(json);
}

template<>
std::string from_json(const std::string &json) {
    return json.substr(1, json.size()-1);
}

而不是
模板
来自_json的双精度（const std:：string&json）{
返回std：：stod（json）；
}
模板
std:：string from_json（const std:：string&json）{
返回json.substr（1，json.size（）-1）；
}

也许可以试试这个，或者至少这应该是一般的想法：

template<>
void from_json(const std::string &json, double *out_value) {
    *out_value = std::stod(json);
}

template<>
void from_json(const std::string &json, std::string *out_value) {
    out_value = json.substr(1, json.size()-1);
}

模板
void from_json（const std:：string&json，double*out_值）{
*out_value=std:：stod（json）；
}
模板
void from_json（const std:：string&json，std:：string*out_值）{
out_value=json.substr（1，json.size（）-1）；
}

---

我肯定会有错误，但我认为这样做是可行的（如果您修复了它们）

OP将函数模板显式专门化与函数重载相结合。特别是来自_hson的

模板双精度（const std:：string&json）

是来自_json（const std:：string&json）的

模板T的显式专门化主模板。使用不同的参数类型可以工作，这是肯定的，但我仍然希望对返回类型进行模板专门化。相关：。具体来说，您定义的两个（主要）函数模板之间没有更专门的关系，因为它们的返回类型不同。如果您想保留该接口，一个解决方案是从_json（tag，const std:：string&）分派到一些
模板T；模板std:：vector from_json（tag，const std:：string&）重载集，其中可以基于第一个（dummy/tag）参数建立更专门的关系。转换字符串不是一个简单的操作。您是否希望它从_json（const std:：string&json）调用
模板t，或来自_json（const std:：string&json）的
模板std:：vector
？也就是说，它应该返回一个
std:：vector
（来自声明但未定义的第一个模板）还是一个
std:：vector
（来自第二个模板）？
Instead of
template<>
double from_json(const std::string &json) {
    return std::stod(json);
}

template<>
std::string from_json(const std::string &json) {
    return json.substr(1, json.size()-1);
}

template<>
void from_json(const std::string &json, double *out_value) {
    *out_value = std::stod(json);
}

template<>
void from_json(const std::string &json, std::string *out_value) {
    out_value = json.substr(1, json.size()-1);
}