2013-06-07 15 views
5

EclipseC++ hatası: sınıfı hiçbir üye seçti

bu işlevi derlerken

MemoryBundleStorage.cpp: In member function 'virtual void dtn::storage::MemoryBundleStorage::store(const dtn::data::Bundle&)': 
MemoryBundleStorage.cpp:146:67: error: 'const class dtn::data::Bundle' has no member named 'getClass' 
MemoryBundleStorage.cpp:150:19: error: 'const class dtn::data::Bundle' has no member named 'getClass' 

void MemoryBundleStorage::store(const dtn::data::Bundle &bundle) 
     { 
      std::cout << "MemoryBundleStorage store" << std::endl; 
      ibrcommon::MutexLock l(_bundleslock); 
      std::cout << "Storing bundle(Memory). His class is " << bundle.getClass() << std::endl; //<<Here ERROR 
} 

Kısmi Bundle.h dosyası bu konuyu var

namespace dtn 
{ 
    namespace security 
    { 
     class StrictSerializer; 
     class MutualSerializer; 
    } 

    namespace data 
    { 
     class CustodySignalBlock; 
     class StatusReportBlock; 

     class Bundle : public PrimaryBlock 
     { 
      friend class DefaultSerializer; 
      friend class DefaultDeserializer; 
      friend class dtn::security::StrictSerializer; 
      friend class dtn::security::MutualSerializer; 

     public: 

      int getClass() const; 

... 
} 

Ve getClass() yönteminin uygulanması aşağıdaki (Bundle.cpp)

'dur.
namespace dtn 
{ 
    namespace data 
    { 
     Bundle::Bundle() 
     { 
      // if the timestamp is not set, add a ageblock 
      if (_timestamp == 0) 
      { 
       // add a new ageblock 
       push_front<dtn::data::AgeBlock>(); 
      } 
     } 

     int Bundle::getClass() const{ 
       whatever 
       } 

} 

Neyi yanlış yapıyorum? Belki çağrı iyi yapılmadı mı?

Teşekkürler!

Edit1: komple bundle.h

#ifndef BUNDLE_H_ 
#define BUNDLE_H_ 

#include "ibrdtn/data/Dictionary.h" 
#include "ibrdtn/data/PrimaryBlock.h" 
#include "ibrdtn/data/Block.h" 
#include "ibrdtn/data/PayloadBlock.h" 
#include "ibrdtn/data/EID.h" 
#include "ibrdtn/data/ExtensionBlock.h" 
#include "ibrcommon/refcnt_ptr.h" 
#include <ostream> 
#ifdef __DEVELOPMENT_ASSERTIONS__ 
#include <cassert> 
#endif 
#include <set> 
#include <map> 
#include <typeinfo> 

namespace dtn 
{ 
    namespace security 
    { 
     class StrictSerializer; 
     class MutualSerializer; 
    } 

    namespace data 
    { 
     class CustodySignalBlock; 
     class StatusReportBlock; 

     class Bundle : public PrimaryBlock 
     { 
      friend class DefaultSerializer; 
      friend class DefaultDeserializer; 
      friend class dtn::security::StrictSerializer; 
      friend class dtn::security::MutualSerializer; 

     public: 

      int getClass() const; 

      class NoSuchBlockFoundException : public ibrcommon::Exception 
      { 
       public: 
        NoSuchBlockFoundException() : ibrcommon::Exception("No block found with this Block ID.") 
        { 
        }; 
      }; 

         enum BUNDLE_CLASS 
         { 

         }; 


      class BlockList 
      { 
       friend class DefaultSerializer; 
       friend class DefaultDeserializer; 
       friend class dtn::security::StrictSerializer; 
       friend class dtn::security::MutualSerializer; 

      public: 
       BlockList(); 
       virtual ~BlockList(); 

       BlockList& operator=(const BlockList &ref); 

       void push_front(Block *block); 
       void push_back(Block *block); 
       void insert(Block *block, const Block *before); 
       void remove(const Block *block); 
       void clear(); 

       const std::set<dtn::data::EID> getEIDs() const; 

       Block& get(int index); 
       const Block& get(int index) const; 
       template<class T> T& get(); 
       template<class T> const T& get() const; 

       template<class T> 
       const std::list<const T*> getList() const; 

       const std::list<const Block*> getList() const; 

       size_t size() const; 

      private: 
       std::list<refcnt_ptr<Block> > _blocks; 
      }; 

      Bundle(); 
      virtual ~Bundle(); 

      bool operator==(const Bundle& other) const; 
      bool operator!=(const Bundle& other) const; 
      bool operator<(const Bundle& other) const; 
      bool operator>(const Bundle& other) const; 

      const std::list<const dtn::data::Block*> getBlocks() const; 

      dtn::data::Block& getBlock(int index); 
      const dtn::data::Block& getBlock(int index) const; 

      template<class T> 
      T& getBlock(); 

      template<class T> 
      const T& getBlock() const; 

      template<class T> 
      const std::list<const T*> getBlocks() const; 

      template<class T> 
      T& push_front(); 

      template<class T> 
      T& push_back(); 

      template<class T> 
      T& insert(const dtn::data::Block &before); 

      dtn::data::PayloadBlock& push_front(ibrcommon::BLOB::Reference &ref); 
      dtn::data::PayloadBlock& push_back(ibrcommon::BLOB::Reference &ref); 
      dtn::data::PayloadBlock& insert(const dtn::data::Block &before, ibrcommon::BLOB::Reference &ref); 

      dtn::data::Block& push_front(dtn::data::ExtensionBlock::Factory &factory); 
      dtn::data::Block& push_back(dtn::data::ExtensionBlock::Factory &factory); 
      dtn::data::Block& insert(dtn::data::ExtensionBlock::Factory &factory, const dtn::data::Block &before); 

      void remove(const dtn::data::Block &block); 
      void clearBlocks(); 

      string toString() const; 

      size_t blockCount() const; 

     private: 
      BlockList _blocks; 
     }; 

     template<class T> 
     const std::list<const T*> Bundle::getBlocks() const 
     { 
      return _blocks.getList<T>(); 
     } 

     template<class T> 
     T& Bundle::getBlock() 
     { 
      return _blocks.get<T>(); 
     } 

     template<class T> 
     const T& Bundle::getBlock() const 
     { 
      return _blocks.get<T>(); 
     } 

     template<> 
     CustodySignalBlock& Bundle::BlockList::get<CustodySignalBlock>(); 

     template<> 
     const CustodySignalBlock& Bundle::BlockList::get<const CustodySignalBlock>() const; 

     template<> 
     StatusReportBlock& Bundle::BlockList::get<StatusReportBlock>(); 

     template<> 
     const StatusReportBlock& Bundle::BlockList::get<const StatusReportBlock>() const; 

     template<class T> 
     const T& Bundle::BlockList::get() const 
     { 
      try { 
       // copy all blocks to the list 
       for (std::list<refcnt_ptr<Block> >::const_iterator iter = _blocks.begin(); iter != _blocks.end(); iter++) 
       { 
        if ((*iter)->getType() == T::BLOCK_TYPE) 
        { 
         const Block *b = (*iter).getPointer(); 
         return dynamic_cast<const T&>(*b); 
        } 
       } 
      } catch (const std::bad_cast&) { 

      } 

      throw NoSuchBlockFoundException(); 
     } 

     template<class T> 
     T& Bundle::BlockList::get() 
     { 
      try { 
       // copy all blocks to the list 
       for (std::list<refcnt_ptr<Block> >::iterator iter = _blocks.begin(); iter != _blocks.end(); iter++) 
       { 
        if ((*iter)->getType() == T::BLOCK_TYPE) 
        { 
         Block *b = (*iter).getPointer(); 
         return dynamic_cast<T&>(*b); 
        } 
       } 
      } catch (const std::bad_cast&) { 

      } 

      throw NoSuchBlockFoundException(); 
     } 

     template<class T> 
     const std::list<const T*> Bundle::BlockList::getList() const 
     { 
      // create a list of blocks 
      std::list<const T*> ret; 

      // copy all blocks to the list 
      for (std::list<refcnt_ptr<Block> >::const_iterator iter = _blocks.begin(); iter != _blocks.end(); iter++) 
      { 
       if ((*(*iter)).getType() == T::BLOCK_TYPE) 
       { 
        const T* obj = dynamic_cast<const T*>((*iter).getPointer()); 

        if (obj != NULL) 
        { 
         ret.push_back(obj); 
        } 
       } 
      } 

      return ret; 
     } 

     template<class T> 
     T& Bundle::push_front() 
     { 
      T *tmpblock = new T(); 
      dtn::data::Block *block = dynamic_cast<dtn::data::Block*>(tmpblock); 

#ifdef __DEVELOPMENT_ASSERTIONS__ 
      assert(block != NULL); 
#endif 

      _blocks.push_front(block); 
      return (*tmpblock); 
     } 

     template<class T> 
     T& Bundle::push_back() 
     { 
      T *tmpblock = new T(); 
      dtn::data::Block *block = dynamic_cast<dtn::data::Block*>(tmpblock); 

#ifdef __DEVELOPMENT_ASSERTIONS__ 
      assert(block != NULL); 
#endif 

      _blocks.push_back(block); 
      return (*tmpblock); 
     } 

     template<class T> 
     T& Bundle::insert(const dtn::data::Block &before) 
     { 
      T *tmpblock = new T(); 
      dtn::data::Block *block = dynamic_cast<dtn::data::Block*>(tmpblock); 

#ifdef __DEVELOPMENT_ASSERTIONS__ 
      assert(block != NULL); 
#endif 

      _blocks.insert(block, &before); 
      return (*tmpblock); 
     } 
    } 
} 

#endif /* BUNDLE_H_ */ 
+0

Daha fazla kod alabilir miyiz? Bundle.h dosyanız tamamlanmadı – nouney

+0

Muhtemelen sınıf paketi yerine 'ileriye dönük bir Bundle paketine sahip olmalısınız. –

+0

@PeterWood Wood, biraz daha açıklayabilir misiniz lütfen? – ndarkness

cevap

1

mu MemoryBundleStorage.cppBundle.h içerir? Üye işlevlerini çağırmak istiyorsanız ileri bildirim yeterli değildir.

+0

Evet öyle, iyi olan MemoryBundleStorage.h olan, # include #include ' – ndarkness

0

Böyle bir durumda, yapılacak ilk şey ön işlemcinin çıktısını almak için derleme yapmaktır. Ardından, bu dosyaya sorunla bakın ve onu özgün kaynağa kadar izleyin. Yaygın nedenler makroları içerir veya diğer dizinden alınan dosyaları içerir.