Good to see that template and nested classes works perfectly with ARM compiler. virtual & friend keywords have already been tested.

Here is my sample CQueue class
Quote:
#include "AEEStdLib.h"

class testclass
{
public:
testclass() {}
~testclass(){
__DBGPRINTF("~testclass()");
}

// Overloaded new & delete operators
void* operator new(size_t sz){return MALLOC(sz);}
void operator delete(void *p){FREEIF(p);}
;

template
class CQueue
{
private:

class _queue_item
{
public:

_queue_item():next(NULL){}
_queue_item(T *val):value(val),next(NULL){}

~_queue_item() {};

T* value;
_queue_item* next;

// Overloaded new & delete operators
void* operator new(size_t sz){return MALLOC(sz);}
void operator delete(void *p){FREEIF(p);}
};

private:
_queue_item *first; // head pointer
_queue_item *last; // tail pointer

int m_NoOfelement;

boolean m_bQueueAccess;

// private
void Flush();

public:
CQueue():first(NULL),last(NULL),m_bQueueAccess(TRUE),m_NoOfelement(0){}
virtual ~CQueue(){Flush();}

// Overloaded new & delete operators
void* operator new(size_t sz){return MALLOC(sz);}
void operator delete(void *p){FREEIF(p);}

// Member functions
boolean Push(T* item);
T* Pop();

boolean IsEmpty();

void EnterCriticalSection();
void LeaveCriticalSection();

int GetElementCount();
;

template
void CQueue::Flush()
{
__DBGPRINTF("Flush()");
T* pItem;
pItem = this->Pop();

while (pItem)
{
/*
delete pItem; ? deleting pItem* will launch T destructor.
*/
pItem = this->Pop();
}

template
boolean CQueue::Push(T* item)
{
if(this->m_bQueueAccess == FALSE)
{
return FALSE;
}
if(m_NoOfelement>=100)
{
/*
delete pItem; ? deleting pItem* will launch T destructor.
*/
return FALSE;
}

_queue_item *next= new _queue_item (item);

if (first==NULL)
{
last=first=next;
}
else
{
last->next=next;
last=next;
}

this->m_NoOfelement=this->m_NoOfelement + 1;

return TRUE;

template
T* CQueue::Pop()
{
if(this->m_bQueueAccess == FALSE) return NULL;
if(first==NULL) return NULL;

_queue_item* oldFirst=first;

T* val = NULL;
val=first->value;
first=first->next;

delete oldFirst;

this->m_NoOfelement--;

return val;

template
boolean CQueue::IsEmpty()
{
if (first==NULL) return TRUE; else return FALSE;

template
void CQueue::EnterCriticalSection()
{
this->m_bQueueAccess=FALSE;

template
void CQueue::LeaveCriticalSection()
{
this->m_bQueueAccess=TRUE;

template
int CQueue::GetElementCount()
{
return m_NoOfelement;

- Be remember that all the template code should reside in a single h file.
- Put following segment in case EVT_KEY: etc. to test the sample
Quote:
CQueue* q=NULL;
q = new CQueue();

testclass* tc=new testclass();
q->Push(tc);

// tc = (testclass*)q->Pop();
// delete tc;

delete q;

return 0;

thanks

wizz