I'；当我将一个类声明为另一个类的成员时，我遇到了一个错误。错误：声明好友时必须使用类密钥 我是C++新手，我在做BooSooLoad实验，我想看看它是否在一个类被声明为另一个类的成员时起作用。但是当我编译我的代码时，我得到了大量的错误。我尝试将based声明为一个结构，但没有发生任何错误。我的代码： #include <iostream> #include <fstream> #include <boost/archive/text_iarchive.hpp> #include <boost/archive/text_oarchive.hpp> class baseds{}; class superior{}; class baseds { private: friend class boost::serialization::access; public: int a; int b; int c; baseds(){} ~baseds(){} template <class Archive> void serialize(Archive & ar, const unsigned int version) { ar & a; ar & b; ar & c; } }; class superior { private: friend class boost::serialization::access; public: int x; int y; baseds lag; superior(){} ~superior(){} template <class Archive> void serialize(Archive & ar, const unsigned int version) { ar & x; ar & y; ar & lag; } }; int main() { superior myData,myData2; myData.x=10; myData.y=20; myData.lag.a=1; myData.lag.b=2; myData.lag.c=3; ofstream ofs("steps.txt"); { boost::serialization::archive one(ofs); one << myData; } ifstream ifs("steps.txt"); { boost::serialization::archive two(ifs); two >> myData2; } std::cout<<"\n"<<myData2.x; std::cout<<"\n"<<myData2.y; std::cout<<"\n"<<myData2.lag.a; std::cout<<"\n"<<myData2.lag.b; std::cout<<"\n"<<myData2.lag.c; return 0; }

您正在重新定义

based

和

superior

。您应该得到一个类似于的错误

class baseds{};   // definition
class superior{}; // definition

// second definition
class baseds {
private:
 ....

错误：重新定义“基于类的”

---

删除第一对定义。

您定义了两次

基本定义和
高级定义

在gcc上，您将得到正确的错误消息：

main.cpp:9:7: error: redefinition of 'baseds'
class baseds {
      ^
main.cpp:6:7: note: previous definition is here
class baseds{};
      ^
main.cpp:27:7: error: redefinition of 'superior'
class superior  {
      ^
main.cpp:7:7: note: previous definition is here
class superior{};

看起来您的编译器无法识别重新定义并丢失，从而产生错误消息

如果要提供两个类的前向声明，则需要丢失大括号：

class baseds;
class superior;

class baseds {
  /* ... */
};

但是，如果您根本不使用
superior
来定义
based
，您可以完全省略正向声明-对于
superior
的定义，您需要定义
based
，由于您有该类型的成员，因此转发声明是不够的。
对不起，各位市民，这是一个愚蠢的问题，睡了一个好觉后发现了大部分错误
正确的代码如下所示：

#include <iostream>
#include <fstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>

class baseds;
class superior;

class baseds {
private:
    friend class boost::serialization::access;
public:
    int a;
    int b;
    int c;
    baseds(){}
    ~baseds(){}
    template <class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & a;
        ar & b;
        ar & c;
    }
};

class superior  {
private:
    friend class boost::serialization::access;
    friend class baseds;
public:
    int x;
    int y;
    baseds lag;
    superior(){}
    ~superior(){}
    template <class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & x;
        ar & y;
        ar & lag;
    }
};

int main()  {

    superior myData,myData2;
    myData.x=10;
    myData.y=20;
    myData.lag.a=1;
    myData.lag.b=2;
    myData.lag.c=3;

    std::ofstream ofs("steps.txt");
    {
        boost::archive::text_oarchive one(ofs);
        one << myData;
    }

    std::ifstream ifs("steps.txt");
    {
        boost::archive::text_iarchive two(ifs);
        two >> myData2;
    }
    std::cout<<"\n"<<myData2.x;
    std::cout<<"\n"<<myData2.y;
    std::cout<<"\n"<<myData2.lag.a;
    std::cout<<"\n"<<myData2.lag.b;
    std::cout<<"\n"<<myData2.lag.c;

    return 0;

}

#包括
#包括
#包括
#包括
以班级为基础；
班长；
类库{
私人：
好友类boost:：serialization:：access；
公众：
INTA；
int b；
INTC；
baseds（）{}
~baseds（）{}
模板
无效序列化（存档和ar，常量未签名整数版本）
{
ar&a；
ar&b；
ar&c；
}
};
班长{
私人：
好友类boost:：serialization:：access；
朋友类基地；
公众：
int x；
int-y；
基线滞后；
上级（）{}
~superior（）{}
模板
无效序列化（存档和ar，常量未签名整数版本）
{
ar&x；
ar&y；
ar&lag；
}
};
int main（）{
高级myData，myData2；
myData.x=10；
myData.y=20；
myData.lag.a=1；
myData.lag.b=2；
myData.lag.c=3；
std：：ofs流（“steps.txt”）；
{
boost:：archive:：text\u oarchive one（ofs）；
一个>myData2；
}
std:：coutOr仅通过删除大括号将它们转换为声明。@SebastianRedl拥有这些声明没有任何意义：）不在示例中，但它们可能在原始代码中是必需的。或者它们可能是一种样式首选项；我见过文件以其定义的类（例如MFC）的声明开头的代码基.Thank@SebastianRedlI对序列化一无所知。为什么在实际的类定义之前有类基{}；类上级{}；？要扩展sajas的注释，
class-baseds；
是类转发声明，
class-baseds{}
是一个定义。从技术上讲，你是在重新定义
基础
和
高级
。
#include <iostream>
#include <fstream>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>

class baseds;
class superior;

class baseds {
private:
    friend class boost::serialization::access;
public:
    int a;
    int b;
    int c;
    baseds(){}
    ~baseds(){}
    template <class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & a;
        ar & b;
        ar & c;
    }
};

class superior  {
private:
    friend class boost::serialization::access;
    friend class baseds;
public:
    int x;
    int y;
    baseds lag;
    superior(){}
    ~superior(){}
    template <class Archive>
    void serialize(Archive & ar, const unsigned int version)
    {
        ar & x;
        ar & y;
        ar & lag;
    }
};

int main()  {

    superior myData,myData2;
    myData.x=10;
    myData.y=20;
    myData.lag.a=1;
    myData.lag.b=2;
    myData.lag.c=3;

    std::ofstream ofs("steps.txt");
    {
        boost::archive::text_oarchive one(ofs);
        one << myData;
    }

    std::ifstream ifs("steps.txt");
    {
        boost::archive::text_iarchive two(ifs);
        two >> myData2;
    }
    std::cout<<"\n"<<myData2.x;
    std::cout<<"\n"<<myData2.y;
    std::cout<<"\n"<<myData2.lag.a;
    std::cout<<"\n"<<myData2.lag.b;
    std::cout<<"\n"<<myData2.lag.c;

    return 0;

}