Opening and reading files

[reeset]

Hi folks:

I'm very new to C++, and I am trying to figure out how to open and read a file. I do not want to the the MFC, but rather, would like to use something like the fread function so that I can read chuncks of the file. What this is going to be used for, is I have files that are basically one string, and about 5 MB each. I want to be able to read 255 character chunks out of the file, and search these chuncks for an particular ASCII character. If the character isn't in the chunk, then I need to place it into a variable and then re-read the file. Once the ASCII character is found, I will then take the contents of any previous chuncks, as well as what has just been read, and run it through a processor. If anyone can give me any advice on any of this, I would greatly appreciate it.

[HarryW]

Try something like:


FILE *fpFile;
char buffer;

// open file for reading, check the syntax because it's been a while.
fpFile = fopen(FILE_PATH_AND_NAME, "r");

// Loop through and send characters to the processor until STOP_CHARACTER is found.
// Again, check the syntax
while ((buffer = getchar(fpFile)) != STOP_CHARACTER)
{
//Send character to processor
};

fclose(fpFile);


That code's off the top of my head and it's been a while since I wrote C code, so I expect there'll be lots of bugs :)

[parksie]

Here's something to make your life easier - it's a tiny interface onto the low-level file i/o so you don't need to bring in too much excess :). You don't have to use it, but it helps if you want to keep your .exe file size down.


#ifndef __DIRECTFILE_H__
#define __DIRECTFILE_H__

#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>

class DirectFile {
public:
DirectFile() {
m_iFD = -1;
}

virtual ~DirectFile() {
//Close();
}

bool OpenRead(char *pcFilename, bool bBinary) {
if(m_iFD != -1) {
return false;
}
m_iFD = _open(pcFilename, (bBinary ? _O_BINARY : _O_TEXT) | _O_RANDOM | _O_RDONLY);
if(m_iFD == -1)
return false;
m_bMode = false;
return true;
}

bool OpenWrite(const char *pcFilename, bool bCreate, bool bBinary, bool bAppend) {
if(m_iFD != -1) {
return false;
}
m_iFD = _open(pcFilename, (bBinary ? _O_BINARY : _O_TEXT) | (bCreate ? _O_CREAT : 0) | _O_RANDOM | _O_RDWR | (bAppend ? _O_APPEND : _O_TRUNC), _S_IREAD | _S_IWRITE);
if(m_iFD == -1)
return false;
m_bMode = true;
return true;
}

bool Close() {
if(m_iFD != -1) {
int iResult = _close(m_iFD);
m_iFD = -1;
if(iResult == -1)
return false;
if(iResult == 0)
return true;
}
return false;
}

int Write(void *pData, int nSize, int nCount) {
if((m_iFD == -1) || (m_bMode == false))
return -1;

int iCount = _write(m_iFD, pData, nCount * nSize);
if(iCount == -1)
return -1;

return (iCount / nSize);
}

int Read(void *pBuffer, int nSize, int nCount) {
if((m_iFD == -1) || (m_bMode == true))
return 0;

int iCount = _read(m_iFD, pBuffer, nCount * nSize);
if(iCount == -1)
return 0;
return (iCount / nSize);
}

long GetPos() {
if(m_iFD == -1)
return -1;
return _tell(m_iFD);
}

long Seek(long lOffset, long lOrigin) {
if(m_iFD == -1)
return -1;
return _lseek(m_iFD, lOffset, lOrigin);
}

int m_iFD;
bool m_bMode; // true=write, false=read
};

#endif // __DIRECTFILE_H__

To use, something like:

DirectFile dfFile;
char pcBuf[255];
int iCount;

dfFile.OpenRead("filename.ext", false); // false = text mode

while(iCount = dfFile.Read(pcBuf, sizeof(char), 255)) {
// Search pcBuf for the character...
if(iCount < 255) break;
}

dfFile.Close();

...or similar. Harry's code will work just as well with a quick change to read 255 bytes at a time.

Wow...choices.