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

BOOL PutHash( LPCTSTR lpszFile, LPOPTIONS lpOpt ){	DWORD w;	LPCTSTR lpszFormat;	if( lpOpt->DispFilename ){		lpszFormat = _T( "%3!s!(%4!s!) : %1!s!-%2!8.8X!.pf/n" );	}else{		if( lpOpt->HashXp && lpOpt->HashVista ){			lpszFormat = _T( "(%4!s!) : %1!s!-%2!8.8X!.pf/n" );		}else{			lpszFormat = _T( "%1!s!-%2!8.8X!.pf/n" );		}	}	if( lpOpt->HashVista ){		w = HashVista( lpszFile );		my_printf( hStdout, lpszFormat, Basename( lpszFile ), w, lpszFile, _T("Vista") );	}	if( lpOpt->HashXp ){		w = HashXp( lpszFile );		my_printf( hStdout, lpszFormat, Basename( lpszFile ), w, lpszFile, _T("XP") );	}	return TRUE;}

/** * @brief */static cm_material_t *Cm_LoadBspMaterials(const char *name) {    char base[MAX_QPATH];    StripExtension(Basename(name), base);    return Cm_LoadMaterials(va("materials/%s.mat", base), NULL);}

bool COption::init(int argc, char** argv){    if(m_bInit)    {        return true;    }    m_optNum = sizeof(OptTab)/sizeof(OptTab[0]);    if(!initOption())    {        return false;    }        //获取程序名称    m_myName = Basename(argv[0]);        //获取命令行选项    int oc = -1;    char optString[sizeof(OptTab)/sizeof(OptTab[0]) * 2] = {0};    makeOptString(optString);    //解析命令行    while((oc = getopt(argc, argv, optString)) != -1)    {        if(Unknown_key == oc || Usage_key == oc)        {            usage();            return false;        }        setOption(oc, optarg);    }    return true;}

staticVOIDShowUsage(    PCSTR pszProgramName,    BOOLEAN bFull    ){    printf(        "Usage: %s [ --<object type> ] [ <flags> ] [ --provider name ]/n",        Basename(pszProgramName));        if (bFull)    {        printf(            "/n"            "Object type options:/n"            "    --user                  Return only user objects/n"            "    --group                 Return only group objects/n"            "/n"            "Query flags:/n"            "     --nss                  Omit data not necessary for NSS layer/n"            "/n"            "Other options:/n"            "     --domain name          Restrict enumeration to the specified NetBIOS domain/n"            "     --provider name        Direct request to provider with the specified name/n"            "/n");    }}

/* * Cl_LoadLocations * * Parse a .loc file for the current level. */void Cl_LoadLocations(void) {	const char *c;	char file_name[MAX_QPATH];	FILE *f;	int i;	Cl_ClearLocations(); // clear any resident locations	i = 0;	// load the locations file	c = Basename(cl.config_strings[CS_MODELS + 1]);	snprintf(file_name, sizeof(file_name), "locations/%s", c);	strcpy(file_name + strlen(file_name) - 3, "loc");	if (Fs_OpenFile(file_name, &f, FILE_READ) == -1) {		Com_Debug("Couldn't load %s/n", file_name);		return;	}	while (i < MAX_LOCATIONS) {		const int err = fscanf(f, "%f %f %f %[^/n]", &locations[i].loc[0],				&locations[i].loc[1], &locations[i].loc[2], locations[i].desc);		num_locations = i;		if (err == EOF)			break;		i++;	}	Cl_LoadProgress(100);	Com_Print("Loaded %i locations./n", num_locations);	Fs_CloseFile(f);}

/* ------------------------------------------------------------- * do_stat: print all important inode info for the path INODE  *      (1) get INODE of path into a minode[] table  *      (2) print all important info  *  * Note: This is the lazy way. KC's recommended way utilizes * the stat struct  --------------------------------------------------------------*/void do_stat(char* path){    MINODE* dir;     char timebuf[256];     int ino;     int dev = running->cwd->dev;         //(1) get INODE of path into a minode[table]    ino = getino(&dev, path);   // get ino     dir = iget(dev, ino);       // get MINODE*         if(dir == NULL)    {        printf("Error: unable to stat %s/n", path);         return;     }        // Copy dir's modified time into timebuf    ctime_r(&dir->INODE.i_mtime, timebuf);     timebuf[24] = 0;    // add NULL terminator             printf("-------------------------------------------------------/n");     printf("file: %s/n", Basename(path));     printf("dev: %d/t/tinode number: %i/tmode:%3x/n", dir->dev, dir->ino, dir->INODE.i_mode);     printf("uid: %i/tgid: %i/tlink count: %d/n", running->uid, running->gid, dir->INODE.i_links_count);     printf("size: %d/t/t%5s/n", dir->INODE.i_size, timebuf);     printf("-------------------------------------------------------/n");         iput(dir);         }

bool RageSound::Load( CString sSoundFilePath, bool bPrecache ){	LOG->Trace( "RageSound::LoadSound( '%s', %d )", sSoundFilePath.c_str(), bPrecache );	CString error;	SoundReader *pSound = SoundReader_FileReader::OpenFile( sSoundFilePath, error );	if( pSound == NULL )	{		LOG->Warn( "RageSound::Load: error opening sound /"%s/": %s",			sSoundFilePath.c_str(), error.c_str() );		pSound = new RageSoundReader_Silence;	}	LoadSoundReader( pSound );	/* Try to precache.  Do this after calling LoadSoundReader() to put the	 * sound in this->m_pSource, so we preload after resampling. */	if( bPrecache )		RageSoundReader_Preload::PreloadSound( m_pSource );	m_sFilePath = sSoundFilePath;	m_Mutex.SetName( ssprintf("RageSound (%s)", Basename(sSoundFilePath).c_str() ) );	return true;}

const char* FileInfo::tail(){	const char* name = Basename();	const char* pt =  strrchr(name, '.');	return (pt == NULL ? "" : pt);}

void ScreenTestSound::UpdateText(int n){	RString fn = Basename( s[n].s.GetLoadedFilePath() );	vector<RageSound *> &snds = m_sSoundCopies[n];	RString pos;	for(unsigned p = 0; p < snds.size(); ++p)	{		if(p) pos += ", ";		pos += ssprintf("%.3f", snds[p]->GetPositionSeconds());	}	s[n].txt.SetText(ssprintf(		"%i: %s/n"		"%s/n"		"%s/n"		"(%s)/n"		"%s",		n+1, fn.c_str(),		s[n].s.IsPlaying()? "Playing":"Stopped",		s[n].s.GetParams().StopMode == RageSoundParams::M_STOP?			"Stop when finished":		s[n].s.GetParams().StopMode == RageSoundParams::M_CONTINUE?			"Continue until stopped":			"Loop",		pos.size()? pos.c_str(): "none playing",		selected == n? "^^^^^^":""		));}

static RString MakeTempFilename( const RString &sPath ){	/* "Foo/bar/baz" -> "Foo/bar/new.baz.new".  Both prepend and append: we don't	 * want a wildcard search for the filename to match (foo.txt.new matches foo.txt*),	 * and we don't want to have the same extension (so "new.foo.sm" doesn't show up	 * in *.sm). */	return Dirname(sPath) + "new." + Basename(sPath) + ".new";}

/* * grpck - verify group file integrity */int main (int argc, char **argv){	int errors = 0;	bool changed = false;	/*	 * Get my name so that I can use it to report errors.	 */	Prog = Basename (argv[0]);	(void) setlocale (LC_ALL, "");	(void) bindtextdomain (PACKAGE, LOCALEDIR);	(void) textdomain (PACKAGE);	process_root_flag ("-R", argc, argv);	OPENLOG ("grpck");	/* Parse the command line arguments */	process_flags (argc, argv);	open_files ();	if (sort_mode) {		gr_sort ();#ifdef	SHADOWGRP		if (is_shadow) {			sgr_sort ();		}		changed = true;#endif	} else {		check_grp_file (&errors, &changed);#ifdef	SHADOWGRP		if (is_shadow) {			check_sgr_file (&errors, &changed);		}#endif	}	/* Commit the change in the database if needed */	close_files (changed);	nscd_flush_cache ("group");	/*	 * Tell the user what we did and exit.	 */	if (0 != errors) {		if (changed) {			printf (_("%s: the files have been updated/n"), Prog);		} else {			printf (_("%s: no changes/n"), Prog);		}	}	return ((0 != errors) ? E_BAD_ENTRY : E_OKAY);}

/* * main - groupadd command */int main (int argc, char **argv){	/*	 * Get my name so that I can use it to report errors.	 */	Prog = Basename (argv[0]);	(void) setlocale (LC_ALL, "");	(void) bindtextdomain (PACKAGE, LOCALEDIR);	(void) textdomain (PACKAGE);	process_root_flag ("-R", argc, argv);	prefix = process_prefix_flag ("-P", argc, argv);	OPENLOG ("groupadd");#ifdef WITH_AUDIT	audit_help_open ();#endif	if (atexit (do_cleanups) != 0) {		fprintf (stderr,		         _("%s: Cannot setup cleanup service./n"),		         Prog);		exit (1);	}	/*	 * Parse the command line options.	 */	process_flags (argc, argv);	check_perms ();#ifdef SHADOWGRP	is_shadow_grp = sgr_file_present ();#endif	/*	 * Do the hard stuff - open the files, create the group entries,	 * then close and update the files.	 */	open_files ();	if (!gflg) {		if (find_new_gid (rflg, &group_id, NULL) < 0) {			exit (E_GID_IN_USE);		}	}	grp_update ();	close_files ();	nscd_flush_cache ("group");	return E_SUCCESS;}

/*!**/intmain(int argc, char** argv){  char *progname = argv[0];  glutInit(&argc, argv);  for(++argv; --argc > 0; ++argv)  {    if( strcmp(*argv, "-help") ==  0 || strcmp(*argv, "--help") == 0 )    {      fputs("View a 3DS model file using OpenGL./n", stderr);      fputs("Usage: 3dsplayer [-nodb|-aa|-flush] <filename>/n", stderr);#ifndef USE_SDL      fputs("Texture rendering is not available; install SDL_image and recompile./n", stderr);#endif      exit(0);    }    else if( strcmp(*argv, "-nodb") == 0 )      dbuf = 0;    else if( strcmp(*argv, "-aa") == 0 )      anti_alias = 1;    else if( strcmp(*argv, "-flush") == 0 )      flush = 1;    else {      filepath = *argv;      decompose_datapath(filepath);    }  }  if (filepath == NULL) {    fputs("3dsplayer: Error: No 3DS file specified/n", stderr);    exit(1);  }  glutInitDisplayMode(GLUT_DEPTH | GLUT_RGB | (dbuf ? GLUT_DOUBLE:0) );  glutInitWindowSize(500, 500);  glutInitWindowPosition(100, 100);  glutCreateWindow(filepath != NULL ? Basename(filepath) : progname);  init();  create_icons();  load_model();  build_menu();  glutAttachMenu(2);  glutDisplayFunc(display);  glutReshapeFunc(reshape);  glutKeyboardFunc(keyboard);  glutMouseFunc(mouse_cb);  glutMotionFunc(drag_cb);  glutTimerFunc(10, timer_cb, 0);  glutMainLoop();  return(0);}

static string GetDumpLocalID(){  string localId = Basename(gReporterDumpFile);  string::size_type dot = localId.rfind('.');  if (dot == string::npos)    return "";  return localId.substr(0, dot);}

void DataFlowTrace::ReadCoverage(const std::string &DirPath) {  Vector<SizedFile> Files;  GetSizedFilesFromDir(DirPath, &Files);  for (auto &SF : Files) {    auto Name = Basename(SF.File);    if (Name == kFunctionsTxt) continue;    std::ifstream IF(SF.File);    Coverage.AppendCoverage(IF);  }}

void DirectFilenameDB::CacheFile( const RString &sPath ){	CHECKPOINT_M( root+sPath );	RString sDir = Dirname( sPath );	FileSet *pFileSet = GetFileSet( sDir, false );	if( pFileSet == NULL )	{		// This directory isn't cached so do nothing.		m_Mutex.Unlock(); // Locked by GetFileSet()		return;	}	while( !pFileSet->m_bFilled )		m_Mutex.Wait();		#if defined(WIN32)	// There is almost surely a better way to do this	WIN32_FIND_DATA fd;	HANDLE hFind = DoFindFirstFile( root+sPath, &fd );	if( hFind == INVALID_HANDLE_VALUE )	{		m_Mutex.Unlock(); // Locked by GetFileSet()		return;	}	File f( fd.cFileName );	f.dir = !!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);	f.size = fd.nFileSizeLow;	f.hash = fd.ftLastWriteTime.dwLowDateTime;		pFileSet->files.insert( f );	FindClose( hFind );#else	File f( Basename(sPath) );		struct stat st;	if( DoStat(root+sPath, &st) == -1 )	{		int iError = errno;		/* If it's a broken symlink, ignore it.  Otherwise, warn. */		/* Huh? */		WARN( ssprintf("File '%s' is gone! (%s)",			       sPath.c_str(), strerror(iError)) );	}	else	{		f.dir = (st.st_mode & S_IFDIR);		f.size = (int)st.st_size;		f.hash = st.st_mtime;	}		pFileSet->files.insert(f);#endif	m_Mutex.Unlock(); // Locked by GetFileSet()	}

const char* FileInfo::realpath(){	char* pt = strdup( _path.c_str());    string dir = ::dirname(pt);	free(pt);	_realpath = _path;	if ( dir[0] == '~' )	{//		const char* pt = getenv("HOME");		const gchar* pt = g_get_home_dir() ;		if ( pt != NULL )			dir = pt + dir.substr(1);	}	else if ( dir[0] == '$' )	{		char varname[80];		const char* pt;		int i;		for ( i=0, pt = dir.c_str()+1;			*pt && *pt != ')' && strncmp(pt,_path_delim,1) ; ++pt )			if ( *pt == '(' ) continue;			else varname[i++] = *pt;		varname[i] = 0;		if ( *pt == ')' ) ++pt;		if ( varname[0] ) {			const char* pt2 = getenv(varname);			if ( pt2 != NULL ) {				dir = string(pt2) + string(pt);			} else				Log::err() << "Error in FileInfo::realpath : undefined environment variable " << varname << endl;		}	}	else if ( dir[0] == '.' )	{  		char resolved[MAXPATHLEN];		char current[MAXPATHLEN];		if ( getcwd(current, sizeof(current)) == NULL )			return "";  // rep courant indefini		if ( chdir(dir.c_str()) != 0 )			return ""; // path invalide		getcwd(resolved, sizeof(resolved));		chdir (current);		dir=resolved;	}	_realpath = FileInfo(dir).join(Basename());	return _realpath.c_str();}

void BackgroundUtil::GetGlobalBGAnimations( const Song *pSong, const RString &sMatch, vector<RString> &vsPathsOut, vector<RString> &vsNamesOut ){	vsPathsOut.clear();	GetDirListing( BG_ANIMS_DIR+sMatch+"*", vsPathsOut, true, true );	GetDirListing( BG_ANIMS_DIR+sMatch+"*.xml", vsPathsOut, false, true );	vsNamesOut.clear();	FOREACH_CONST( RString, vsPathsOut, s )		vsNamesOut.push_back( Basename(*s) );	StripCvsAndSvn( vsPathsOut, vsNamesOut );}

static bool MoveCrashData(const string& toDir,                          string& dumpfile,                          string& extrafile,                          string& memoryfile){  if (!UIEnsurePathExists(toDir)) {    UIError(gStrings[ST_ERROR_CREATEDUMPDIR]);    return false;  }  string newDump = toDir + UI_DIR_SEPARATOR + Basename(dumpfile);  string newExtra = toDir + UI_DIR_SEPARATOR + Basename(extrafile);  string newMemory = toDir + UI_DIR_SEPARATOR + Basename(memoryfile);  if (!UIMoveFile(dumpfile, newDump)) {    UIError(gStrings[ST_ERROR_DUMPFILEMOVE]);    return false;  }  if (!UIMoveFile(extrafile, newExtra)) {    UIError(gStrings[ST_ERROR_EXTRAFILEMOVE]);    return false;  }  if (!memoryfile.empty()) {    // Ignore errors from moving the memory file    if (!UIMoveFile(memoryfile, newMemory)) {      UIDeleteFile(memoryfile);      newMemory.erase();    }    memoryfile = newMemory;  }  dumpfile = newDump;  extrafile = newExtra;  return true;}

/* ------------------------------------------------------- * make_dir:  *      must understand perfectly!!! *  *      Takes a pathname as parameter  *  *      (1) set the device  *      (2) get parent MINODE by using dirname with  *              getino  *          Load MINODE using iget  *      (3) call my_mkdir(MINODE* parent, char* name) *  --------------------------------------------------------*/void make_dir(char* path){    MINODE* pip;                // parent MINODE*     int dev, pino;              // device, parent ino         // parent = path to parent directory, child = basename     char* parent, *child;                // (1) Set device according to relative or absolute path     if(path[0] == '/')        dev = root->dev;     else         dev = running->cwd->dev;         // (2) Separate path into dirname and basename     parent = strdup(Dirname(path));     // make copies     child = strdup(Basename(path));         // Debug print     //printf("parent: %s/n", parent);    //printf("child: %s/n", child);        // (3) get in memory MINODE of parent directory     pino = getino(&dev, parent); // First, get parent ino     pip = iget(dev, pino); // Then use it to load INODE into minode[] table            // (4) Error checking on found MINODE    if(pip == NULL)                     // (4.1) ensure the MINODE was found     {        printf("Error: unable to locate %s/n", parent);     }    else if(!isdir(pip))                // (4.2) is DIR     {        printf("Error: %s is not a directory/n", parent);    }    else if(search(pip, child) != 0)    // (4.3) child does not already exist        {        // the child was already found         printf("Error: %s already exists in %s/n", child, parent);     }    // (5) We've verified that parent path exists, is a directory         // and child does not exist in it, so add to it      else        my_mkdir(pip,child);         // No matter what, dont forget to write back!     // Release parent from minode[] table and write back to disk     iput(pip);}

int shell (const char *file, /*@[email
C++ Basic函数代码示例
C++ BaseWindingForPlane函数代码示例