Witam,
próbuję odpalić program, który omawia na swojej stronie Xion.
Przepisując kod co jakiś czas odpalam "Build and run" (codeblocks) żeby sprawdzić czy wszystko idzie dobrze.
Niestety w pewnym momencie kompilator wyrzucił mi następujący błąd:
||=== Build: Debug in Cleaner (compiler: GNU GCC Compiler) ===|
/home/michalzrb/workspace/Cleaner/main.cpp|34|error: need ‘typename’ before ‘Ptr<T>::Blocks:: iterator’ because ‘Ptr<T>::Blocks’ is a dependent scope|
/home/michalzrb/workspace/Cleaner/main.cpp|34|error: expected ‘;’ before ‘it’|
/home/michalzrb/workspace/Cleaner/main.cpp|37|error: ‘it’ was not declared in this scope|
/home/michalzrb/workspace/Cleaner/main.cpp|80|error: need ‘typename’ before ‘Ptr<T>::Blocks’ because ‘Ptr<T>’ is a dependent scope|
||=== Build failed: 4 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|
poniżej dotychczasowy kod programu:
#include <iostream>
#include <map>
template <typename T> struct BlockInfo ///dane o pojedynczym bloku pamięci
{
const T* Ptr;
int RefCount;
explicit BlockInfo(T* ptr) : Ptr(ptr), RefCount(1) { }
};
template <typename T> class Ptr
{
private:
T* m_Ptr; ///adres docelowego miejsca w pamięci
///typ kolekcji o zaalokowanych blokach
typedef std::map<T*, BlockInfo<T>*> Blocks;
///rzeczona kolekcja
static Blocks ms_Blocks;
///info o bloku pamięci na który aktualnie pokazuje wskaźnik
BlockInfo<T>* m_pInfo;
/// tworzy lub zwraca istnejącą strukturę BlockInfo na podstawie wskaźnika
static BlockInfo<T>* GetBlockInfo(T* p)
{
//szukamy struktury w kolekcji
BlockInfo<T>* pBI;
Blocks::iterator it = ms_Blocks.find(p);
//jeżeli nie znaleziono, tworzymy nową i dodajemy do kolekcji
if(it == ms_Blocks.end())
ms_Blocks.insert(std::make_pair(p, pBI = new BlockInfo<T>(p)));
else
{
//w przeciwnym razie zwiększamy licznik znalezionego bloku
pBI = it->second;
++pBI->RefCount;
}
return pBI;
}
public:
///konstruktor i destruktor
Ptr(T* = 0);
Ptr(const Ptr&);
~Ptr();
//operatory przypisania
T* operator = (T*);
Ptr& operator = (const Ptr&);
//operatory logiczne
operator bool () const {return m_Ptr != 0;}
bool operator ! () const {return !m_Ptr;}
//operatory wskaźnikowe
T& operator * () {return *m_Ptr;}
const T& operator * () const {return *m_Ptr;}
T* operator -> () {return m_Ptr;}
//operatory konwersji na wskaźnik natywny
operator T* () {return m_Ptr;}
operator const T* () const {return m_Ptr;}
///zwraca akt. wartość licznika referencji
int GetInfoCount() const {return m_pInfo ? m_pInfo->RefCount : 0;}
///pobranie licznika referencji
int GetRefCount() const;
};
template <typename T> Ptr<T>::Blocks Ptr<T>::ms_Blocks;
using namespace std;
int main()
{
return 0;
}
proszę o jakieś naprowadzenie na rozwiązanie