自学教程：C++ GetHead函数代码示例

//moves onto the next value in the current node's list. Returns NULL if no moreCLTANode* CLTANodeIterator::NextValueShallow(){	ASSERT(m_nStackPos > 0);	for(	uint32 nCurrElem = GetElementIndex(); 			nCurrElem < GetHead()->GetNumElements(); 			nCurrElem++)	{		if(GetHead()->GetElement(nCurrElem)->IsAtom())		{			//found it			//save this new offset			SetElementIndex(nCurrElem + 1);			//return the element			return GetHead()->GetElement(nCurrElem);		}	}	//didn't find it	//set the offset to the end	SetElementIndex(GetHead()->GetNumElements());	//indicate failure	return NULL;}

int UnSelectAllObjects(piObject *w){	piObject *o;	struct List *l;	ULONG sel,s=0;	piGetAttr(w,WNOBJ_GadgetList,(ULONG *)&l);	for(o=(piObject *)GetHead(l);GetSucc(o);o=(piObject *)GetSucc(o))	{		piGetAttr(o,OBJ_Select,(ULONG *)&sel);		if(sel)		{			s=1;			piSetAttrs(o,OBJ_Select,FALSE,TAG_DONE);			piRenderObject(o);		}	}	piGetAttr(w,WNOBJ_FrameList,(ULONG *)&l);	for(o=(piObject *)GetHead(l);GetSucc(o);o=(piObject *)GetSucc(o))	{		piGetAttr(o,OBJ_Select,(ULONG *)&sel);		if(sel)		{			s=1;			piSetAttrs(o,OBJ_Select,FALSE,TAG_DONE);			piRenderObject(o);		}	}	return (int)s;}

//moves onto the next list in the current node's list. Returns NULL if no moreCLTANode* CLTANodeIterator::NextListShallow(){	for(	uint32 nCurrElem = GetElementIndex(); 			nCurrElem < GetHead()->GetNumElements(); 			nCurrElem++)	{		if(GetHead()->GetElement(nCurrElem)->IsList())		{			//found it			//save this new offset			SetElementIndex(nCurrElem + 1);			//return the element			return GetHead()->GetElement(nCurrElem);		}	}	//didn't find it	//set the offset to the end	m_nElemStack[m_nStackPos] = GetHead()->GetNumElements();	//indicate failure	return NULL;}

int main(){	int i;	QElemType d;	LinkQueue q;	i=InitQueue(&q);	if(i)		printf("成功地构造了一个空队列!/n");	printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));	printf("队列的长度为%d/n",QueueLength(q));	EnQueue(&q,-5);	EnQueue(&q,5);	EnQueue(&q,10);	printf("插入3个元素(-5,5,10)后,队列的长度为%d/n",QueueLength(q));	printf("是否空队列？%d(1:空 0:否)  ",QueueEmpty(q));	printf("队列的元素依次为：");	QueueTraverse(q);	i=GetHead(q,&d);	if(i==OK)	 printf("队头元素是：%d/n",d);	DeQueue(&q,&d);	printf("删除了队头元素%d/n",d);	i=GetHead(q,&d);	if(i==OK)		printf("新的队头元素是：%d/n",d);	ClearQueue(&q);	printf("清空队列后,q.front=%u q.rear=%u q.front->next=%u/n",q.front,q.rear,q.front->next);	DestroyQueue(&q);	printf("销毁队列后,q.front=%u q.rear=%u/n",q.front, q.rear);		return 0;}

/** * 算法2.21 */Status MergeList(LinkList &La, LinkList &Lb, LinkList &Lc, 				int (*compare)(ElemType, ElemType)){	Link ha, hb, pa, pb, q;	ElemType a, b;	if (!InitList(Lc))		return ERROR;	ha = GetHead(La);	hb = GetHead(Lb);	pa = NextPos(La, ha);	pb = NextPos(Lb, hb);	while (pa && pb) {		a = GetCurElem(pa);		b = GetCurElem(pb);		if (compare(a, b) <= 0) {   // a<=b			DelFirst(ha, q);			Append(Lc, q);			pa = NextPos(La, ha);		} else {    // a>b			DelFirst(hb, q);			Append(Lc, q);			pb = NextPos(Lb, hb);		}   	} // while	if (pa)		Append(Lc, pa);	else		Append(Lc, pb);	FreeNode(ha);	FreeNode(hb);	return OK;}

		vptr FreeListAllocator::Allocate(usize Size, uint8 Alignment) const		{			vptr pointer = nullptr;			Size += (((uptr)m_Next) + Size) % Alignment;			FreeChunk *header = FindFreeChunk(Size);			if(header == nullptr)			{				header = AllocateHeader();				pointer = m_Next;				m_LastHeader = header;				m_Next = (vptr)((uptr)m_Next + Size);				if((uptr)m_Next > m_Tail || (uptr)m_Next < (uptr)GetHead())				{					DAMN_ERROR("Free list allocator ran out of memory./n"						   "It asked for %u bytes more than the %u bytes that were "						   "previously allocated.",						   (uint32)((uptr)m_Next - m_Tail),						   (uint32)(m_Tail - (uptr)GetHead()));				}			}			else			{				pointer = (vptr)((uptr)header + s_FreeChunkSize);			}			header->m_Size = (uint32)Size;			header->m_Used = true;			m_AllocCount += 1;			m_Used += header->m_Size;			return pointer;		}

		FreeChunk *FreeListAllocator::FindFreeChunk(usize Size) const		{			FreeChunk *node = (FreeChunk*)GetHead();			int32 count = 0;			FreeChunk *last;			while(node != nullptr && node->m_Size != Size && m_LastHeader != node)			{				node = (FreeChunk*)((uptr)node + s_FreeChunkSize + (node->m_Size));				if(count >= m_AllocCount)				{					return nullptr;				}				if((uptr)node > m_Tail || (uptr)node < (uptr)GetHead())				{					DAMN_ERROR("Free list allocator ran out of memory./n"						   "It asked for %u bytes more than the %u bytes that were "						   "previously allocated.",						   (uint32)((uptr)node - m_Tail),						   (uint32)(m_Tail - (uptr)GetHead()));				}				if(node->m_Size == Size && !node->m_Used)				{					break;				}				last = node;				++count;			}			if(node == nullptr || node->m_Used) return nullptr;			return node;		}

void test_GetHead(void) {	GENERALIZED_LIST_TYPE list = NULL;	CU_ASSERT_EQUAL(GetHead(list), NULL);	list = getGeneralizedList("(1,2)");	assertEqual(GetHead(list), "(1)");	list = getGeneralizedList("((11,12,13),(21,22,23,24,25),3)");	assertEqual(GetHead(list), "(11,12,13)");}

//----------------------------------------------------------------------------------------------------------------void CClient::PreThink(){    int iLastWaypoint = iCurrentWaypoint;    CPlayer::PreThink();    // Client don't have access to waypoint modification.    if ( FLAG_CLEARED(FCommandAccessWaypoint, iCommandAccessFlags) )        return;    // Check if lost waypoint, in that case add new one.    if ( bAutoCreateWaypoints && m_bAlive &&         ( !CWaypoint::IsValid(iCurrentWaypoint) ||           (GetHead().DistToSqr(CWaypoints::Get(iCurrentWaypoint).vOrigin) >= SQR(CWaypoint::iDefaultDistance)) ) )    {        Vector vOrigin( GetHead() );        // Add new waypoint, but distance from previous one must not be bigger than iDefaultDistance.        if ( CWaypoint::IsValid(iLastWaypoint) )        {            CWaypoint& wLast = CWaypoints::Get(iLastWaypoint);            vOrigin -= wLast.vOrigin;            vOrigin.NormalizeInPlace();            vOrigin *= CWaypoint::iDefaultDistance;            vOrigin += wLast.vOrigin;        }        // Add new waypoint.        iCurrentWaypoint = CWaypoints::Add(vOrigin);        // Add paths from previous to current.        if ( CWaypoint::IsValid(iLastWaypoint) )        {            float fHeight = GetPlayerInfo()->GetPlayerMaxs().z - GetPlayerInfo()->GetPlayerMins().z + 1;            bool bIsCrouched = (fHeight < CMod::iPlayerHeight);            CWaypoints::CreatePathsWithAutoFlags(iLastWaypoint, iCurrentWaypoint, bIsCrouched);            iDestinationWaypoint = iLastWaypoint;        }    }    // Calculate destination waypoint according to angles. Path's should be drawn.    if ( !bLockDestinationWaypoint && (iPathDrawFlags != FPathDrawNone) &&         (CWaypoints::fNextDrawWaypointsTime >= CBotrixPlugin::fTime) )    {        QAngle ang;        GetEyeAngles(ang);        iDestinationWaypoint = CWaypoints::GetAimedWaypoint( GetHead(), ang );    }    // Draw waypoints.    CWaypoints::Draw(this); // TODO: should not draw for several admins...    // Draw entities.    CItems::Draw(this);}

/******************************************************************************void IFXKeyTrack::CalcInstantConst(F32 time,IFXInstant *instant,											IFXListContext *context) const	FUTURE perhaps something better than linear interpolation on locations******************************************************************************/void IFXKeyTrack::CalcInstantConst(								   F32 time,								   IFXInstant *instant,								   IFXListContext *context) const{	if(context==NULL)		context=(IFXListContext *)&m_current;	Sync(time,context);	IFXKeyFrame *after=GetCurrent(*context);	IFXKeyFrame *before=PreDecrement(*context);	PreIncrement(*context); // put back	if(!before && !after)	{		if(GetHead())		{			*instant= *GetHead();			return;		}		else			instant->Reset();	}	else if(!before)	{		*instant= *after;		return;	}	else if(!after)	{		*instant= *before;		return;	}	else	{		F32 fraction= (time-before->Time()) /			(after->Time()-before->Time());		instant->Location().Interpolate(fraction,			before->LocationConst(),after->LocationConst());		instant->Rotation().Interpolate(fraction,			before->RotationConst(),after->RotationConst());		instant->Scale().Interpolate(fraction,			before->ScaleConst(),after->ScaleConst());	}}

void    *GDList::rem_del(position rel,int mode){    NIDNode *node = 0;    switch(rel)    {        case GDBase::liststart: node=GetHead();  break;        case GDBase::listend:   node=GetTail();  break;        case GDBase::current:   node=GetCurr();  break;        case GDBase::before:    if((node=GetCurr()) != 0)                                    node = node->GetPrev();                                break;        case GDBase::after:     if((node=GetCurr()) != 0)                                    node = node->GetNext();                                break;    }    if(node)    {        void *obj = node->object;        remove(node);        if(mode && cleanup() == ListBase::active)            zap_object(obj);        return obj;    }    return 0;}

//*****************************************************************************void BBlockRing::RemoveAll() {  BTerrainBlock *pBlock;  while(pBlock = GetHead()) {    Remove(pBlock);    delete pBlock;  }}

LIBFUNC2(APTR, AllocMem, ULONG, size, ULONG, flags, struct ExecBase *,SysBase){	struct	MemHeader *mh;	struct	MemBlock *mb;	ULONG	realsize=size+sizeof(struct MemHeader);	Forbid();		mb=(struct MemBlock *) GetHead(&SysBase->FreeMemList);		if(!mb) return (NULL);	while(mb->mb_Size<realsize) {		mb=(struct MemBlock *) GetNext(mb);		if(!mb) return (NULL);	}		realsize=realsize+(realsize%MEM_BLOCKSIZE);	mb->mb_Size -= realsize;	mh=(struct MemHeader *) (mb+mb->mb_Size);	mh->mh_Node.mln_Prev = NULL;	mh->mh_Node.mln_Next = NULL;	mh->mh_Magic = MEMF_MAGIC;	mh->mh_Size = realsize;	Permit();	return ((APTR) mh);}

void SLList::Insert(int contents) {	if(head_ == NULL) {		InsertHead(contents);	}	else if(contents < GetHead()) {		InsertHead(contents);	}	else if (head_->next_node() == NULL && head_ != NULL) {		InsertTail(contents);	}	else if(contents > GetTail()) {		InsertTail(contents);	}	else {		SLNode* node = new SLNode(contents);		SLNode* i = head_;		SLNode* j = NULL;		while(i->contents() <= contents && i->next_node() != NULL) {			j = i;			i = i->next_node();		}		j->set_next_node(node);		node->set_next_node(i);		size_++;	}}

BOOL PlugInPathList::RemoveHiddenItems(){	// Go through all the paths in the list and remove all those with the hidden	// attribute set.	PlugInPath* pPath = (PlugInPath *)GetHead();	while (pPath)	{		if (pPath->IsHidden())		{			// The item is hidden so remove it			// First, find the next item, if there is one			PlugInPath* pNextPath = (PlugInPath *)GetNext(pPath);			RemoveItem(pPath);			// remove item returns NULL if problem			if (pPath == NULL)				return FALSE;						// remove the old path item from memory			delete pPath;			// move to considering the next item			pPath = pNextPath;		}		else		{			// Try the next pathname in the list			pPath = (PlugInPath *)GetNext(pPath);		}	}	return TRUE;}

void OverrideList::AddHead( OverrideListItem* poliToAdd){	if (poliToAdd==NULL)	{		ERROR2RAW("OverrideList::AddHead - NULL parameter");		return;	}	//Get the first item in the list	OverrideListItem* pliFirst=(OverrideListItem*) GetHead();	//Was there anything in the list?	if (pliFirst!=NULL)				 	{		//Yes. So call our InsertBefore function		InsertBefore(pliFirst, poliToAdd);	}	else	{		//No. So we need do no special checking - simply insert		//the list item		List::AddHead(poliToAdd);	}	}

/** * /brief remove the end of the list, and return it * /returns shared ptr to what was the end of the list */std::shared_ptr<CSnowflake> CSnowflakeLinkedList::pop(){	auto snowflake = GetHead();	if (snowflake != nullptr)	{		//check if we are already at last node (singly linked list is size 1)		if (snowflake->Next() == nullptr)		{			mStartSnowflake = nullptr;			return snowflake;		}		else		{			//Get to one before the end			while (snowflake->Next()->Next() != nullptr)			{				snowflake = snowflake->Next();			}			auto last = snowflake->Next();			snowflake->SetNext(nullptr);			return last;		}	}	else	{		return nullptr;	}}

int CItemStone::FixWeirdness(){	ADDTOCALLSTACK("CItemStone::FixWeirdness");	// Check all my members. Make sure all wars are reciprocated and members are flaged.	int iResultCode = CItem::FixWeirdness();	if ( iResultCode )	{		return( iResultCode );	}	bool fChanges = false;	CStoneMember * pMember = STATIC_CAST <CStoneMember *>(GetHead());	while ( pMember != NULL )	{		CStoneMember * pMemberNext = pMember->GetNext();		if ( ! CheckValidMember(pMember))		{			IT_TYPE oldtype = GetType();			SetAmount(0);	// turn off validation for now. we don't want to delete other members.			delete pMember;			SetAmount(1);	// turn off validation for now. we don't want to delete other members.			SetType( oldtype );			fChanges = true;		}		pMember = pMemberNext;	}	if ( fChanges )	{		ElectMaster();	// May have changed the vote count.	}	return( 0 );}

void GSRasterizerList::PrintStats(){	if(!IsEmpty())	{		GetHead()->PrintStats();	}}

void eFBCTunerManager::Unlink(eDVBRegisteredFrontend *fe) const{	eDVBRegisteredFrontend *simul_fe;	bool simulate;	simulate = fe->m_frontend->is_simulate();	if (IsRootFE(fe) || IsFEUsed(fe, simulate) || IsSCR(fe) || !IsLinked(fe))		return;	//PrintLinks(fe);	DisconnectLink(fe, FrontendGetLinkPtr(fe, link_prev), FrontendGetLinkPtr(fe, link_next), simulate);	fe->m_frontend->setEnabled(false);	if(!simulate) // also act on the simulation frontends	{		if((simul_fe = GetSimulFE(fe)) && !IsRootFE(simul_fe) && !IsFEUsed(simul_fe, true) &&				!IsSCR(simul_fe) && IsLinked(simul_fe))		{			DisconnectLink(simul_fe, FrontendGetLinkPtr(simul_fe, link_prev), FrontendGetLinkPtr(simul_fe, link_next), true);			simul_fe->m_frontend->setEnabled(false);		}	}	//PrintLinks(fe);	//setDefaultFBCID(link_fe);	UpdateLNBSlotMask(FESlotID(fe), FESlotID(GetHead(fe)), /*remove*/true);}

void CDVDPositionList::SaveLatestEntry(){    CString  strValue;    strValue = SerializeHex((BYTE*)&GetHead(), sizeof(DVD_POSITION));    m_pApp->WriteProfileString(m_lpszSection, _T("DVD Position 0"), strValue);}

int main(){	LinkQueue Q;	if(InitQueue(&Q))	{		QElemType e;		printf("initialize successful");		if(IsEmpty(Q))		{			printf("queue is IsEmpty/n");		}		for (int i=0;i<10;i++)		{			EnQueue(&Q,i);		}		GetHead(Q,&e);		printf("The head element is %d/n",e );		printf("The length of the queue is %d/n",GetLength(Q));		DeQueue(&Q,&e);		printf("delete element is %d/n",e);		TraverseQueue(Q,*visit);		if (DestroyQueue(&Q))		{			printf("DestroyQueue successful/n");		}	}	return 0;}

void GDList::sort(int (*sort_func)(void *p1,void *p2)){    int     num = count();    while(num)    {        NIDNode *p1 = GetHead();        NIDNode *p2 = p1->GetNext();        for(int k=1;k < num;k++)        {            // If this returns true, p1 is sorted toward the end            if(sort_func(p1->GetObject(),p2->GetObject()))            {                GDBase::swap(p1,p2);                p2 = p1->GetNext();            }            else            {                p1 = p2;                p2 = p2->GetNext();            }        }        num--;    }}

////// DumpDbgMalloc// output all current allocationsvoid DumpDbgMalloc(void){  ENTER();  if(isFlagSet(debug_classes, DBC_MTRACK))  {    ULONG i;    ObtainSemaphore(&DbgMallocListSema);    D(DBF_ALWAYS, "%ld memory areas tracked", DbgMallocCount);    for(i = 0; i < ARRAY_SIZE(DbgMallocList); i++)    {      struct Node *curNode;      for(curNode = GetHead((struct List *)&DbgMallocList[i]); curNode != NULL; curNode = GetSucc(curNode))      {        struct DbgMallocNode *dmn = (struct DbgMallocNode *)curNode;        _DPRINTF(DBC_MTRACK, DBF_ALWAYS, dmn->file, dmn->line, "memarea 0x%08lx, size/type %ld, func (%s)", dmn->memory, dmn->size, dmn->func);      }    }    ReleaseSemaphore(&DbgMallocListSema);  }  LEAVE();}

void main(){    LinkQueue *lq;    ElemType e;    InitQueue(lq);    printf("队%s/n", (QueueEmpty(lq) == 1 ? "空" : "不空"));    printf("a进队/n");    EnQueue(lq, 'a');    printf("b进队/n");    EnQueue(lq, 'b');    printf("c进队/n");    EnQueue(lq, 'c');    printf("d进队/n");    EnQueue(lq, 'd');    printf("队%s/n", (QueueEmpty(lq) == 1 ? "空" : "不空"));    GetHead(lq, e);    printf("队头元素:%c/n", e);    printf("出队次序:");    while (!QueueEmpty(lq)) {        DeQueue(lq, e);        printf("%c ", e);    }    printf("/n");}

int CParseString::ParseRev2(CString& item1, CString& item2, CString separ){    InitRev(separ);    GetPrevWord(item2);    GetHead(item1);    return (!item1.IsEmpty()) + (!item2.IsEmpty());}

void Bank_simulation(int CloseTime){	//银行业务模拟，统计一天内客户在银行的逗留时间	//全局变量	static Event en;//事件表	static EvenList ev;//事件	static LinkQueue q[5];//4个客户列队	static QElemType customer;//客户记录	static int TotalTime,CustomerNum;//累计逗留时间，客户数	//变量结束	EvenList p,e;	OpenForDay(TotalTime,CustomerNum,en,ev,q);	while(!ListEmpty(ev)){		e=GetHead(ev);		DelFirst(e,p);				en=GetCurElem(p);		if(en.NType==0)			CustomerArrived(CloseTime,CustomerNum,en,ev,q);		else CustomerDeparture(en,ev,q,customer,TotalTime);		if(TotalTime>CloseTime)break;	}	printf("%0.2f/n",(float)TotalTime/CustomerNum);}

bool TrGainDB::Save(const char* filename) {  Init();  TFile* rootfile = TFile::Open(filename,"recreate");  if (rootfile==0) return false;  rootfile->WriteTObject(GetHead());  return true;}