C++ read from file failing - g++11 - Ubuntu14

Question

sorry for having to ask such a trivial question here, but I have to admit I can't think the reason that's causing my program to behave this way.

Here's the problem;

I'm trying to read from a file which has 32 lines with each line containing a 32-bit long binary number.

I've got a string array of size 32 and I'm trying to store each number from the file in it. It seems straight forward to me but then when I get to the line that tests getline() it jumps to the else bit and ouputs my error message. Initially it was working fine on eclipse but not from the terminal, I thought it had something to do with the permissions so I changed them all to rwx to no avail. I even tried changing the name but that caused the program to not work even in eclipse and now even going back to the original name doesn't work !!

I would appreciate if anyone can shed a light on the problem for me. Ta!

Edit: Thank you guys for helping me investigate the problem, so far the file seems to be read just fine, I've got a cout statement in my main function to print the second element of the vector in which data is stored (after being read from the file) and it prints fine, in eclipse that is!! .When I compile the same code from the terminal and then run a.out it simply doesn't output anything.

I decided I would include my entire code and hope this will be more helpful.

Here's a quick recap to the questions I was asked: -The file is just a simple text file that contains lines of 1's and 0's here's what it looks like

00000000000000000000000000000000
11100000000000100000000000000000
00010000000000010000000000000000
10010000000001100000000000000000
10010000000000100000000000000000
10010000000001100000000000000000
00000000000001110000000000000000
10000000001000000000000000000000
10110110010000000000000000000000
00000000000000000000000000000000

I've got a cpp file with it's corresponding header like this:

#ifndef MANCHESTER_H_
#define MANCHESTER_H_

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

using namespace std;

class Manchester {
private:


    struct Processor
    {
        enum operation { JMP,JRP,LDN,STO,SUB,CMP,STP };
        char accumulator[32]; // holds results of arithmetic operations.
        char controlInstruction[32];  // program counter.holds the address of an instruction.
        char presentInstruction[32]; //contains the actual instruction fetched and being executed.
    };
    Processor processor;


public:
    vector<string> store;
    int static const size = 32;
    Manchester();
    ~Manchester();

    void copyFromFileToStore();
    string decToBinary(int );
    int binToDecimal(string s);
    string getInstruction(int lineNumber);
    string getOperand(int lineNumber);
};

#endif /* MANCHESTER_H_ */

Here's the .cpp file

#include "Manchester.h"

Manchester::Manchester()
{
    copyFromFileToStore(); // load the program in the store.
}

Manchester::~Manchester() {}

void Manchester::copyFromFileToStore()
{
    ifstream myfile;
    myfile.open("BabyTest1-MC.txt");

    if (!myfile.is_open())
    {
        cout << "Cannot read file!" << endl;
    }
    else
    {
        int i =0;
        while( i < 10)
        {
            string line;
            if (getline(myfile,line))
            {
                store.push_back(line);
                i++;
            }
            else
            {
                cout << "Error while reading file!" << endl;  // always outputs when running the code.
                return;
            }
        }
        myfile.close();
    }
}

string Manchester::decToBinary(int number)
{
    string converted="";
    char holder;
    do
    {
        holder = number % 2 + '0';
        converted = holder + converted;
        number = number /2;

    }while (number != 0);


    string filler = "";
    int stringsize = converted.size();
    int diff = (8 - stringsize);

    if (diff > 0)
    {
        for (int i = 0; i < diff; i++)

            filler = filler + '0';
    }
    converted = filler + converted;
    return converted;
}
int Manchester::binToDecimal(string s)
{
    int converted =0;
    int power = 0;
    for (int i = s.size()-1; i >= 0; --i)
    {
        converted += (s[i] - '0') * pow(2, power);
        power++;
    }
    return converted;
}

And finally the file containing the main():

#include "Manchester.h"



int main()
{
    Manchester baby;

    cout << baby.store.at(1);

    return 0;
}

These the original parts that I posted that I didn't want to delete:

string store[32];
ifstream myfile;
myfile.open("BabyTest1-MC.txt");

if (!myfile.is_open())
{
    cout << "Cannot read file!" << endl;
}
else
{
    int i =0;
    while( i < 32)
    {
        if (getline(myfile,store[i]))
        {
            i++;
        }
        else
        {
            cout << "Error while reading file!" << endl;  // always outputs when running the code.
            return;
        }
    }
    myfile.close();
}

Sorry I'm editing to show you what works on eclipse but not from the terminal!!! I simply don't understand the behaviour !!!

string store[32];
ifstream myfile;
myfile.open("BabyTest1-MC.txt");

if (!myfile.is_open())
{
    cout << "Cannot read file!" << endl;
}
else
{
    int i =0;
    while( i < 32)
    {
        getline(myfile,store[i]);
        i++;
    }
    myfile.close();
}

Answer 1

Why don't you use a std::vector<std::string>, and push_back() to populate it?

std::vector<std::string> store;

// ...

while(i < 32) {
    std::string line;
    if (getline(myfile,line)) {
        store.push_back(line);
        i++;
    }
    // ...
 }

Answer 2

What about:

string store[32];
ifstream myfile;
int i;

myfile.open("filename.txt");

if (!myfile.is_open())
{
    cout << "Cannot read file!" << endl;
}
else
{
    for (i = 0; i < 32; i++)
    {
        if (!getline(myfile, store[i]))
        {
            cout << "Error while reading file!" << endl;  // always outputs when running the code.
            return 0;
        }
    }
    myfile.close();
}

Tested it and it was working for me. This way the for loop automatically increment you variable and if for some strange reason the program reaches the end of the file, it will display your error message.

Answer 3

I got some help from one of the guys at university and we figured what the problem was !! It was to do with the endline characters. I'm working on linux which uses \n as the endline character but the file I'm trying to read was built on Windows which of course has \r\n as the endline character! Eclipse seems to be accepting both versions of end of line but not bash!

I edited my code to get rid of those characters altogether before storing them in the vector and it now works fine.

Sorry for the trouble caused in here and hope this will at least remind beginners that there is a difference between files built on windows, mac and linux !! and that attention needs to be made when working with different files !!

void Manchester::copyFromFileToStore()
{
    ifstream myfile;
    myfile.open("BabyTest1-MC.txt");

    if (!myfile.is_open())
    {
        cout << "Cannot read file!" << endl;
    }
    else
    {
        int i =0;

        string line;
        while(getline(myfile,line))
        {
            line.erase(std::remove(line.begin(), line.end(), '\r'), line.end());
            line.erase(std::remove(line.begin(), line.end(), '\n'), line.end());
            store.push_back(line);
            i++;
        }
        myfile.close();
    }
}