C++ Text File Input

Question

This is a relatively simple question but I can't seem to find an answer. I need to read every character from a text file excluding spaces.

I currently have:

fstream inFile(fileName, ios::in);
char ch;
while (!inFile.eof()){
ch = inFile.get();

This is working for all letters and number but not special characters. What's an alternative I can use to read everything but spaces?

Answer 1

Assuming the file is ASCII and contains no NULL characters the following method could be used.

size_t ReadAllChars(char const* fileName, char **ppDestination)
{
    //Check inputs
    if(!filename || !ppDestination)
    {
        //Handle errors;
        return 0;
    }

    //open file for reading
    FILE *pFile = fopen(fileName, "rb");

    //check file successfully opened
    if(!pFile)
    {
        //Handle error
        return 0;
    }

    //Seek to end of file (to get file length)
    if(_fseeki64(pFile, 0, SEEK_END))
    {
        //Handle error
        return 0;
    }

    //Get file length
    size_t fileLength = _ftelli64(pFile);
    if(fileLength == -1)
    {
        //Handle error
        return 0;
    }

    //Seek back to start of file
    if(_fseeki64(pFile, 0, SEEK_SET))
    {
        //Handle error
        return 0;
    }

    //Allocate memory to store entire contents of file
    char *pRawSource = (char*)malloc(fileLength);

    //Check that allocation succeeded
    if(!pRawSource)
    {
        //Handle error
        //return 0;
    }

    //Read entire file
    if(fread(pRawSource, 1, fileLength, pFile) != fileLength))
    {
        //Handle error
        fclose(pFile);
        free(pRawSource);
        return 0;
    }

    //Close file
    fclose(pFile);

    //count spaces
    size_t spaceCount = 0;
    for(size_t i = 0; i < fileLength; i++)
    {
        if(pRawSource[i] == ' ')
            ++spaceCount;
    }

    //allocate space for file contents not including spaces (plus a null terminator)
    size_t resultLength = fileLength - spaceCount;
    char *pResult = (char*)malloc(resultLength + 1)

    //Check allocation succeeded
    if(!pResult)
    {
        //Handle error
        free(pRawSource);
        return 0;
    }

    //Null terminate result
    pResult[resultLength] = NULL;

    //copy all characters except space into pResult
    char *pNextTarget = pResult;
    for(size_t i = 0; i < fileLength; i++)
    {
        if(pRawSource[i] != ' ')
        {
            *pNextTarget = pRawSource[i];
            ++pNextTarget;
        }
    }

    //Free temporary buffer
    free(pRawSource);

    *ppDestination = pResult;
    return resultLength;
}

Answer 2

You should open the file in binary mode

Answer 3

Assuming you are using the default locale of C++, maybe try to put them into a std::string and let std::ifstream& operator >> (std::ifstream&, std::string&) and std::skipws do the magic (skip all spaces) for you?

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <utility>

int main(int, char* argv[]) 
{
    const char *filename = /* filename */;
    std::ifstream in{filename};
    if (in.fail()) {
        std::cerr << "Fails to open " << filename << std::endl;
        return 1;
    }
    /*
     * Actually, you can skip this line, because the default behavior of 
     * std::fstream and other stream is to skip all the white space before input.
     */
    in >> std::skipws;

    std::vector<std::string> stringv;
    // reserve to speed up, you can replace the new_cap with your guess
    stringv.reserve(10);

    std::string str;
    /*
     * while std::skipws tells the stream to skip all the white space before input, 
     * std::ifstream& operator >> (std::ifstream&, std::string&) will stop when a space is read.
     */
    while(in >> str)   
        stringv.push_back(std::move(str));
}

Edit:

I haven't tested this program yet, so there might be some compilation errors, but I am so sure that this method should works.

Using !in.eof() tests whether the eof is reached, but it doesn't test whether the extraction succeeds or not, which means you can get invalid data. in >> str fixs this because after the extraction the value of !in.fail() indicates whether the extraction from stream succeeds or not.

Answer 4

One of the simpler approaches would just start checking the ASCII of all each character that you are iterating on. If the ASCII value of the character is "20" (ASCII for SPACE) then skip it with "continue" otherwise just print it.