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

void CTrieHolder::InitFailureFunction(){    assert (!m_Nodes.empty());    yvector<size_t> BFS;    BFS.push_back(0);    //  going breadth-first search    for (size_t i=0; i < BFS.size(); i++) {        const CTrieNode& Parent = m_Nodes[BFS[i]];        size_t ChildrenCount =  GetChildrenCount(BFS[i]);        for (size_t j=0; j<ChildrenCount; j++) {            const CTrieRelation& p = GetChildren(BFS[i])[j];            //  going upside using following failure function in order to find the first node which            //  has a way downward with symbol RelationChar            int r =  Parent.m_FailureFunction;            while ((r != -1) &&  (FindChild(r,p.m_RelationChar) == -1))                r = m_Nodes[r].m_FailureFunction;            if (r != -1) {                //  the way is found                m_Nodes[p.m_ChildNo].m_FailureFunction = FindChild(r,p.m_RelationChar);            } else                // no way is found, should start from the beginning                m_Nodes[p.m_ChildNo].m_FailureFunction = 0;            BFS.push_back(p.m_ChildNo);        };    };};

/*----------------------------------------------------------------------|   AP4_TrakAtom::GetChunkOffsets+---------------------------------------------------------------------*/AP4_ResultAP4_TrakAtom::GetChunkOffsets(AP4_Array<AP4_UI64>& chunk_offsets){    AP4_Atom* atom;    if ((atom = FindChild("mdia/minf/stbl/stco"))) {        AP4_StcoAtom* stco = AP4_DYNAMIC_CAST(AP4_StcoAtom, atom);        if (stco == NULL) return AP4_ERROR_INTERNAL;        AP4_Cardinal    stco_chunk_count   = stco->GetChunkCount();        const AP4_UI32* stco_chunk_offsets = stco->GetChunkOffsets();        chunk_offsets.SetItemCount(stco_chunk_count);        for (unsigned int i=0; i<stco_chunk_count; i++) {            chunk_offsets[i] = stco_chunk_offsets[i];        }        return AP4_SUCCESS;    } else if ((atom = FindChild("mdia/minf/stbl/co64"))) {        AP4_Co64Atom* co64 = AP4_DYNAMIC_CAST(AP4_Co64Atom, atom);        if (co64 == NULL) return AP4_ERROR_INTERNAL;        AP4_Cardinal    co64_chunk_count   = co64->GetChunkCount();        const AP4_UI64* co64_chunk_offsets = co64->GetChunkOffsets();        chunk_offsets.SetItemCount(co64_chunk_count);        for (unsigned int i=0; i<co64_chunk_count; i++) {            chunk_offsets[i] = co64_chunk_offsets[i];        }        return AP4_SUCCESS;    } else {        return AP4_ERROR_INVALID_STATE;    }}

/*----------------------------------------------------------------------|       AP4_EncaSampleEntry::ToSampleDescription+---------------------------------------------------------------------*/AP4_SampleDescription*AP4_EncaSampleEntry::ToSampleDescription(){    // get the original sample format    AP4_FrmaAtom* frma = (AP4_FrmaAtom*)FindChild("sinf/frma");    // get the scheme info    AP4_SchmAtom* schm = (AP4_SchmAtom*)FindChild("sinf/schm");    if (schm == NULL) return NULL;    // get the sample description for the original sample entry    AP4_MpegAudioSampleDescription* original_sample_description =         (AP4_MpegAudioSampleDescription*)        AP4_AudioSampleEntry::ToSampleDescription();    // get the schi atom    AP4_ContainerAtom* schi;    schi = static_cast<AP4_ContainerAtom*>(FindChild("sinf/schi"));    // create the sample description    return new AP4_IsmaCrypSampleDescription(        original_sample_description,        frma?frma->GetOriginalFormat():AP4_ATOM_TYPE_MP4A,        schm->GetSchemeType(),        schm->GetSchemeVersion(),        schm->GetSchemeUri().c_str(),        schi);}

/*----------------------------------------------------------------------|   AP4_TrakAtom::AP4_TrakAtom+---------------------------------------------------------------------*/AP4_TrakAtom::AP4_TrakAtom(AP4_UI32         size,                           AP4_ByteStream&  stream,                           AP4_AtomFactory& atom_factory) :    AP4_ContainerAtom(AP4_ATOM_TYPE_TRAK, size, false, stream, atom_factory){    m_TkhdAtom = AP4_DYNAMIC_CAST(AP4_TkhdAtom, FindChild("tkhd"));    m_MdhdAtom = AP4_DYNAMIC_CAST(AP4_MdhdAtom, FindChild("mdia/mdhd"));}

BOOL OSAL_ConfigController_SetNumValue(const char *ignore, const char *config_name, UINT32 *value){    BOOL result = FALSE;    BOOL bXmlRead, bSetInnerText, bXmlWrite;    pXmlElement xmlRoot, xmlTopElement, xmlTargetElement;    char buf[16] = {0};    if (config_name == NULL) {        return result;    }    pthread_mutex_lock(&g_configmutex);    // Open Config XML file    xmlRoot = CreateEmptyXmlData();    bXmlRead = ReadXmlFile(xmlRoot, CONFIG_XMLFILE);    if (!bXmlRead) {		OSALTRACE(OSAL_ERROR, ("cannot read config xml file"));		pthread_mutex_unlock(&g_configmutex);        return result;    }    // Find "config_name"    xmlTopElement = FindChild(xmlRoot, CONFIG_INTEL_WIMAX);    xmlTargetElement = FindChild(xmlTopElement, config_name);    if (xmlTargetElement != NULL) {	//convert integer to string	snprintf(buf, sizeof(buf), "%d", *value);        bSetInnerText = SetElementInnerText(xmlTargetElement, buf);        if(bSetInnerText == TRUE) {            // write to XML file            bXmlWrite = WriteXmlFile(xmlTopElement, CONFIG_XMLFILE_TMP);            if(bXmlWrite == TRUE) {                result = TRUE;			}			else {				OSALTRACE(OSAL_ERROR, ("cannot write config xml file"));				result = FALSE;			}		}	}    // Close XML    FreeXmlData(xmlRoot);	//swap the file	pthread_mutex_lock(&g_swapfilemutex);	rename(CONFIG_XMLFILE_TMP,CONFIG_XMLFILE);	pthread_mutex_unlock(&g_swapfilemutex);	pthread_mutex_unlock(&g_configmutex);    return result;}

BOOL OSAL_ConfigController_GetNumValue(const char *ignore, const char *config_name, UINT32 * value){	BOOL result = FALSE;	BOOL bXmlRead;	pXmlElement xmlRoot, xmlTopElement, xmlTargetElement;	const char *target_data;	BOOL bDnDOutputQuery = FALSE;	if (config_name == NULL) {		return result;	}	if ( strcasecmp(config_name, OSAL_KEY_ENTRY_DND_OUTPUT_MODE) == 0)	{		bDnDOutputQuery = TRUE;	}	pthread_mutex_lock(&g_configmutex);	// Open Config XML file	xmlRoot = CreateEmptyXmlData();  	bXmlRead = ReadXmlFile(xmlRoot, CONFIG_XMLFILE);	if (!bXmlRead) {		OSALTRACE(OSAL_ERROR, ("cannot read config xml file"));		pthread_mutex_unlock(&g_configmutex);		return result;	}	// Find "config_name"	xmlTopElement = FindChild(xmlRoot, CONFIG_INTEL_WIMAX);	xmlTargetElement = FindChild(xmlTopElement, config_name);	if (xmlTargetElement != NULL) {		target_data = GetElementInnerText(xmlTargetElement);		if (target_data != NULL) {			// Copy to the value			*value = (UINT32) atoi(target_data);			result = TRUE;		}	}	if ( bDnDOutputQuery )	{		OSALTRACE(OSAL_DEBUG, ("Result of query is %d, and value is %d.", result, result ? *value : -1));	}	// Close XML	FreeXmlData(xmlRoot);	pthread_mutex_unlock(&g_configmutex);	return result;}

// Try to expand as much of the given path as possible,// and select the given tree item.bool wxGenericDirCtrl::ExpandPath(const wxString& path){    bool done = false;    wxTreeItemId treeid = FindChild(m_rootId, path, done);    wxTreeItemId lastId = treeid; // The last non-zero treeid    while (treeid.IsOk() && !done)    {        ExpandDir(treeid);        treeid = FindChild(treeid, path, done);        if (treeid.IsOk())            lastId = treeid;    }    if (!lastId.IsOk())        return false;    wxDirItemData *data = (wxDirItemData *) m_treeCtrl->GetItemData(lastId);    if (data->m_isDir)    {        m_treeCtrl->Expand(lastId);    }    if (HasFlag(wxDIRCTRL_SELECT_FIRST) && data->m_isDir)    {        // Find the first file in this directory        wxTreeItemIdValue cookie;        wxTreeItemId childId = m_treeCtrl->GetFirstChild(lastId, cookie);        bool selectedChild = false;        while (childId.IsOk())        {            data = (wxDirItemData*) m_treeCtrl->GetItemData(childId);            if (data && data->m_path != wxEmptyString && !data->m_isDir)            {                m_treeCtrl->SelectItem(childId);                m_treeCtrl->EnsureVisible(childId);                selectedChild = true;                break;            }            childId = m_treeCtrl->GetNextChild(lastId, cookie);        }        if (!selectedChild)        {            m_treeCtrl->SelectItem(lastId);            m_treeCtrl->EnsureVisible(lastId);        }    }    else    {        m_treeCtrl->SelectItem(lastId);        m_treeCtrl->EnsureVisible(lastId);    }    return true;}

BOOL OSAL_ConfigController_GetStrValue(const char *ignore, const char *config_name, char* value,UINT32 maxsize){	BOOL result = FALSE;	BOOL bXmlRead;	pXmlElement xmlRoot, xmlTopElement, xmlTargetElement;	const char *target_data;	UINT32 data_size=0;	if (config_name == NULL) {		return result;	}	pthread_mutex_lock(&g_configmutex);		// Open Config XML file	xmlRoot = CreateEmptyXmlData();	bXmlRead = ReadXmlFile(xmlRoot, CONFIG_XMLFILE);	if (!bXmlRead) {		OSALTRACE(OSAL_ERROR, ("cannot read config xml file"));		pthread_mutex_unlock(&g_configmutex);		return result;	}	// Find "config_name"	xmlTopElement = FindChild(xmlRoot, CONFIG_INTEL_WIMAX);	xmlTargetElement = FindChild(xmlTopElement, config_name);	if (xmlTargetElement != NULL) 	{		target_data = GetElementInnerText(xmlTargetElement);		data_size = strlen(target_data)+1;		if (target_data != NULL)		{			if(data_size > maxsize -1){				// Copy to the value				memcpy(value, target_data, maxsize-1);				// Added by Kalyan to make the value as a complete string 				// and to avoid problems with strlen, strcpy on value without /0				value[maxsize-1] = '/0';			}			else {				memcpy(value, target_data, data_size);			}			result = TRUE;			}	}	// Close XML	FreeXmlData(xmlRoot);	pthread_mutex_unlock(&g_configmutex);	return result;}

void OGR_SRSNode::StripNodes( const char * pszName ){/* -------------------------------------------------------------------- *//*      Strip any children matching this name.                          *//* -------------------------------------------------------------------- */    while( FindChild( pszName ) >= 0 )        DestroyChild( FindChild( pszName ) );/* -------------------------------------------------------------------- *//*      Recurse                                                         *//* -------------------------------------------------------------------- */    for( int i = 0; i < GetChildCount(); i++ )        GetChild(i)->StripNodes( pszName );}

TreeNode * TreeNode::AddChild( TreeNode * Child ) { 	TreeNode * Result = NULL;		Result = FindChild( Child->Item, Child->ItemIsIntra);	if( Result == NULL ) {		Result = Child;		(*Children).push_back( Child ); 		// To keep the children vector sorted.		//inplace_merge( (*Children).begin(), (*Children).end()-1, (*Children).end(), TreeNodeLess );		Child->Parent = this;		if( Child->ItemIsIntra ) {			Child->ItemsetNumber = ItemsetNumber;			Child->Items = Items + 1;		}		else {			Child->ItemsetNumber = ItemsetNumber + 1;			Child->Items = Items + 1;		}	} else {		if( Child->Support > Result->Support )				Result->Support = Child->Support;		delete Child;	}	return Result;}

Room::Room(Map *m, Room *par, Direction from_direction, SDL_Rect area) {    map = m;    space = area;    parent = par;    for (int i = NORTH; i < LAST_DIRECTION; ++i) {        if (i == from_direction) {            children[from_direction] = parent;            corridors[from_direction] = (SDL_Rect) {0, 0, 0, 0};        }        else            children[i] = NULL;    }    map->ApplyRoom(this);    for (int i = 0; i < CHILD_TRIES; ++i) {        if (!hasChildrenAvailable())            break;        FindChild();    }    if (!map->lastroom && this->CountExits() < 2) {        map->lastroom = this;        AddObject(RoomObject::STAIRS_DOWN);    }}

bool ControlRoom::Attach(const char *nodeUrl,const char *controllerUrl) {  if (controllerUrl[0] ==0) return true;	ControlNode *existing=FindChild(nodeUrl) ;	if ((!existing)||(existing->GetType()!=CNT_ASSIGNABLE)) {		Trace::Error("Trying to map unknown node %s",nodeUrl) ;		return false ;	}		AssignableControlNode *acn=(AssignableControlNode*)existing ;	MultiChannelAdapter *mca=(MultiChannelAdapter *)acn->GetSourceChannel() ;	if (!mca) {		std::string name=acn->GetName() ;		name+="-adapter" ;		mca=new MultiChannelAdapter(name.c_str()) ;		acn->SetSourceChannel(mca) ;	}	Channel *channel=ControllerService::GetInstance()->GetChannel(controllerUrl) ;	if (channel) {		mca->AddChannel(*channel) ;		Trace::Log("MAPPING","Attached %s to %s",nodeUrl,controllerUrl) ;	} else {		Trace::Debug("Failed to attach %s to %s",nodeUrl,controllerUrl) ;	} ;	return true ;} ;

HWND FindChild(HWND hParent, wchar_t *find_name){    if(NULL == hParent)    {        return NULL;    }    HWND hFind = FindWindowEx(hParent, NULL, find_name, NULL);    if(NULL == hFind)    {// not found        HWND hChild = GetWindow(hParent, GW_CHILD);        while (hChild)        {            hFind = FindChild(hChild, find_name);            if(hFind)            {                return hFind;            }            hChild = GetWindow(hChild, GW_HWNDNEXT);        }        return NULL;    }    return hFind;}

CControlUI* CVideoFrame::FindChild( CContainerUI* pContainer, LPCTSTR strName ){	if (!pContainer)		return NULL;	if (_tcsicmp(strName, pContainer->GetName()) == 0)	{		return pContainer;	}	for (int i = 0; ; i ++)	{		CControlUI* pControl = pContainer->GetItemAt(i);		if (pControl == NULL)			return NULL;		if ( _tcsicmp(strName ,pControl->GetName()) == 0)		{			return pControl;		}		CContainerUI* pContainerSub = dynamic_cast<CContainerUI*>(pControl);		if (pContainerSub)		{			CControlUI* p = FindChild(pContainerSub, strName);			if (p)				return p;		}	}	return NULL;}

	QModelIndex MergeModel::mapFromSource (const QModelIndex& sourceIndex) const	{		if (!sourceIndex.isValid ())			return {};		QList<QModelIndex> hier;		auto parent = sourceIndex;		while (parent.isValid ())		{			hier.prepend (parent);			parent = parent.parent ();		}		auto currentItem = Root_;		for (const auto& idx : hier)		{			currentItem = currentItem->FindChild (idx);			if (!currentItem)			{				qWarning () << Q_FUNC_INFO						<< "no next item for"						<< idx						<< hier;				return {};			}		}		return createIndex (currentItem->GetRow (), sourceIndex.column (), currentItem.get ());	}

wxTreeItemId ClassBrowser::FindChild(const wxString& search, wxTreeCtrl* tree, const wxTreeItemId& start, bool recurse, bool partialMatch){    if (!tree)        return wxTreeItemId();    wxTreeItemIdValue cookie;    wxTreeItemId res = tree->GetFirstChild(start, cookie);    while (res.IsOk())    {        wxString text = tree->GetItemText(res);        if (   (!partialMatch && text == search)            || ( partialMatch && text.StartsWith(search)) )        {            return res;        }        if (recurse && tree->ItemHasChildren(res))        {            res = FindChild(search, tree, res, true, partialMatch);            if (res.IsOk())                return res;        }        res = m_CCTreeCtrl->GetNextChild(start, cookie);    }    res.Unset();    return res;}

FarDlgNode & FarDialog::operator[](const String & n){  FarDlgNode * obj = FindChild(n);  if (!obj)    FWError(Format(L"Request to undefined object %s", n.ptr()));  return *obj;}

void ScrollView::Build(){	if (nullptr == m_pDelegate)		return;	Item* pContent = (Item*)FindChild("Content");	if (nullptr == pContent)		return;	pContent->ClearChildren();	// create new items	ScrollViewModel* pModel = (ScrollViewModel*)GetModel();	int nCnt = pModel->GetCount();	for (int i = 0; i < nCnt; i++)	{		Item* pItem = GenerateDelegateItem();		if (!pItem->IsInstanceOf("ScrollViewDelegate"))		{			GetMgr()->Destroy(pItem->GetID());			continue;		}		ScrollViewDelegate* pDelegateItem = (ScrollViewDelegate*)pItem;		pDelegateItem->SetName("ScrollViewDelegateItem");		pDelegateItem->SetWidth(GetWidth());		pDelegateItem->SetHeight(50);		pDelegateItem->SetLeft(0);		pDelegateItem->SetTop(i*50);		pDelegateItem->SetIndex(i);		pContent->AddChild(pItem);	}}

int  CTrieHolder::GetTerminatedPeriodNext (int NodeNo) const{    if (NodeNo == 0) return -1;    TerminalSymbolType RelationChar = m_Nodes[NodeNo].m_IncomingSymbol;    int r =  m_Nodes[m_Nodes[NodeNo].m_Parent].m_FailureFunction;    while (r != -1) {        while ((r != -1) &&  (FindChild(r,RelationChar) == -1))                    r = m_Nodes[r].m_FailureFunction;        if (r != -1)            return FindChild(r,RelationChar);    };    return -1;};

int TreeAddObject(HWND hwndDlg, int ID, OPT_OBJECT_DATA * data){	HTREEITEM rootItem=NULL;	HTREEITEM cItem=NULL;	char * path;	char * ptr;	char * ptrE;	char buf[255];	BOOL ext=FALSE;	path=data->szPath?mir_strdup(data->szPath):(data->szName[1]=='$')?mir_strdup((data->szName)+2):NULL;	if (!path)	{		mir_snprintf(buf,SIZEOF(buf),"$(other)/%s",(data->szName)+1);		path=mir_strdup(buf);	}	ptr=path;	ptrE=path;		do 	{				while (*ptrE!='/' && *ptrE!='/0') ptrE++;		if (*ptrE=='/')		{			*ptrE='/0';			ptrE++;			// find item if not - create;			{				cItem=FindChild(GetDlgItem(hwndDlg,ID),rootItem,ptr);				if (!cItem) // not found - create node				{					TVINSERTSTRUCTA tvis;					tvis.hParent=rootItem;					tvis.hInsertAfter=TVI_SORT;					tvis.item.mask=TVIF_PARAM|TVIF_TEXT|TVIF_PARAM;					tvis.item.pszText=ptr;					tvis.item.lParam=(LPARAM)NULL;					cItem=TreeView_InsertItemA(GetDlgItem(hwndDlg,ID),&tvis);									}					rootItem=cItem;			}			ptr=ptrE;		}		else ext=TRUE;	}while (!ext);	//Insert item node	{		TVINSERTSTRUCTA tvis;		tvis.hParent=rootItem;		tvis.hInsertAfter=TVI_SORT;		tvis.item.mask=TVIF_PARAM|TVIF_TEXT|TVIF_PARAM;		tvis.item.pszText=ptr;		tvis.item.lParam=(LPARAM)data;		TreeView_InsertItemA(GetDlgItem(hwndDlg,ID),&tvis);	}	mir_free_and_nill(path);	return 0;}

/*----------------------------------------------------------------------|       AP4_TrakAtom::AdjustChunkOffsets+---------------------------------------------------------------------*/AP4_Result    AP4_TrakAtom::AdjustChunkOffsets(AP4_Offset offset){    if (AP4_Atom* atom = FindChild("mdia/minf/stbl/co64")) {        AP4_Co64Atom* co64 = dynamic_cast<AP4_Co64Atom*>(atom);        co64->AdjustChunkOffsets(offset);	}    AP4_Atom* atom = FindChild("mdia/minf/stbl/stco");    if (atom != NULL) {        AP4_StcoAtom* stco = dynamic_cast<AP4_StcoAtom*>(atom);        stco->AdjustChunkOffsets(offset);        return AP4_SUCCESS;    } else {        return AP4_FAILURE;    }}

		void XUI_Wnd::AddChild(XUI_Wnd* pElement )		{			if (-1==FindChild(pElement))			{				pElement->m_pParent=this;				m_pChildren.push_back(pElement);			}		}

/////////////////// Get the child by ID, returns NULL when not foundCBasicContainer *CBasicContainer::GetChild(const std::string& id){	ContainerList::iterator i = FindChild(id);	if (i == tChildren.end())		return NULL;	else		return *i;}

static OptionExp* FindSibling(OptionExp* pOptExp, const char* name){	OptionExp* pParent = pOptExp->GetParent();	if(pParent == NULL)	{		return NULL;	}	return FindChild(pParent, name);}