std::ifstream issue when running outside of IDE - c++

Question

I have a function that works fine when running inside of the Visual Studio debugging environment (with both the Debug and Release configurations), but when running the app outside of the IDE, just as an end-user would do, the program crashes. This happens with both the Debug and Release builds.
I'm aware of the differences that can exist between the Debug and Release configurations (optimizations, debug symbols, etc) and at least somewhat aware of the differences between running an app inside Visual Studio versus outside of it (debug heap, working directory, etc). I've looked at several of these things and none seem to address the issue. This is actually my first time posting to SO; normally I can find the solution from existing posts so I'm truly stumped!
I am able to attach a debugger and oddly enough I get two different error messages, based on whether I'm running the app on Windows 7 versus Windows 8.1. For Windows 7, the error is simply an access violation and it breaks right on the return statement. For Windows 8.1, it is a heap corruption error and it breaks on the construction of std::ifstream. In both cases, all of the local variables are populated correctly so I know it is not a matter of the function not being able to find the file or read its contents into the buffer data.
Also interestingly, the issue happens only about 20% of the time on Windows 8.1 and 100% of the time on Windows 7, though this may have something to do with the vastly different hardware these OS's are running on.
I'm not sure it makes any difference but the project type is a Win32 Desktop App and it initializes DirectX 11. You'll notice that the file type is interpreted as binary, which is correct as this function is primarily loading compiled shaders.
Here is the static member function LoadFile:
HRESULT MyClass::LoadFile(_In_ const CHAR* filename, _Out_ BYTE** data, _Out_ SIZE_T* length)
{
CHAR pwd[MAX_PATH];
GetCurrentDirectoryA(MAX_PATH, pwd);
std::string fullFilePath = std::string(pwd) + "\\" + filename;
std::ifstream file(fullFilePath, std::ifstream::binary);
if (file)
{
file.seekg(0, file.end);
*length = (SIZE_T)file.tellg();
file.seekg(0, file.beg);
*data = new BYTE[*length];
file.read(reinterpret_cast<CHAR*>(*data), *length);
if (file) return S_OK;
}
return E_FAIL;
}
UPDATE:
Interestingly, if I allocate std::ifstream file on the heap and do not delete it, the issue goes away. There must be something about the destruction of ifstream that is causing an issue in my case.

Answer 1

You don't check the return value of GetCurrentDirectoryA - maybe your current directory name is too long or something?
If you are already using Win32 (not portable!), use GetFileSize to get file size rather than doing seek
Better yet, use boost to write portable code
Switch on all warnings in compiler options
Enable ios exceptions

Answer 2

Okay, I gave up on trying to use ifstream. Apparently I'm not the only one that has this issue...just search "ifstream destructor crash".
Since this app is based on DirectX and will only be run on Windows, I went the Windows API route and everything works perfectly.
Working code, in case anyone cares:
HRESULT MyClass::LoadFile(_In_ const CHAR* filename, _Out_ BYTE** data, _Out_ SIZE_T* length)
{
CHAR pwd[MAX_PATH];
GetCurrentDirectoryA(MAX_PATH, pwd);
string fullFilePath = string(pwd) + "\\" + filename;
WIN32_FIND_DATAA fileData;
HANDLE file = FindFirstFileA(fullFilePath.c_str(), &fileData);
if (file == INVALID_HANDLE_VALUE) return E_FAIL;
file = CreateFileA(fullFilePath.c_str(),
GENERIC_READ,
FILE_SHARE_READ,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (file == INVALID_HANDLE_VALUE) return E_FAIL;
*length = (SIZE_T)fileData.nFileSizeLow;
*data = new BYTE[*length];
DWORD bytesRead;
if (ReadFile(file, *data, *length, &bytesRead, NULL) == FALSE || bytesRead != *length)
{
delete[] *data;
*length = 0;
CloseHandle(file);
return E_FAIL;
}
CloseHandle(file);
return S_OK;
}