java.io.Serialized 在 C/C++ 中的等价物是什么？

C/C++ 的等价物是什么java.io.Serialized https://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html?

有对序列化库的引用：

• 用 C 序列化数据结构 https://stackoverflow.com/questions/371371/serialize-data-structures-in-c

还有：

• http://troydhanson.github.io/tpl/index.html http://troydhanson.github.io/tpl/index.html
• http://www.boost.org/doc/libs/1_41_0/libs/serialization/doc/index.html http://www.boost.org/doc/libs/1_41_0/libs/serialization/doc/index.html
• https://developers.google.com/protocol-buffers/docs/cpptutorial#optimization-tips https://developers.google.com/protocol-buffers/docs/cpptutorial#optimization-tips

但这样的等价真的存在吗？

那么，如果我在 Java 中有一个如下所示的抽象类，那么在 C/C++ 中的可序列化类会是什么样子呢？

import java.io.Serializable;

public interface SuperMan extends Serializable{

    /**
     * Count the number of abilities.
     * @return
     */
    public int countAbility();

    /**
     * Get the ability with index k.
     * @param k
     * @return
     */
    public long getAbility(int k);

    /**
     * Get the array of ability from his hand.
     * @param k
     * @return
     */
    public int[] getAbilityFromHand(int k);

    /**
     * Get the finger of the hand.
     * @param k
     * @return
     */
    public int[][] getAbilityFromFinger(int k);

    //check whether the finger with index k is removed.
    public boolean hasFingerRemoved(int k);

    /**
     * Remove the finger with index k.
     * @param k
     */
    public void removeFinger(int k);

}

任何可序列化的 C/C++ 对象是否可以像 Java 中那样被继承？

没有标准库类可以实现序列化一样的方法Java做。有一些图书馆可以帮助序列化但为了满足基本需求，您通常会上课可序列化通过超载插入 and 萃取像这样的运算符：

class MyType
{
    int value;
    double factor;
    std::string type;

public:
    MyType()
    : value(0), factor(0.0), type("none") {}
    MyType(int value, double factor, const std::string& type)
    : value(value), factor(factor), type(type) {}

    // Serialized output
    friend std::ostream& operator<<(std::ostream& os, const MyType& m)
    {
        return os << m.value << ' ' << m.factor << ' ' << m.type;
    }

    // Serialized input
    friend std::istream& operator>>(std::istream& is, MyType& m)
    {
        return is >> m.value >> m.factor >> m.type;
    }
};

int main()
{
    std::vector<MyType> v {{1, 2.7, "one"}, {4, 5.1, "two"}, {3, 0.6, "three"}};

    std::cout << "Serialize to standard output." << '\n';

    for(auto const& m: v)
        std::cout << m << '\n';

    std::cout << "\nSerialize to a string." << '\n';

    std::stringstream ss;
    for(auto const& m: v)
        ss << m << '\n';

    std::cout << ss.str() << '\n';

    std::cout << "Deserialize from a string." << '\n';

    std::vector<MyType> v2;

    MyType m;
    while(ss >> m)
        v2.push_back(m);

    for(auto const& m: v2)
        std::cout << m << '\n';

}

Output:

Serialize to standard output.
1 2.7 one
4 5.1 two
3 0.6 three

Serialize to a string.
1 2.7 one
4 5.1 two
3 0.6 three

Deserialize from a string.
1 2.7 one
4 5.1 two
3 0.6 three

The 序列化格式完全取决于程序员，您有责任确保您想要的类的每个成员连载是它本身可序列化（有一个插入/萃取运算符定义）。您还必须处理字段如何分隔（空格或换行符或零终止？）。

所有基本类型都有序列化 (插入/萃取) 运算符是预定义的，但您仍然需要小心诸如std::string可以包含（例如）空格或换行符（如果您使用空格或换行符作为字段分隔符）。