C++Primer 类的使用解决思路

C++Primer 类的使用
写了个小程序，有两个类，互相都会调用，Message和Floder
程序如下：

11 class Floder;
 12 class Message;  
 13 
 14 class Message {
 15 private:
 16 string contents;
 17 set<Floder*> floders; 
 18 void put_floder(set<Floder*> &);
 19 void remove_floder(set<Floder *> &);
 20 public:
 21 Message(const string &k):contents(k) {}
 22 Message(const Message &);
 23 Message& operator=(const Message&);
 24 ~Message();
 25 void save(Floder&);
 26 void remove(Floder&);
 27 };


30 void Message::put_floder(set<Floder*> &floder)
 31 {
 32 set<Floder*>::iterator beg;
 33 for(beg = floder.begin(); beg != floder.end(); beg++)  
 34 (*beg)->messages.insert(this);
 35 }
 36 void Message::remove_floder(set<Floder *> &floder)
 37 {
 38 set<Floder*>::iterator beg;
 39 for(beg = floder.begin(); beg != floder.end(); beg++){
 40 (*beg)->messages.erase(this);  
 41 }
 42 }
 43 Message::Message(const Message &src):
 44 contents(src.contents),floders(src.floders)
 45 {
 46 put_floder(floders);
 47 }
 48 
 49 void Message::save(Floder &src)
 50 {
 51 floders.insert(&src);  
 52 src.messages.insert(this);
 53 }
 54 
 55 Message::~Message()
 56 {
 57 remove_floder(floders);
 58 }
 59 
 60 void Message::remove(Floder &src)
 61 {
 62 set<Floder*>::iterator f = floders.find(&src);
 63 if(f != floders.end()){
 64 src.messages.erase(this);
 65 floders.erase(*f);
 66 }
 67 }
 68 
 69 Message& Message::operator=(const Message &src)
 70 {
 71 if(this != &src){
 72 remove_floder(floders);
 73 contents = src.contents;
 74 floders = src.floders;
 75 put_floder(floders);
 76 }
 77 return *this;
 78 }
 79 
80 class Floder {
81 public:
82 set<Message*> messages;
83 };

结果有报错
Message.cpp:34: error: invalid use of incomplete type ‘struct Floder’
Message.cpp:11: error: forward declaration of ‘struct Floder’

貌似我的类定义有问题，求解答.....



------解决方案--------------------
估计是你引用的太多了，或者定义引起了冲突导致了无法识别了。我把你的顺序改变了下就OK啦。

C/C++ code

 class Message; 
 class Floder {
 public: 
     set<Message*> messages;
 };



 class Message {
 private:
     string contents;
     set<Floder*> floders;  
     void put_floder(set<Floder*> &);
 void remove_floder(set<Floder *> &);
     public:
    Message(const string &k):contents(k) {}
     Message(const Message &);
     Message& operator=(const Message&);
     ~Message();
     void save(Floder&);
     void remove(Floder&);
     };


     void Message::put_floder(set<Floder*> &floder)
         {
             set<Floder*>::iterator beg;
             for(beg = floder.begin(); beg != floder.end(); beg++)   
                 (*beg)->messages.insert(this);
             }
     void Message::remove_floder(set<Floder *> &floder)
         {
             set<Floder*>::iterator beg;
             for(beg = floder.begin(); beg != floder.end(); beg++){
                 (*beg)->messages.erase(this);   
                 }
             }
     Message::Message(const Message &src):
     contents(src.contents),floders(src.floders)
         {
             put_floder(floders);
             }
      
         void Message::save(Floder &src)
        {
             floders.insert(&src);   
             src.messages.insert(this);
             }
      
         Message::~Message()
         {
             remove_floder(floders);
             }
      
         void Message::remove(Floder &src)
         {
             set<Floder*>::iterator f = floders.find(&src);
             if(f != floders.end()){
                 src.messages.erase(this);
                 floders.erase(*f);
            }
         }
      
        Message& Message::operator=(const Message &src)
        {
             if(this != &src){
                 remove_floder(floders);
                 contents = src.contents;
                 floders = src.floders;
                put_floder(floders);
                 }
             return *this;
             }