挑战：优化函数 MatchCharInString

Testing -- BBO
   Does not match: This is a Test
          Matches: Bob said, "Hello World!"   0 2 15
   Does not match: Lizzard Lips
   Does not match: Zebra tails                2
   Does not match: Luke warm milk
Testing -- RZ
   Does not match: This is a Test
   Does not match: Bob said, "Hello World!"   19
   Does not match: Lizzard Lips               5
   Does not match: Zebra tails                3
   Does not match: Luke warm milk             7
Testing -- ZR
   Does not match: This is a Test
   Does not match: Bob said, "Hello World!"
          Matches: Lizzard Lips               2 5
          Matches: Zebra tails                0 3
   Does not match: Luke warm milk
Testing -- KML
   Does not match: This is a Test
   Does not match: Bob said, "Hello World!"
   Does not match: Lizzard Lips
   Does not match: Zebra tails
          Matches: Luke warm milk             2 8 12

// Does a lowercase match each character in sMatchChars to a character in the string sSource
// (also lower case).
// Each match is done in sequence. When the first character is found from sMatchChars the
// next character from sMatchChars is searched for the current position of sSource to
// the end of sSource string.
// The position of each match is stored in the vector index that is passed by reference.
// Returns true if all sMatchChars are found before reaching the end of sSource, false otherwise.
bool MatchCharsInString(const wchar_t * pcszSource, const wchar_t * pcszMatchChars, std::vector & index)
{
    std::wstring sSource(pcszSource);
    std::wstring sMatchChars(pcszMatchChars);
    // change input strings to lower case
    std::transform(sSource.begin(), sSource.end(), sSource.begin(), std::tolower);
    std::transform(sMatchChars.begin(), sMatchChars.end(), sMatchChars.begin(), std::tolower);
    bool bFound = true;
    size_t pos = 0;
    std::wstring::iterator itChar = sMatchChars.begin();
    for(itChar; itChar != sMatchChars.end(); itChar++) {
        pos = sSource.find_first_of(*itChar, pos);
        if(pos == std::wstring::npos) {
            // if the position of sSource is the end of the string then
            // there was not a complete match of each character in sMatchChars
            bFound = false;
            break;
        }
        index.push_back(pos);  //push valid position to index
        pos++;
    }
    return bFound;
}

////////////////////////////////////////////////////////////////////////
// Will not work for some unicode locales.
////////////////////////////////////////////////////////////////////////
bool MatchString(const wchar_t * pcszSource, const wchar_t * pcszMatchChars)
{
        while(*pcszMatchChars) {
                wchar_t c = std::tolower(*pcszMatchChars);
                while(*pcszSource) {
                        if(c == std::tolower(*pcszSource)) {
                                break;
                        }
                        pcszSource++;
                }
                if(!*pcszSource)
                        break;
                pcszMatchChars++;
        }
        return (*pcszSource && !*pcszMatchChars);
}

#include "stdafx.h"
#include 
#include 
#include 
void MatchString(const wchar_t *pcszSource, const wchar_t *pcszMatchChars, 
                 std::vector & index)
{
  std::locale loc;
  bool bMatchIsHigh;
  bool bSrcIsHigh;
  for(size_t idx = 0; *pcszSource != '\0'; idx++)
  {
    if(*pcszMatchChars != '\0')
    {
      bMatchIsHigh = IS_HIGH_SURROGATE(*pcszMatchChars);
      bSrcIsHigh = IS_HIGH_SURROGATE(*pcszSource);
      if(!bMatchIsHigh && !bSrcIsHigh)
      {
        if(std::tolower(*pcszSource,loc) == std::tolower(*pcszMatchChars,loc))
        {
          index.push_back(idx);
          pcszMatchChars++;
        }
        pcszSource++;
      }
      else if(bMatchIsHigh && bSrcIsHigh)
      {
        if( *pcszSource+1 != '\0' && *pcszMatchChars+1 != '\0')
        {
          UINT32 a = ((*pcszSource - 0xD800) * 0x400) + 
             (*pcszSource+1 - 0xDC00) + 0x10000;
          UINT32 b = ((*pcszMatchChars - 0xD800) * 0x400) + 
            (*pcszMatchChars+1 - 0xDC00) + 0x10000;
          if(std::tolower(a,loc) == std::tolower(b,loc))
          {
            index.push_back(idx);
            pcszMatchChars++;
            pcszMatchChars++;
          }
          pcszSource++;
          pcszSource++;
        }
        else
        {
          return;// bad format
        }
      }
      else if(bMatchIsHigh  && !bSrcIsHigh) 
      { 
        pcszSource++;
      }
      else if(!bMatchIsHigh && bSrcIsHigh) 
      { 
        pcszSource++;
        pcszSource++;
      }
    }
    else
    {
      break;
    }
  }
}
int _tmain(int argc, _TCHAR* argv[])
{
  std::vector index;
  wchar_t a[] = {'d', 'a', 0xD834, 0xDD1E,'\0'};
  wchar_t b[] = {'a', 0xD834, 0xDD1E,'\0'};
  //wchar_t a[] = {'L','u','k','e',' ',0xD834,0xDD1E,'w','a','r','m',' ','m','i','l','k','\0'};
  //wchar_t b[] = {'K',0xD834,0xDD1E,'L','\0'}; // 2 5 13
  //wchar_t a[] = {'L','u','k','e',' ','w','a','r','m',' ','m','i','l','k','\0'};
  //wchar_t b[] = {'K','M','L','\0'};
  MatchString(a,b,index);
  for(size_t i = 0; i < index.size(); i++)
  {
    wprintf(_T("%ld "),index[i]);
  }
  system("pause");
  return 0;
}

          UINT32 a = ((*pcszSource - 0xD800) * 0x400) + 
             (*pcszSource+1 - 0xDC00) + 0x10000;
          UINT32 b = ((*pcszMatchChars - 0xD800) * 0x400) + 
            (*pcszMatchChars+1 - 0xDC00) + 0x10000;
          if(std::tolower(a,loc) == std::tolower(b,loc))

if((*pcszSource + *pcszSource+1) ==
             (*pcszMatchChars + *pcszMatchChars+1))