Manish K. Agarwal - Professional Profile

_tsetlocale(LC_NUMERIC, _T("German_Germany.1252"));

CString GetLocaleStr()
{
	CString localeStrBuf;
	TCHAR strBuf[128];
	memset(strBuf, 0, sizeof(strBuf));
	
	// Load the English name of the locale
	GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGLANGUAGE, strBuf, 127);
	localeStrBuf = strBuf;
 
	memset(strBuf, 0, sizeof(strBuf));
 
        // Load the English name for the country/region
	GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SENGCOUNTRY, strBuf, 127);
	if (*strBuf)
	{
		localeStrBuf += _T("_");
		localeStrBuf += strBuf;
	}
 
	memset(strBuf, 0, sizeof(strBuf));
 
        // Load the code page
	if ((GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTANSICODEPAGE, strBuf, 127)
		|| GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTCODEPAGE, strBuf, 127))
		&& *strBuf)
        {
		localeStrBuf += _T(".");
		localeStrBuf += strBuf;
	}
 
	return localeStrBuf;
}

   TCHAR* lcl = _tcsdup(::_tsetlocale(LC_NUMERIC, NULL)); //Save the current locale
   ::_tsetlocale(LC_NUMERIC, _T(""));  //Set the locale to the environment locale

   // your code

   ::_tsetlocale(LC_NUMERIC, lcl); //restore the original locale
   free(lcl);

BOOL CheckPattern(LPTSTR pattern, LPTSTR str)
{
   LPTSTR pStrCurPos = NULL;
   LPTSTR pPatCurPos = NULL;
   LPTSTR pStrMatchPos =  NULL;
   LPTSTR pPatMatchPos = NULL;
   BOOL fIsAsterisk  = FALSE;
 

   pStrMatchPos = pStrCurPos = str;
   pPatMatchPos = pPatCurPos = pattern;
 

 
   while (*pStrCurPos != '\0')
   {
      if (*pPatCurPos == _T('*'))
      {
         fIsAsterisk = TRUE;
 
         
         // Set matched string to cur position
         pStrMatchPos = pStrCurPos;
 
         // Move to the next position in the pattern
         pPatMatchPos = ++pPatCurPos;
 
         if (*pPatMatchPos == '\0')
         {
            return TRUE;
         }
 
         continue;
      }
      else if (*pPatCurPos == _T('?'))
      {
        // do nothing just move to next char
      }
      else if (*pStrCurPos != *pPatCurPos)
      {
         if (fIsAsterisk == FALSE)
         {
             // Not processing wildcard
            return FALSE;
         }
 
         // Move to next position in String
         pStrCurPos = ++pStrMatchPos;
 
         // Reset pattern in matched position
         pPatCurPos = pPatMatchPos;
 
         continue;
      }
 
      // Move current position forward
      ++pStrCurPos;
      ++pPatCurPos;
   } // while

 
   if (*pPatCurPos == _T('*'))
      ++pPatCurPos;
 
   return (*pPatCurPos == _T('\0'));
}

class MySingleton
{
public:
	static MySingleton *GetInstance(){
		if (mMySingletonP == NULL) {
			mMySingletonP = new MySingleton;
		}
 
		return mMySingletonP;
	}
 
private:
	MySingleton(){
	}
 
	MySingleton(const MySingleton & ){
	}
 
	MySingleton & operator=(const MySingleton & ) {
		// Wrong but we just want a private implementation
		// We simply want no one call this.
		return *((MySingleton *)NULL);
	}
 
	~MySingleton(){
	}
 
	static MySingleton *mMySingletonP;
 
};

class Singleton
{
public:
	static Singleton &GetInstance(){
		static Singleton instance;
 
		return instance;
	}
 
private:
	Singleton(){
	}
 
	Singleton(const Singleton & ){
	}
 
	Singleton & operator=(const Singleton & ) {
		// We simply want no one call this.
		return *this;
	}
 
	~Singleton(){
	}
 
};

static MySingleton *GetInstance() {
 
     if (mMySingletonP == NULL) {
           // Aquire a lock here
           if (mMySingletonP == NULL) {
                mMySingletonP = new MySingleton;
           }
           // relase lock here
     }
 
     return mMySingletonP;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int nTmp1 = 10;
	Singleton &firstRef = Singleton::GetInstance();
 
	Singleton &otherRef = Singleton::GetInstance();
 
	return 0;
}

int sprintf_s1(char* buffer, size_t bufferSize, const char *formattingString, ...)
{
  int size = -1;
 
  if (bufferSize < 1 || buffer == NULL) {
	  return size;
  }
  va_list argptr;
 
  va_start(argptr, formattingString);
 
  //FILE *nul = fopen("nul", "w");
  
  // calculate the size of output by nul device.
  size = vfprintf(stderr, formattingString, argptr);
  //fclose(nul);

  if (size > bufferSize) {
    return -1;
  }
 
  size = vsprintf(buffer, formattingString, argptr);
  // ensure null termination.
  buffer[(size > 0) ? (size-1) : 0] = '\0';
 
  va_end(argptr);
 
   return size;
}