C / C++ / MFC

// this function copies a "resource block" into memory
// The return value is size of memory that are actually used
DWORD CopyResToMem(UINT nResourceID, LPCTSTR lpResourceType, LPVOID lpBuffer, DWORD dwMaxBufferSize)
{
    ::ZeroMemory(lpBuffer, dwMaxBufferSize);
    HRSRC hRs = ::FindResource(NULL, MAKEINTRESOURCE(nResourceID), lpResourceType);
    if (hRs == NULL)
    {
        return 0;
    }
    
    HGLOBAL hGlb = ::Loadresource(NULL, hRs);
    if (hGlb == NULL)
    {
        return 0;
    }
  
    LPVOID pData = ::LockResource(hGlb);
    if (pData == NULL)
    {
        return 0;
    }
  
    // the actual resource size that are going to be copied
    const DWORD dwActualSize = min(dwMaxBufferSize, ::SizeofResource(NULL, hRs)); 
    ::memcpy(lpBuffer, pData, dwActualSize);
    return dwActualSize;
}

// I assume the text file size is 1000 bytes, but if it isn't, then just
// make "dwMyTextSize" large enough, anyway you are safe even 
// if "dwMyTextSize" is smaller than the reality.
  
DWORD dwMyTextSize = 1000; 
BYTE* pData = new BYTE[dwMyTextSize];
DWORD dwActual = CopyResToMem(MYTEXT, _T("TXT"), pData, dwMyTextSize);
  
ASSERT(dwActual > 0);
  
// Now this memory block "pData" is yours, you can do whatever you want to, 
// like writing it to a disk file or something.
  
/* ... Do your stuff here! ... */
  
delete [] pData;
pData = NULL;

DWORD GetResourceSize(UINT nResourceID, LPCTSTR lpResourceType)
{
    HRSRC hRs = ::FindResource(NULL, MAKEINTRESOURCE(nResourceID), lpResourceType);
    return ::SizeofResource(NULL, hRs);
}

// Amount of memory needed, in bytes
DWORD dwMyTextSize = GetResourceSize(MYTEXT, _T("TXT"));
BYTE* pData = new BYTE[dwMyTextSize];
/*Copy the resourse and use it here...*/
delete [] pData;
pData = NULL;

BOOL IsDouble(LPCTSTR lpStr)
{
    BOOL bHasPoint = FALSE; // Already has a point?
    const int LEN = _tcslen(lpStr);
    for (int i = 0; i < LEN; i++)
    {
        if (lpStr[i] < _T('0') || lpStr[i] > _T('9'))
        {
            // Not a digit, then what it is?
            if (lpStr[i] == _T('+') || lpStr[i] == _T('-'))
            {
                // if there's a sign, it must be the leading char
                if (i != 0)
                {
                    return FALSE;
                }
            }            
            else if (lpStr[i] == _T('.'))
            {
                if (bHasPoint
                    || i == 0
                    || i == LEN - 1
                    || (lpStr[i - 1] < _T('0') || lpStr[i - 1] > _T('9')))
                {
                    // point can occur only once,
                    // point must not be the leading char
                    // point must not be the last char
                    // point must follow a digit
                    return FALSE; 
                }
                else
                {
                    bHasPoint = TRUE;
                }
            }
            else
            {
                return FALSE; // definitely not a double
            }            
        }
    }
    return TRUE; // Validated
}