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

HRESULT CComModule::RegisterTypeLib(){	USES_CONVERSION;	_ASSERTE(m_hInst != NULL);	TCHAR szModule[_MAX_PATH+4];	TCHAR szDir[_MAX_PATH];	GetModuleFileName(GetTypeLibInstance(), szModule, _MAX_PATH);	CComPtr<ITypeLib> pTypeLib;	HRESULT hr = LoadTypeLib(T2OLE(szModule), &pTypeLib);	if (!SUCCEEDED(hr))	{		// typelib not in module, try <module>.tlb instead		LPTSTR lpszExt = szModule + lstrlen(szModule);		for (LPTSTR lpsz = szModule; *lpsz != '/0'; lpsz = CharNext(lpsz))		{			if (*lpsz == '.')				lpszExt = lpsz;		}		_ASSERTE(lpszExt != NULL);		lstrcpy(lpszExt, _T(".tlb"));		hr = LoadTypeLib(T2OLE(szModule), &pTypeLib);	}	if (SUCCEEDED(hr))	{		int nLen = lstrlen(szModule) - AtlGetFileName(szModule, NULL, 0);		lstrcpy(szDir, szModule);		szDir[nLen] = 0;		return ::RegisterTypeLib(pTypeLib, T2OLE(szModule), T2OLE(szDir));	}	return S_FALSE;}

LPCTSTR FindOneOf(LPCTSTR p1, LPCTSTR p2){    while (p1 != NULL && *p1 != NULL)    {        LPCTSTR p = p2;        while (p != NULL && *p != NULL)        {            if (*p1 == *p)                return CharNext(p1);            p = CharNext(p);        }        p1 = CharNext(p1);    }    return NULL;}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow){  DWORD               Ret;  STARTUPINFO         si   = {0};  PROCESS_INFORMATION pi   = {0};  char command_line[1024];  char seekchar=' ';  char *cmdline;    si.cb = sizeof(si);  // Make child process use this app's standard files. Not needed because the handles  // we created when executing this process were inheritable.  //si.dwFlags    = STARTF_USESTDHANDLES;  //si.hStdInput  = GetStdHandle (STD_INPUT_HANDLE);  //si.hStdOutput = GetStdHandle (STD_OUTPUT_HANDLE);  //si.hStdError  = GetStdHandle (STD_ERROR_HANDLE);  lstrcpyn(command_line, GetCommandLine(), 1024);    cmdline = command_line;  if (*cmdline == '/"') seekchar = *cmdline++;  while (*cmdline && *cmdline != seekchar) cmdline=CharNext(cmdline);  cmdline=CharNext(cmdline);  // skip any spaces before the arguments  while (*cmdline && *cmdline == ' ') cmdline++;  Ret = CreateProcess (NULL, cmdline,    NULL, NULL,    TRUE, 0,    NULL, NULL,    &si, &pi    );  if (Ret)  {    WaitForSingleObject(pi.hProcess, INFINITE);    GetExitCodeProcess(pi.hProcess, &Ret);    CloseHandle (pi.hProcess);    CloseHandle (pi.hThread);    ExitProcess(Ret);  }  else  {    ExitProcess(STATUS_ILLEGAL_INSTRUCTION);  }  return 0; // dummy}

static voidpush_include_cygwin(const char *path, VALUE (*filter)(VALUE)){    const char *p, *s;    char rubylib[FILENAME_MAX];    VALUE buf = 0;    p = path;    while (*p) {	unsigned int len;	while (*p == ';')	    p++;	if (!*p) break;	for (s = p; *s && *s != ';'; s = CharNext(s));	len = s - p;	if (*s) {	    if (!buf) {		buf = rb_str_new(p, len);		p = RSTRING_PTR(buf);	    }	    else {		rb_str_resize(buf, len);		p = strncpy(RSTRING_PTR(buf), p, len);	    }	}	if (cygwin_conv_to_posix_path(p, rubylib) == 0)	    p = rubylib;	push_include(p, filter);	if (!*s) break;	p = s + 1;    }}

VOID ACLStr::RTrim(VOID){	LPTSTR string			= CharFirst();	LPTSTR lastWhiteSpace	= NULL;	//	Loop over the string looking	//	for white spaces. We start at the	//	front since we want to be DBCS compatible.	//	At least that's the HOPE! :-)	while(*string != '/0')	{		if (*string == CH_SPACE)		{			if (lastWhiteSpace == NULL)			{				lastWhiteSpace = string;			}		}		else			lastWhiteSpace = NULL;		//	Bump our current pointer to the next		//	character in the stream.		//		string = CharNext();	}	//	while.	//	Move the NULL terminator to the	//	new location.	if (lastWhiteSpace != NULL)	{		*lastWhiteSpace	= '/0';		_length			= (lastWhiteSpace - _string);	}} // RTrim

/*----------------------------------------------------------------------------------------- Check Format--------------------------------------------------*/DWORD FindFormat(const char* fmt){	DWORD ret = 0;		while(*fmt) {		if(*fmt == '"') {			do{				for(++fmt; *fmt&&*fmt++!='"'; );			}while(*fmt == '"');			if(!*fmt)				break;		}				else if(*fmt == 's') {			fmt++;			ret |= FORMAT_SECOND;		}		else if(*fmt == 'T' && strncmp(fmt, "TIME", 4) == 0) {			fmt += 4;			ret |= FORMAT_SECOND;		}				else if(*fmt == '@' && fmt[1] == '@' && fmt[2] == '@') {			fmt += 3;			if(*fmt == '.' && fmt[1] == '@') {				ret |= FORMAT_BEAT2;				fmt += 2;			} else ret |= FORMAT_BEAT1;		}				else fmt = CharNext(fmt);	}	return ret;}

/*-------------------------------------------　パス名にファイル名をつける---------------------------------------------*/void add_title(char *path, char *title){	char *p;		p = path;	if(*title && *(title + 1) == ':') ;	else if(*title == '//')	{		if(*p && *(p + 1) == ':') p += 2;	}	else	{		while(*p)		{			if((*p == '//' || *p == '/') && *(p + 1) == 0)			{				break;			}			p = (char *)CharNext(p);		}		*p++ = '//';	}	while(*title) *p++ = *title++;	*p = 0;}

static int WordCmpI(LPCTSTR psz1, LPCTSTR psz2) throw(){    TCHAR c1 = (TCHAR)CharUpper((LPTSTR)*psz1);    TCHAR c2 = (TCHAR)CharUpper((LPTSTR)*psz2);    while (c1 != NULL && c1 == c2 && c1 != ' ' && c1 != '/t')    {        psz1 = CharNext(psz1);        psz2 = CharNext(psz2);        c1 = (TCHAR)CharUpper((LPTSTR)*psz1);        c2 = (TCHAR)CharUpper((LPTSTR)*psz2);    }    if ((c1 == NULL || c1 == ' ' || c1 == '/t') && (c2 == NULL || c2 == ' ' || c2 == '/t'))        return 0;    return (c1 < c2) ? -1 : 1;}

static inline voidtranslate_char(char *p, int from, int to){    while (*p) {	if ((unsigned char)*p == from)	    *p = to;	p = CharNext(p);    }}

TCHAR *_get_cmd_arg(TCHAR *pCmdLine){    static TCHAR *pArgs = NULL;    TCHAR *pRetArg;    BOOL bQuoted;    if (!pCmdLine && !pArgs)        return NULL;    if (!pArgs)        pArgs = pCmdLine;    /* skip whitespace */    for (pRetArg = pArgs; *pRetArg && _istspace(*pRetArg);         pRetArg = CharNext(pRetArg))        ;    if (!*pRetArg) {        pArgs = NULL;        return NULL;    }    /* check for quote */    if (*pRetArg == TEXT('"')) {        bQuoted = TRUE;        pRetArg = CharNext(pRetArg);        pArgs = _tcschr(pRetArg, TEXT('"'));    } else {        /* skip to whitespace */        for (pArgs = pRetArg; *pArgs && !_istspace(*pArgs);             pArgs = CharNext(pArgs))            ;    }    if (pArgs && *pArgs) {        TCHAR *p;        p = pArgs;        pArgs = CharNext(pArgs);        *p = (TCHAR) 0;    } else {        pArgs = NULL;    }    return pRetArg;}

LPTSTR FindChar(LPTSTR lpsz, TCHAR ch){        while (*lpsz != 0)        {                if (*lpsz == ch)                        return lpsz;                lpsz = CharNext(lpsz);        }        return NULL;}

LPTSTR FindReverseChar(LPTSTR lpsz, TCHAR ch){        LPTSTR lpszLast = NULL;        while (*lpsz != 0)        {                if (*lpsz == ch)                        lpszLast = lpsz;                lpsz = CharNext(lpsz);        }        return lpszLast;}

BOOL HasBlanks(    LPTSTR psz){    while (*psz) {        if (*psz == CHAR_SPACE)            return TRUE;        else            psz = CharNext(psz);    }    return FALSE;}

static UINT PASCAL AtlGetFileName(LPCTSTR lpszPathName, LPTSTR lpszTitle, UINT nMax){	_ASSERTE(lpszPathName != NULL);	// always capture the complete file name including extension (if present)	LPTSTR lpszTemp = (LPTSTR)lpszPathName;	for (LPCTSTR lpsz = lpszPathName; *lpsz != '/0'; lpsz = CharNext(lpsz))	{		// remember last directory/drive separator		if (*lpsz == '//' || *lpsz == '/' || *lpsz == ':')			lpszTemp = (LPTSTR)CharNext(lpsz);	}	// lpszTitle can be NULL which just returns the number of bytes	if (lpszTitle == NULL)		return lstrlen(lpszTemp)+1;	// otherwise copy it into the buffer provided	lstrcpyn(lpszTitle, lpszTemp, nMax);	return 0;}

static int lstrncmpi (LPCTSTR pszA, LPCTSTR pszB, size_t cch){   if (!pszA || !pszB)      {      return (!pszB) - (!pszA);   // A,!B:1, !A,B:-1, !A,!B:0      }   for ( ; cch > 0; cch--, pszA = CharNext(pszA), pszB = CharNext(pszB))      {      TCHAR chA = toupper( *pszA );      TCHAR chB = toupper( *pszB );      if (!chA || !chB)         return (!chB) - (!chA);    // A,!B:1, !A,B:-1, !A,!B:0      if (chA != chB)         return (int)(chA) - (int)(chB);   // -1:A<B, 0:A==B, 1:A>B      }   return 0;  // no differences before told to stop comparing, so A==B}

static VALUErubylib_mangled_path(const char *s, unsigned int l){    static char *newp, *oldp;    static int newl, oldl, notfound;    char *ptr;    VALUE ret;    if (!newp && !notfound) {	newp = getenv("RUBYLIB_PREFIX");	if (newp) {	    oldp = newp = strdup(newp);	    while (*newp && !ISSPACE(*newp) && *newp != ';') {		newp = CharNext(newp);	/* Skip digits. */	    }	    oldl = newp - oldp;	    while (*newp && (ISSPACE(*newp) || *newp == ';')) {		newp = CharNext(newp);	/* Skip whitespace. */	    }	    newl = strlen(newp);	    if (newl == 0 || oldl == 0) {		rb_fatal("malformed RUBYLIB_PREFIX");	    }	    translate_char(newp, '//', '/');	}	else {	    notfound = 1;	}    }    if (!newp || l < oldl || STRNCASECMP(oldp, s, oldl) != 0) {	return rb_str_new(s, l);    }    ret = rb_str_new(0, l + newl - oldl);    ptr = RSTRING_PTR(ret);    memcpy(ptr, newp, newl);    memcpy(ptr + newl, s + oldl, l - oldl);    ptr[l + newl - oldl] = 0;    return ret;}

MODULEVERSION& ModuleVersion(HINSTANCE instance/* = 0*/){    static bool Initialized = false;    static MODULEVERSION g_ModuleVersion = { 0 };    if (!Initialized)    {        //  Initialize Module version information        TCHAR szFileName[MAX_PATH];        DWORD dwLen;        BOOL bGotModuleVersion = FALSE;        if ((dwLen = GetModuleFileName(static_cast<HMODULE>(instance), szFileName, sizeof(szFileName))))        {            szFileName[dwLen] = '/0';            DWORD dwHandle, dwInfoLen;            if ((dwInfoLen = GetFileVersionInfoSize(szFileName, &dwHandle)))            {                char *szVersionBuffer = (char *)malloc(dwInfoLen);                if (GetFileVersionInfo(szFileName, dwHandle, dwInfoLen, szVersionBuffer))                {                    VS_FIXEDFILEINFO *fi;                    UINT uBlockLen;                    if (VerQueryValue(szVersionBuffer, _T("//"),                         reinterpret_cast<LPVOID*>(&fi), &uBlockLen))                    {                        Initialized = true;                        g_ModuleVersion.Major = fi->dwProductVersionMS >> 16;                        g_ModuleVersion.Minor = fi->dwProductVersionMS & 0xff;                        g_ModuleVersion.Release = fi->dwProductVersionLS >> 16;                        g_ModuleVersion.Build = fi->dwProductVersionLS & 0xff;                        //  Get module path                        g_ModuleVersion.ModuleFullPath = szFileName;                        TCHAR *eop = _tcsrchr(szFileName, _T('//'));            //  end of path                        g_ModuleVersion.ModuleFileName = CharNext(eop);         //  beginning of the file name                        *CharNext(eop) = _T('/0');                        g_ModuleVersion.ModulePath = szFileName;                    }                }

/*-------------------------------------------　パス名からファイル名をとりのぞく---------------------------------------------*/void del_title(char *path){	char *p, *ep;	p = ep = path;	while(*p)	{		if(*p == '//' || *p == '/')		{			if(p > path && *(p - 1) == ':') ep = p + 1;			else ep = p;		}		p = (char *)CharNext(p);	}	*ep = 0;}

PCTSTR WINAPIpGetFilePart(    IN PCTSTR FilePath){    PCTSTR LastComponent = FilePath;    TCHAR  CurChar;    while(CurChar = *FilePath) {        FilePath = CharNext(FilePath);        if((CurChar == TEXT('//')) || (CurChar == TEXT('/')) || (CurChar == TEXT(':'))) {            LastComponent = FilePath;        }    }    return LastComponent;}

int WinMain(HINSTANCE hinst, HINSTANCE hinstPrev, LPSTR cmdLine, int nShow){    char buf[30];    if (!cmdLine || !cmdLine[0])        return 0;    LPSTR next = CharNext(cmdLine);    if (*next != 0)    {		OutputDebugString("Yes");    }     else     {		OutputDebugString("No");    }    return 0;}

void TrimString(TCHAR *pszStr){	int i;	TCHAR *psz,szChars[]=_T(" /r/n/t");	for(i=0;i<SIZEOF(szChars);++i) {		/* trim end */		psz=&pszStr[lstrlen(pszStr)-1];		while(pszStr[0] && *psz==szChars[i]) {			*psz=0;			psz=CharPrev(pszStr,psz);		}		/* trim beginning */		for(psz=pszStr;(*psz && *psz==szChars[i]);psz=CharNext(psz));		MoveMemory(pszStr,psz,(lstrlen(psz)+1)*sizeof(TCHAR));	}}

char *my_strstr(char *a, char *b){  int l = lstrlen(b);  while (lstrlen(a) >= l)  {    char c = a[l];    a[l] = 0;    if (!lstrcmpi(a, b))    {      a[l] = c;      return a;    }    a[l] = c;    a = CharNext(a);  }  return NULL;}

TCHAR *my_strstr(TCHAR *a, TCHAR *b){  int l = lstrlen(b);  while (lstrlen(a) >= l)  {    TCHAR c = a[l];    a[l] = 0;    if (!lstrcmpi(a, b))    {      a[l] = c;      return a;    }    a[l] = c;    a = CharNext(a);  }  return NULL;}

CString NameFromVKey(UINT nVK){	CString str;	if (0x00 == nVK)	{		str = _T("None");	}	else if (VK_SNAPSHOT == nVK)	{		str = _T("Prt Scr");	}	else	{		UINT nScanCode = MapVirtualKeyEx(nVK, 0, GetKeyboardLayout(0));		switch(nVK) {			// Keys which are "extended" (except for Return which is Numeric Enter as extended)			case VK_INSERT:			case VK_DELETE:			case VK_HOME:			case VK_END:			case VK_NEXT:  // Page down			case VK_PRIOR: // Page up			case VK_LEFT:			case VK_RIGHT:			case VK_UP:			case VK_DOWN:				nScanCode |= 0x100; // Add extended bit		}			// GetKeyNameText() expects the scan code to be on the same format as WM_KEYDOWN		// Hence the left shift		LPTSTR prb = str.GetBuffer(80);		BOOL bResult = GetKeyNameText(nScanCode << 16, prb, 79);		// these key names are capitalized and look a bit daft		int len = lstrlen(prb);		if(len > 1) {			LPTSTR p2 = CharNext(prb);			CharLowerBuff(p2, len - (p2 - prb) );		}		str.ReleaseBuffer();		ATLASSERT(str.GetLength());	}	return str; // internationalization ready, sweet!}

static char *strrdirsep(const char *path){    char *last = NULL;    while (*path) {	if (isdirsep(*path)) {	    const char *tmp = path++;	    while (isdirsep(*path)) path++;	    if (!*path) break;	    last = (char *)tmp;	}	else {	    path = CharNext(path);	}    }    return last;}

static voidpush_include(const char *path, VALUE (*filter)(VALUE)){    const char sep = PATH_SEP_CHAR;    const char *p, *s;    VALUE load_path = GET_VM()->load_path;    p = path;    while (*p) {	while (*p == sep)	    p++;	if (!*p) break;	for (s = p; *s && *s != sep; s = CharNext(s));	rb_ary_push(load_path, (*filter)(rubylib_mangled_path(p, s - p)));	p = s;    }}

int WINAPI ReplaceCharWithNull(LPTSTR psz, int ch){        int cChanged = 0;        if (psz == NULL)                return -1;        while ('/0' != *psz)        {                if (ch == *psz)                {                        *psz++ = '/0';                        cChanged++;                        continue;                }                psz = CharNext(psz);        }        return cChanged;}