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

// Called before render is availablebool j1FileSystem::Awake(pugi::xml_node& config){	LOG("Loading File System");	bool ret = true;	// Add all paths in configuration in order	for(pugi::xml_node path = config.child("path"); path; path = path.next_sibling("path"))	{		AddPath(path.child_value());	}	// Ask SDL for a write dir	char* write_path = SDL_GetPrefPath(App->GetOrganization(), App->GetTitle());	if(PHYSFS_setWriteDir(write_path) == 0)		LOG("File System error while creating write dir: %s/n", PHYSFS_getLastError());	else	{		// We add the writing directory as a reading directory too with speacial mount point		LOG("Writing directory is %s/n", write_path);		AddPath(write_path, GetSaveDirectory());	}	SDL_free(write_path);	return ret;}

CString FindIncludeFile( const TCHAR *pszIncludeFilename, const TCHAR *pszIncludePath ){	CString strEnvInclude;	CStringList strrgPathList;		if( FileExists( pszIncludeFilename ) )		return CString(pszIncludeFilename);		// add current directory to path list;	strrgPathList.AddTail( ".//" );		// add path specified in the command line (/I option)	if( pszIncludePath )		AddPath( strrgPathList, pszIncludePath );		// add path specified in the INCLUDE variable	if( strEnvInclude.GetEnvironmentVariable( _T("INCLUDE") ) )		AddPath( strrgPathList, strEnvInclude );		POSITION pos = strrgPathList.GetHeadPosition();	for (int i=0;i < strrgPathList.GetCount();i++)	{		CString strPath = strrgPathList.GetNext(pos);		CString tmp = strPath.Right(1);		if( tmp != ":" && tmp != "//" )			strPath += '//';				strPath += pszIncludeFilename;				if( FileExists( strPath ) )			return CString(strPath);	}	return CString("");}

j1FileSystem::j1FileSystem(const char* game_path) : j1Module(){	name.create("file_system");	// need to be created before Awake so other modules can use it	char* base_path = SDL_GetBasePath();	PHYSFS_init(base_path);	SDL_free(base_path);	AddPath(".");	AddPath(game_path);}

void QtStylePreferencePage::Update(){  styleManager->RemoveStyles();  QString paths = m_StylePref->Get(berry::QtPreferences::QT_STYLE_SEARCHPATHS, "");  QStringList pathList = paths.split(";", QString::SkipEmptyParts);  QStringListIterator it(pathList);  while (it.hasNext())  {    AddPath(it.next(), false);  }  QString styleName = m_StylePref->Get(berry::QtPreferences::QT_STYLE_NAME, "");  styleManager->SetStyle(styleName);  oldStyle = styleManager->GetStyle();  FillStyleCombo(oldStyle);  QString fontName = m_StylePref->Get(berry::QtPreferences::QT_FONT_NAME, "Open Sans");  styleManager->SetFont(fontName);  int fontSize = m_StylePref->Get(berry::QtPreferences::QT_FONT_SIZE, "9").toInt();  styleManager->SetFontSize(fontSize);  controls.m_FontSizeSpinBox->setValue(fontSize);  styleManager->UpdateWorkbenchFont();  FillFontCombo(styleManager->GetFont());  controls.m_ToolbarCategoryCheckBox->setChecked(    m_StylePref->GetBool(berry::QtPreferences::QT_SHOW_TOOLBAR_CATEGORY_NAMES, true));}

void CRegisterDlg::OnReceiveComplete(void){	switch (m_ContextObject->InDeCompressedBuffer.GetBuffer(0)[0])	{	case TOKEN_REG_PATH:		{			AddPath((char*)(m_ContextObject->InDeCompressedBuffer.GetBuffer(1)));			break;		}	case TOKEN_REG_KEY:		{			AddKey((char*)(m_ContextObject->InDeCompressedBuffer.GetBuffer(1)));			break;		}	default:		// 传输发生异常数据		break;	}}

FilePath::FilePath(const FilePath &directory, const String &filename){	DVASSERT(directory.IsDirectoryPathname());    pathType = directory.pathType;	absolutePathname = AddPath(directory, filename);}

bool CTSVNPathList::LoadFromFile(const CTSVNPath& filename){    Clear();    try    {        CString strLine;        CStdioFile file(filename.GetWinPath(), CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite);        // for every selected file/folder        CTSVNPath path;        while (file.ReadString(strLine))        {            path.SetFromUnknown(strLine);            AddPath(path);        }        file.Close();    }    catch (CFileException* pE)    {        std::unique_ptr<TCHAR[]> error(new TCHAR[10000]);        pE->GetErrorMessage(error.get(), 10000);        ::MessageBox(NULL, error.get(), L"TortoiseSVN", MB_ICONERROR);        pE->Delete();        return false;    }    return true;}

bool CTGitPathList::LoadFromFile(const CTGitPath& filename){	Clear();	try	{		CString strLine;		CStdioFile file(filename.GetWinPath(), CFile::typeBinary | CFile::modeRead | CFile::shareDenyWrite);		// for every selected file/folder		CTGitPath path;		while (file.ReadString(strLine))		{			path.SetFromUnknown(strLine);			AddPath(path);		}		file.Close();	}	catch (CFileException* pE)	{		CTraceToOutputDebugString::Instance()(__FUNCTION__ ": CFileException loading target file list/n");		TCHAR error[10000] = {0};		pE->GetErrorMessage(error, 10000);//		CMessageBox::Show(NULL, error, _T("TortoiseGit"), MB_ICONERROR);		pE->Delete();		return false;	}	return true;}

int CTGitPathList::FillUnRev(unsigned int action, CTGitPathList *list, CString *err){	this->Clear();	CTGitPath path;	int count;	if(list==NULL)		count=1;	else		count=list->GetCount();	for (int i = 0; i < count; ++i)	{		CString cmd;		int pos = 0;		CString ignored;		if(action & CTGitPath::LOGACTIONS_IGNORE)			ignored= _T(" -i");		if(list==NULL)		{			cmd=_T("git.exe ls-files --exclude-standard --full-name --others -z");			cmd+=ignored;		}		else		{	cmd.Format(_T("git.exe ls-files --exclude-standard --full-name --others -z%s -- /"%s/""),					(LPCTSTR)ignored,					(*list)[i].GetWinPath());		}		BYTE_VECTOR out, errb;		out.clear();		if (g_Git.Run(cmd, &out, &errb))		{			if (err != nullptr)				CGit::StringAppend(err, &errb[0], CP_UTF8, (int)errb.size());			return -1;		}		pos=0;		CString one;		while (pos >= 0 && pos < (int)out.size())		{			one.Empty();			CGit::StringAppend(&one, &out[pos], CP_UTF8);			if(!one.IsEmpty())			{				//SetFromGit will clear all status				path.SetFromGit(one);				path.m_Action=action;				AddPath(path);			}			pos=out.findNextString(pos);		}	}	return 0;}

FX_BOOL CFX_LinuxFontInfo::ParseFontCfg(const char** pUserPaths) {  if (!pUserPaths) {    return FALSE;  }  for (const char** pPath = pUserPaths; *pPath; ++pPath) {    AddPath(*pPath);  }  return TRUE;}

FilePath::FilePath(const String &directory, const String &filename){	FilePath directoryPath(directory);	DVASSERT(!directoryPath.IsEmpty());	directoryPath.MakeDirectoryPathname();    pathType = directoryPath.pathType;	absolutePathname = AddPath(directoryPath, filename);}

bool Clipper::addPolyline(const ofPolyline& polyline,                          ClipperLib::PolyType PolyTyp,                          bool autoClose,                          ClipperLib::cInt scale){    auto _polyline = polyline;    if (autoClose) close(_polyline);    return AddPath(toClipper(_polyline, scale), PolyTyp, _polyline.isClosed());}

voidSCSIPressurePathManager::ActivatePath ( IOSCSIProtocolServices * interface ){		bool					result 	= false;	SCSITargetDevicePath *	path	= NULL;		STATUS_LOG ( ( "SCSIPressurePathManager::ActivatePath/n" ) );		require_nonzero ( interface, ErrorExit );		IOLockLock ( fLock );		result = fInactivePathSet->member ( interface );	if ( result == true )	{				path = fInactivePathSet->getObjectWithInterface ( interface );		if ( path != NULL )		{						path->retain ( );			path->Activate ( );			fInactivePathSet->removeObject ( interface );			fPathSet->setObject ( path );			path->release ( );			path = NULL;					}			}		else	{				result = fPathSet->member ( interface );		if ( result == false )		{						IOLockUnlock ( fLock );			AddPath ( interface );			goto Exit;					}			}		IOLockUnlock ( fLock );		ErrorExit:Exit:			return;	}

void PyInit(const TStr& PySettings){	Try	ifstream f(PySettings.CStr());	if (f.is_open())	{		std::string s;		std::getline(f, s);		Py_Initialize(); // инициализация интерпретатора  */		AddPath(s);		AddPath(s+"////networkx////generators");		AddPath(s+"////networkx////readwrite");		AddPath(s+"////networkx////classes");	}	return;			IAssert(1);	Catch	}

//reads envvar, splits it by : and ; and add it to pathlist, when existsstatic void GetEnv(const std::string& name, LSL::StringVector& pathlist){	const char* envvar = getenv(name.c_str());	if (envvar == NULL)		return;	LSL::StringVector res = LSL::Util::StringTokenize(envvar, ";:");	for (const std::string path : res) {		AddPath(path, pathlist);	}}

		void ZipArchiveImpl::AddFolder(const bfs::path& path, const bfs::path& archive_path)		{			++m_Info.folderCount;			zip_fileinfo fileinfo;			fileinfo.internal_fa = 0;#ifdef _WIN32			fileinfo.external_fa = ::GetFileAttributesW(path.native().c_str());#else			{				struct stat path_stat;				if (::stat(path.native().c_str(), &path_stat) == 0)				{					fileinfo.external_fa = path_stat.st_mode;				}			}#endif			fileinfo.dosDate = 0;			// Read the time from the filesystem and convert it			auto fsTime = bfs::last_write_time(path);			auto posixTime = boost::posix_time::from_time_t(fsTime);			auto tm = boost::posix_time::to_tm(posixTime);			/* TODO: this is how to get the time for a physfs file			boost::posix_time::ptime posixTime;			auto milisPastEpoc = PHYSFS_getLastModTime(path.generic_string().c_str());			if (milisPastEpoc >= 0)			time = boost::posix_time::ptime(boost::gregorian::date(1970, 1, 1), boost::posix_time::milliseconds(milisPastEpoc));			else			time = boost::posix_time::second_clock::local_time();			*/			fileinfo.tmz_date.tm_hour = tm.tm_hour;			fileinfo.tmz_date.tm_min = tm.tm_min;			fileinfo.tmz_date.tm_sec = tm.tm_sec;			fileinfo.tmz_date.tm_year = tm.tm_year;			fileinfo.tmz_date.tm_mon = tm.tm_mon;			fileinfo.tmz_date.tm_mday = tm.tm_mday;			auto r = zipOpenNewFileInZip(m_File, (archive_path.generic_string() + "/").c_str(),				&fileinfo,				nullptr, 0,				nullptr, 0,				nullptr,				Z_DEFLATED,				Z_BEST_SPEED);			zipCloseFileInZip(m_File);			for (bfs::directory_iterator it(path), end = bfs::directory_iterator(); it != end; ++it)			{				AddPath(it->path(), archive_path / it->path().filename());			}		}

FilePath& FilePath::operator+=(const String & path){    absolutePathname = AddPath(*this, path);	if (pathType == PATH_EMPTY)	{		pathType = GetPathType(absolutePathname);	}    return (*this);}

FilePath FilePath::operator+(const String &path) const{    FilePath pathname(AddPath(*this, path));    pathname.pathType = this->pathType;	if (this->pathType == PATH_EMPTY)	{		pathname.pathType = GetPathType(pathname.absolutePathname);	}    return pathname;}

  //  // RequestPath  //  // Request a new path be found.  Returns FALSE if request is invalid.  //  Finder::RequestResult Finder::RequestPath  (    U32 sx, U32 sz, U32 dx, U32 dz, U8 traction, UnitObj *unit,    SearchType type, U32 flags, PointList *blockList  )  {    // Forget any current path    ForgetPath();    // Is destination on the map    if (!WorldCtrl::CellOnMap(sx, sz) || !WorldCtrl::CellOnMap(dx, dz))    {      LOG_DIAG(("Request position is not on the map (%u, %u)->(%u,%u)", sx, sz, dx, dz));      return (RR_OFFMAP);    }    // Filter out requests to move to the same cell    if (sx == dx && sz == dz)    {      return (RR_SAMECELL);    }    // Can this traction type move to this cell    if (!CanMoveToCell(traction, dx, dz))    {      U32 xNew, zNew;      // Find the closest location we can move to      if (FindClosestCell(traction, dx, dz, xNew, zNew, 15))      {        // Use the new location        dx = xNew;        dz = zNew;      }      else      // AStar will fail, so jump straight to trace      if (type == ST_ASTAR)      {        type = ST_TRACE;      }    }    // Create a new path    path = new Path(sx, sz, dx, dz, traction, unit, type, flags, blockList);    // Add to the system    AddPath(path);    // Success    return (RR_SUBMITTED);  }

BOOL CAddListDlg::EnumerateFiles(){	m_AddFileCount=0;	BOOL success=TRUE;	// Recurse any directories in files list, placing enumerated files into 	// the 'files' list	POSITION pos=m_pStrList->GetHeadPosition();	for( int i=0; pos != NULL && success; i++)		success=AddPath(&m_EnumeratedList, m_pStrList->GetNext(pos));	return success;}

void C4Reloc::Init(){	Paths.clear();	// The system folder (i.e. installation path) has higher priority than the user path	// Although this is counter-intuitive (the user may want to overload system files in the user path),	// people had trouble when they downloaded e.g. an Objects.ocd file in a network lobby and that copy permanently	// ruined their OpenClonk installation with no obvious way to fix it.	// Not even reinstalling would fix the problem because reinstallation does not overwrite user data.	// We currently don't have any valid case where overloading system files would make sense so just give higher priority to the system path for now.#ifndef __APPLE__	// Add planet subfolder with highest priority because it's used when starting directly from the repository with binaries in the root folder	StdCopyStrBuf planet(Config.General.ExePath);	planet.AppendBackslash();	planet.Append("planet");	AddPath(planet.getData());#endif	// Add main system path	AddPath(Config.General.SystemDataPath);	// Add user path for additional data (player files, user scenarios, etc.)	AddPath(Config.General.UserDataPath, PATH_PreferredInstallationLocation);}

j1FileSystem::j1FileSystem() : j1Module(){	name.create("file_system");	// need to be created before Awake so other modules can use it	char* base_path = SDL_GetBasePath();	PHYSFS_init(base_path);	SDL_free(base_path);	// By default we include executable's own directory	// without this we won't be able to find config.xml :-(	AddPath(".");}

void CTGitPathList::LoadFromAsteriskSeparatedString(const CString& sPathString){	int pos = 0;	CString temp;	for(;;)	{		temp = sPathString.Tokenize(_T("*"),pos);		if(temp.IsEmpty())		{			break;		}		AddPath(CTGitPath(CPathUtils::GetLongPathname(temp)));	}}

void wxGraphicsPathData::AddEllipse( wxDouble x, wxDouble y, wxDouble w, wxDouble h){    wxDouble rw = w/2;    wxDouble rh = h/2;    wxDouble xc = x + rw;    wxDouble yc = y + rh;    wxGraphicsMatrix m = GetRenderer()->CreateMatrix();    m.Translate(xc,yc);    m.Scale(rw/rh,1.0);    wxGraphicsPath p = GetRenderer()->CreatePath();    p.AddCircle(0,0,rh);    p.Transform(m);    AddPath(p.GetPathData());}

void cTerrainGen3D::BuildPath(const tVector& origin, const tVector& ground_size, const Eigen::VectorXd& params, cRand& rand, 								std::vector<float>& out_data, std::vector<int>& out_flags){	double w = params[eParamsPathWidth0];	double len = params[eParamsPathLength];	double turn_len = params[eParamsPathTurnLength];	double h0 = params[eParamsPathHeight0];	double h1 = params[eParamsPathHeight1];	Eigen::Vector2i start_coord = Eigen::Vector2i::Zero();	Eigen::Vector2i out_res = Eigen::Vector2i::Zero();	out_res[0] = CalcResX(ground_size[0]);	out_res[1] = CalcResZ(ground_size[1]);	return AddPath(origin, start_coord, ground_size, out_res, w, len, turn_len, h0, h1, out_data, out_flags);}

voidGLRendererRoster::AddDefaultPaths(){	// add user directories first, so that they can override system renderers	const directory_which paths[] = {		B_USER_ADDONS_DIRECTORY,		B_COMMON_ADDONS_DIRECTORY,		B_BEOS_ADDONS_DIRECTORY,	};	for (uint32 i = fSafeMode ? 2 : 0; i < sizeof(paths) / sizeof(paths[0]); i++) {		BPath path;		status_t status = find_directory(paths[i], &path, true);		if (status == B_OK && path.Append("opengl") == B_OK)			AddPath(path.Path());	}}

Prefs_Fonts::Prefs_Fonts(QWidget* parent, ScribusDoc* doc)	: Prefs_Pane(parent),	m_doc(doc){	setupUi(this);	RList = PrefsManager::instance()->appPrefs.fontPrefs.GFontSub;	UsedFonts.clear();	CurrentPath = "";	m_askBeforeSubstitute = true;	setMinimumSize(fontMetrics().width( tr( "Available Fonts" )+ tr( "Font Substitutions" )+ tr( "Additional Paths" ))+180, 200);	fontListTableView->setModel(new FontListModel(fontListTableView, m_doc));	fontSubstitutionsTableWidget->setRowCount(RList.count());	fontSubstitutionsTableWidget->setColumnCount(2);	fontSubstitutionsTableWidget->setHorizontalHeaderItem(0, new QTableWidgetItem( tr("Font Name")));	fontSubstitutionsTableWidget->setHorizontalHeaderItem(1, new QTableWidgetItem( tr("Replacement")));	fontSubstitutionsTableWidget->setSortingEnabled(false);	fontSubstitutionsTableWidget->setSelectionBehavior( QAbstractItemView::SelectRows );	QHeaderView *header = fontSubstitutionsTableWidget->horizontalHeader();	header->setSectionsMovable(false);	header->setSectionsClickable(false);	header->setSectionResizeMode(QHeaderView::Stretch);	fontSubstitutionsTableWidget->verticalHeader()->hide();	fontSubstitutionsTableWidget->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));	// If we're being called for global application preferences, not document	// preferences, we let the user customize font search paths. Because things	// go rather badly if paths are changed/removed while a doc is open, the	// control is also not displayed if there is a document open.	if (m_doc==0 && !ScCore->primaryMainWindow()->HaveDoc)	{		whyBlankLabel->resize(0,0);		whyBlankLabel->hide();		readPaths();		changeButton->setEnabled(false);		removeButton->setEnabled(false);		connect(pathListWidget, SIGNAL(itemClicked(QListWidgetItem*)), this, SLOT(SelectPath(QListWidgetItem*)));		connect(addButton, SIGNAL(clicked()), this, SLOT(AddPath()));		connect(changeButton, SIGNAL(clicked()), this, SLOT(ChangePath()));		connect(removeButton, SIGNAL(clicked()), this, SLOT(DelPath()));	}

	void LoadPaths(const char *pArgv0)	{		// check current directory		IOHANDLE File = io_open("storage.cfg", IOFLAG_READ);		if(!File)		{			// check usable path in argv[0]			unsigned int Pos = ~0U;			for(unsigned i = 0; pArgv0[i]; i++)				if(pArgv0[i] == '/' || pArgv0[i] == '//')					Pos = i;			if(Pos < MAX_PATH_LENGTH)			{				char aBuffer[MAX_PATH_LENGTH];				str_copy(aBuffer, pArgv0, Pos+1);				str_append(aBuffer, "/storage.cfg", sizeof(aBuffer));				File = io_open(aBuffer, IOFLAG_READ);			}			if(Pos >= MAX_PATH_LENGTH || !File)			{				dbg_msg("storage", "couldn't open storage.cfg");				return;			}		}		char *pLine;		CLineReader LineReader;		LineReader.Init(File);		while((pLine = LineReader.Get()))		{			const char *pLineWithoutPrefix = str_startswith(pLine, "add_path ");			if(pLineWithoutPrefix)			{				AddPath(pLineWithoutPrefix);			}		}		io_close(File);		if(!m_NumPaths)			dbg_msg("storage", "no paths found in storage.cfg");	}

int CTGitPathList::FillBasedOnIndexFlags(unsigned short flag, CTGitPathList* list /*nullptr*/){	Clear();	CTGitPath path;	CAutoRepository repository(g_Git.GetGitRepository());	if (!repository)		return -1;	CAutoIndex index;	if (git_repository_index(index.GetPointer(), repository))		return -1;	int count;	if (list == nullptr)		count = 1;	else		count = list->GetCount();	for (int j = 0; j < count; ++j)	{		for (size_t i = 0, ecount = git_index_entrycount(index); i < ecount; ++i)		{			const git_index_entry *e = git_index_get_byindex(index, i);			if (!e || !((e->flags | e->flags_extended) & flag) || !e->path)				continue;			CString one = CUnicodeUtils::GetUnicode(e->path);			if (!(!list || (*list)[j].GetWinPathString().IsEmpty() || one == (*list)[j].GetGitPathString() || (PathIsDirectory(g_Git.CombinePath((*list)[j].GetWinPathString())) && one.Find((*list)[j].GetGitPathString() + _T("/")) == 0)))				continue;			//SetFromGit will clear all status			path.SetFromGit(one);			if ((e->flags | e->flags_extended) & GIT_IDXENTRY_SKIP_WORKTREE)				path.m_Action = CTGitPath::LOGACTIONS_SKIPWORKTREE;			else if ((e->flags | e->flags_extended) & GIT_IDXENTRY_VALID)				path.m_Action = CTGitPath::LOGACTIONS_ASSUMEVALID;			AddPath(path);		}	}	RemoveDuplicates();	return 0;}