opening and reading a file whose name is given at runtime

My problem is how to use correctly the function infile.open().

I have a class that, among the others, has the following public properties:

class myclass {
public:
int rows
int columns
const char* array_file
}

All values are given at run-time.

When I call the function that uses a member of the class I have (pt is a pointer to a member of the class)

#include <vector>
#include <fstream>
#include <iostream>
typedef std::vector< std::vector<int> > Matrixint;

void function(myclass* pt) { 
    Matrixint array_name(pt->rows, std::vector<int>(pt->columns));

    std::ifstream infi开发者_运维问答le;

    infile.open("%s", pt->array_file); // my problem: is this correct?
    for (int a = 0; a < pt->rows; a++) {
         for (int b = 0; b < pt->columns; b++) {
               infile >> array_name[a][b] ;
         }
    }
    infile.close();

}

Is this way of opening/reading the file correct?

The data in the file will be formatted as in this question (please note: only the array will be present in the file, no other data)

infile.open gets as its first parameter the filename:

void open ( const char * filename, ios_base::openmode mode = ios_base::in );

(source)

I don't know what your filename is but maybe something like this (just a guess based on variable types) could do:

infile.open(pt->array_file); 

of course you have to ensure that the filename you pass in is correct at the time of calling that function.

Assuming that my psychic abilities for fixing your question's code were right, I'd write it like this:

struct mine {
    int rows
    int columns
    std::string array_file
}

void function(const mine& m) { 
    Matrixint array_name(pt->rows, std::vector<int>(pt->columns));

    std::ifstream infile(m.array_file.c_str());

    for (int a = 0; a < ls->rows && infile.good(); ++a) {
         for (int b = 0; b < ls->columns && infile.good(); ++b) {
               infile >> array_name[a][b] ;
         }
    }

    if(!infile) 
        throw "Uh oh!"; // assume real error handling here
}

Why have I changed all these things?

• A class with all public data isn't a class, but an aggregation of data. I'd use a struct for that, to not to confuse those who later need to maintain my code. (That might include me a few years down the road, which is a strong incentive to be very helpful.)
• Unless you know exactly what you're doing (which doesn't seem to be the case), you should be using std::string rather than C-style strings.
• Why pass the function parameter by pointer, when you can use a const reference?
• std::ifstream has a constructor with which you can open a file immediately. I rarely ever use (or see used) its open() member function.
• You need to test whether the file was opened and whether the input operations succeeded. (In this case, I merged the test whether it could be opened with the input operation succeed test, since the for loop is a pre-testing loop.) After the operations, I check whether an error occurred. Alternatively you could break out of the loop with an exception when reading fails.
• Usually there is no need to close a stream, since its destructor already does this. If you make your variables as local as possible (which is good programming praxis), the file will be closed right away nevertheless.