C++ 调用类的成员函数后的垃圾值

我试图从类b调用类a的一个成员，但没有成功。它可以工作，但总是为类a中的向量提供垃圾值。是的，在第三次抛出异常，而读取循环只应运行2次

b、 h

main.cpp

#include "b.h"


int main() {
    b obj_1( "" );
    obj_1.all( "xyz" );
    obj_1.out();

}

a、 cpp

#包括“a.h”
a：：a（）
：s{0}
{
}
a：：a（a&ai）
：s{ai.s}，n{ai.n}
{
用于（自动c:ai.v）
v、 推回（c）；
}
a:：a（a&&ai）不例外
：s{ai.s}，n{ai.n}
{
用于（自动c:ai.v）
v、 推回（c）；
ai.v.clear（）；
}
void a：：set_v（int i）{v.push_back（i）；}
void a：：set_s（size_t si）{s=si；}
void a：：set_n（string na）{n=na；}
void a：：print（）{
cout非类型不能直接写入或读取。例如，std:：string类。string类有一些成员数据，但通常字符串内容在其他地方（如动态内存中）

我建议为类定义
操作符来序列化和取消序列化

这个库处理起来相当优雅。我在几个项目中使用过它。这里有一个示例程序，展示了如何使用它

唯一的原生方法是使用流。这基本上就是
Boost:：serialization
库所做的，它通过设置一个框架来扩展流方法，将对象写入类似文本的格式，并从相同的格式读取它们

对于内置类型，或者您自己定义了
operator
的类型，这相当简单；有关更多信息，请参阅

另见和

**编辑：**

试试这个，但这不是便携式的，它不能处理所有角落的情况

#include <iostream>
#include <string>
#include <vector>

#include <fstream>

class Bin {

public:
    void set_size(size_t s)                 { size_ = s; }
    void set_str(const std::string& s)      { str_ = s; }
    void append_int(int s)                  { vec_.emplace_back(s); }

public:
    size_t get_size(void) const             { return size_; }
    std::string get_str(void) const         { return str_; }
    std::vector<int> get_vec(void) const    { return vec_; }

public:
    void print(void) const
    {
        std::cout << "---- A ----" << std::endl;
        std::cout << "Size: " << size_ << std::endl;
        std::cout << "Str: " << str_ << std::endl;
        std::cout << "Vec: ";
        for (const auto& i: vec_)
            std::cout << i << " ";
        std::cout << std::endl;
        std::cout << "-----------" << std::endl;
    }

public:
    friend std::ofstream& operator<<(std::ofstream& fstream, const Bin& obj)
    {
        size_t str_size = obj.str_.length();
        size_t vec_size = obj.vec_.size();
        fstream.write(reinterpret_cast<const char *>(&obj.size_), sizeof(obj.size_));
        fstream.write(reinterpret_cast<const char *>(&str_size), sizeof(str_size));
        for (const auto& i: obj.str_)
            fstream.write(reinterpret_cast<const char *>(&i), sizeof(i));
        fstream.write(reinterpret_cast<const char *>(&vec_size), sizeof(vec_size));
        for (const auto& i: obj.vec_)
            fstream.write(reinterpret_cast<const char *>(&i), sizeof(i));
        return fstream;
    }

public:
    friend std::ifstream& operator>>(std::ifstream& fstream, Bin& obj)
    {
        obj.str_.clear();
        obj.vec_.clear();
        size_t size = 0;

        fstream.read(reinterpret_cast<char *>(&obj.size_), sizeof(obj.size_));
        fstream.read(reinterpret_cast<char *>(&size), sizeof(size));
        for (size_t i = 0; i < size; i++)
        {
            char c;
            fstream.read(&c, sizeof(c));
            obj.str_.push_back(c);
        }
        fstream.read(reinterpret_cast<char *>(&size), sizeof(size));
        for (size_t i = 0; i < size; i++)
        {
            int j;
            fstream.read(reinterpret_cast<char *>(&j), sizeof(j));
            obj.vec_.emplace_back(j);
        }
        return fstream;
    }

private:
    size_t size_;
    std::string str_;
    std::vector<int> vec_;
};

int main(void)
{
    Bin a, b;
    a.set_size(100);
    a.set_str("stackoverflow");
    for (int i = 0; i < 10; i++)
        a.append_int(i + 1);
    a.print();
    {
        std::ofstream ostream("see.bin", std::ios::out | std::ios::binary);
        ostream << a;
    }

    std::ifstream istream("see.bin", std::ios::in | std::ios::binary);
    istream >> b;
    b.print();
    return 0;
}

#包括
#包括
#包括
#包括
分类箱{
公众：
空集大小（大小）{size=s；}
void set_str（const std:：string&s）{str_=s；}
void append_int（int s）{vec_.emplace_back（s）；}
公众：
size_t get_size（void）const{return size_；}
std:：string get_str（void）const{return str_；}
std:：vector get_vec（void）const{return vec_；}
公众：
无效打印（无效）常量
{
std：：cout
a
的定义在哪里？请做一个。我会尽量让它尽可能短。如果必要，我添加了a的定义，请告诉我你是否需要.h文件。谢谢你的帮助，因为我使用的是二进制文件。我应该使用运算符重载还是只使用读写功能？嘿，我试过使用读方法，但唯一的问题是，每当调用a的析构函数时，它都会给出一个错误。请告诉我原因，因为我还不想使用序列化，无论如何，感谢您的帮助。（编辑：可能是由于删除了a中的字符串）（void _Container_base12:：_Orphan_all（）//此函数在xmemory中出现异常）请参见我的答案中的示例。非常感谢它所做的一切。我在>>和上使用了运算符重载
#include "b.h"


int main() {
    b obj_1( "" );
    obj_1.all( "xyz" );
    obj_1.out();

}

#include "a.h"

a::a()
    :s{ 0 }
{
}

a::a( a& ai )
    : s{ ai.s }, n{ ai.n }
{
    for (auto c : ai.v)
        v.push_back( c );
}

a::a( a&& ai ) noexcept
    :s{ ai.s }, n{ ai.n }
{
    for (auto c : ai.v)
        v.push_back( c );
    ai.v.clear();
}

void a::set_v( int i ) {v.push_back( i );}

void a::set_s( size_t si ) {    s = si;}

void a::set_n( string na ) {n = na;}


void a::print(){
    cout << s << " " << n << " ";
    for (int &p : v)
        cout << " " << p;
}

a::~a() {v.clear();}

#include <iostream>
#include <string>
#include <vector>

#include <fstream>

class Bin {

public:
    void set_size(size_t s)                 { size_ = s; }
    void set_str(const std::string& s)      { str_ = s; }
    void append_int(int s)                  { vec_.emplace_back(s); }

public:
    size_t get_size(void) const             { return size_; }
    std::string get_str(void) const         { return str_; }
    std::vector<int> get_vec(void) const    { return vec_; }

public:
    void print(void) const
    {
        std::cout << "---- A ----" << std::endl;
        std::cout << "Size: " << size_ << std::endl;
        std::cout << "Str: " << str_ << std::endl;
        std::cout << "Vec: ";
        for (const auto& i: vec_)
            std::cout << i << " ";
        std::cout << std::endl;
        std::cout << "-----------" << std::endl;
    }

public:
    friend std::ofstream& operator<<(std::ofstream& fstream, const Bin& obj)
    {
        size_t str_size = obj.str_.length();
        size_t vec_size = obj.vec_.size();
        fstream.write(reinterpret_cast<const char *>(&obj.size_), sizeof(obj.size_));
        fstream.write(reinterpret_cast<const char *>(&str_size), sizeof(str_size));
        for (const auto& i: obj.str_)
            fstream.write(reinterpret_cast<const char *>(&i), sizeof(i));
        fstream.write(reinterpret_cast<const char *>(&vec_size), sizeof(vec_size));
        for (const auto& i: obj.vec_)
            fstream.write(reinterpret_cast<const char *>(&i), sizeof(i));
        return fstream;
    }

public:
    friend std::ifstream& operator>>(std::ifstream& fstream, Bin& obj)
    {
        obj.str_.clear();
        obj.vec_.clear();
        size_t size = 0;

        fstream.read(reinterpret_cast<char *>(&obj.size_), sizeof(obj.size_));
        fstream.read(reinterpret_cast<char *>(&size), sizeof(size));
        for (size_t i = 0; i < size; i++)
        {
            char c;
            fstream.read(&c, sizeof(c));
            obj.str_.push_back(c);
        }
        fstream.read(reinterpret_cast<char *>(&size), sizeof(size));
        for (size_t i = 0; i < size; i++)
        {
            int j;
            fstream.read(reinterpret_cast<char *>(&j), sizeof(j));
            obj.vec_.emplace_back(j);
        }
        return fstream;
    }

private:
    size_t size_;
    std::string str_;
    std::vector<int> vec_;
};

int main(void)
{
    Bin a, b;
    a.set_size(100);
    a.set_str("stackoverflow");
    for (int i = 0; i < 10; i++)
        a.append_int(i + 1);
    a.print();
    {
        std::ofstream ostream("see.bin", std::ios::out | std::ios::binary);
        ostream << a;
    }

    std::ifstream istream("see.bin", std::ios::in | std::ios::binary);
    istream >> b;
    b.print();
    return 0;
}