No Matching Function Error When Opening File

I have a function in a .h file designed to save some information to a file, but I get this error:

Code:

---

error: no matching function for call to `std::basic_fstream<char, std::char_traits<char> >::basic_fstream(std::string&, std::_Ios_Openmode)'

---

on this line:

Code:

---

fstream fbin(filename, ios::binary | ios::in | ios::out);

---

This is the full code of the function as well as the includes:

Code:

---

#include <fstream>
#include <iostream>

using namespace std;

...

void plant::writetofile(int pnum, string filename){
    fstream fbin(filename, ios::binary | ios::in | ios::out);
    if(!fbin){
              cout << "Error opening fbin";
              }
   
    int recsize = sizeof(int) + (sizeof(int) + sizeof(int) + sizeof(int))*2 + sizeof(string);
    fbin.seekp(pnum * recsize);
   
    fbin.write(reinterpret_cast<char*>(&name), sizeof(string));
   
    fbin.write(reinterpret_cast<char*>(waterd.getm()), sizeof(int));
    fbin.write(reinterpret_cast<char*>(waterd.getd()), sizeof(int));
    fbin.write(reinterpret_cast<char*>(waterd.gety()), sizeof(int));
   
    fbin.write(reinterpret_cast<char*>(aquired.getm()), sizeof(int));
    fbin.write(reinterpret_cast<char*>(aquired.getd()), sizeof(int));
    fbin.write(reinterpret_cast<char*>(aquired.gety()), sizeof(int));
   
    fbin.write(reinterpret_cast<char*>(&size), sizeof(int));
   
    fbin.close();
    return;
}

---

I have no idea why I am getting this error, since the line it is pointing to is fairly standard, I think.

Any idea?

Thanks!

You need to designate it an ifstream or ofstream, meaning Input and/or Output file stream.

The problem is that due to an oversight (or some other technicality) standard C++ does not allow you to pass a string as the filename to an fstream. You have to call the c_str() function to pass a const char*:

Code:

---

fstream fbin(filename.c_str(), ...

---

BTW, it looks like you're trying to write a string object out in binary. That won't work, because the string likely holds pointers to data outside the object (and for other reasons as well). Is there a reason you're using binary?

>> You need to designate it an ifstream or ofstream, meaning Input and/or Output file stream.
This is actually not true. An fstream will work fine.

Quote:

---

Originally Posted by Daved

This is actually not true. An fstream will work fine.

---

Really? I guess I learn something every day. I've tried fstream before also and got the same error. Changing it to if/ofstream fixed it and I never really thought twice about it. Thanks for clearing that up!

Thanks for the help. I got the error I was getting fixed.

Daved - The reason I am using binary rather than text is because, as I understand it, that is required for random access. If that is incorrect or if you know how I can get around the problem you described, that would be great. Of course, I cannot be sure that the problem you described is, well, a problem, since I have not yet gotten around to writing a way for the output file to be read. :-)

Also, (sorry for all the questions) even after I got the errors I originally posted about fixed (thanks again), there were still some errors, which I narrowed down to the lines with this basic format:

Code:

---

fbin.write(reinterpret_cast<char*>(waterd.getd()), sizeof(int));

---

I found that I can get around the errors by doing something like this:

Code:

---

int x = waterd.getd();
fbin.write(reinterpret_cast<char*>(&x), sizeof(int));

---

I am still curious why the first version did not work, though. Any explanation would be greatly appreciated.

Thanks so much!

In the first example, you're trying to cast waterd.getd(); in the second, you are trying to cast the address of waterd.getd() (or more specifically, the address where the result of the function call is stored).

tabstop - That makes sense, but then I should be able to add an & in front of waterd.getd() and it should work. Instead, when I do that I get this error:
non-lvalue in unary '&'

Thanks!

Quote:

---

but then I should be able to add an & in front of waterd.getd()

---

And what should be the result of it? I could not imagine

I think it is because there is no variable for the output of waterd.getd() to be assigned to, hence no memory location for it. Where the second has a location where the output was stored. I could be wrong, though.

No, there is memory for it. It would be a temporary.
How could something be returned if it isn't stored somewhere? It wouldn't exist.
The problem is a language-related one, not a machine-related one (it's a violation of how the language works).

OK. I wrote a read function. Everything works except for the name (the only string.) The name is just blank. I suspect this has to do with what Daved was talking about. Any idea how I can overcome this issue?

Thanks!

I don't know exactly what you're referring to, but...
Two things, then:

fbin.write(reinterpret_cast<char*>(&name), sizeof(string));
This is bad. Don't try to write a class in raw form. Instead just do fbin << name. The class will know how to store its data.
And if you wondered about

fbin.write(reinterpret_cast<char*>(waterd.getd()), sizeof(int));

Then you already found a solution (use a temporary variable to hold the result, then write).

Quote:

---

Originally Posted by Elysia

fbin.write(reinterpret_cast<char*>(&name), sizeof(string));
This is bad. Don't try to write a class in raw form. Instead just do fbin << name. The class will know how to store its data.

---

I changed my program to use that way of doing things. I had no idea that was possible. (Could I just do that with my plant class?)

Now the name has the correct name followed by a bunch of symbols and the integers are always the same....

Any ideas?

Thanks!

Quote:

---

Originally Posted by zephyrcat

I changed my program to use that way of doing things. I had no idea that was possible. (Could I just do that with my plant class?)

---

Indeed you can, with proper operator overloading.
If you've learned how to overload operators?
There was a similar discussion on how to achieve this in http://cboard.cprogramming.com/showt...8&goto=newpost

Code:

---

Now the name has the correct name followed by a bunch of symbols and the integers are always the same....

---

Do you need the file to be readable by humans?
If not, then you should ignore them, because most likely the class stored some more data, such as the length of the string or some such.
If you need to be able to read it without those symbols, then another, better way, might be to write the string itself (in const char* form), by doing fbin << name.c_str().

I don't need the file to be human readable, but I do need the program to be able to read it and display the information there in human readable form. Right now, when I use the readfromfile function that I wrote the program returns the name as the correct name followed by a bunch of random characters and the integers are always the same.

I will include both functions, in case the problem is the reading function.

Thanks!

Code:

---

void plant::readfromfile(int pnum, string filename){
    //cout << "Got to read from file function." << endl;
    fstream fbin(filename.c_str(), ios::binary | ios::in | ios::out);
    if(!fbin){
              cout << "Error opening fbin";
              }
    //cout << "Opened file." << endl;
   
    int recsize = sizeof(int) + (sizeof(int) + sizeof(int) + sizeof(int))*2 + sizeof(string);
    fbin.seekp(pnum * recsize);
    //cout << "Found place in file." << endl;
   
    fbin >> name;
    //fbin.read(reinterpret_cast<char*>(&name), sizeof(string)); //<-- old version
    //cout << "Read string from file." << endl;
   
    int m, d, y;
   
    fbin.read(reinterpret_cast<char*>(&m), sizeof(int));
    fbin.read(reinterpret_cast<char*>(&d), sizeof(int));
    fbin.read(reinterpret_cast<char*>(&y), sizeof(int));
    waterd.set(m,d,y);
   
    fbin.read(reinterpret_cast<char*>(&m), sizeof(int));
    fbin.read(reinterpret_cast<char*>(&d), sizeof(int));
    fbin.read(reinterpret_cast<char*>(&y), sizeof(int));
    aquired.set(m,d,y);
   
    //cout << "Read date info from file." << endl;
   
    fbin.read(reinterpret_cast<char*>(&size), sizeof(int));
    //cout << "Finished reading everything from file." << endl;
   
    fbin.close();
    //cout << "Leaving function." << endl;
    return;
}

---

Code:

---

void plant::writetofile(int pnum, string filename){
    //cout << "Got to write to file function." << endl;
    fstream fbin(filename.c_str(), ios::binary | ios::in | ios::out);
    if(!fbin){
              cout << "Error opening fbin";
              }
    //cout << "Opened file." << endl;
   
    int recsize = sizeof(int) + (sizeof(int) + sizeof(int) + sizeof(int))*2 + sizeof(string);
    fbin.seekp(pnum * recsize);
    //cout << "Found place in file." << endl;
   
    fbin << name; //<-- new version
    //fbin.write(reinterpret_cast<char*>(&name), sizeof(string)); //<-- old version
    //cout << "Wrote string to file." << endl;
   
    int x;
    x=waterd.getm();
    fbin.write(reinterpret_cast<char*>(&x), sizeof(int));
    x=waterd.getd();
    fbin.write(reinterpret_cast<char*>(&x), sizeof(int));
    x=waterd.gety();
    fbin.write(reinterpret_cast<char*>(&x), sizeof(int));
   
    x=aquired.getm();
    fbin.write(reinterpret_cast<char*>(&x), sizeof(int));
    x=aquired.getd();
    fbin.write(reinterpret_cast<char*>(&x), sizeof(int));
    x=aquired.gety();
    fbin.write(reinterpret_cast<char*>(&x), sizeof(int));
    //cout << "Wrote date info to file." << endl;
   
    fbin.write(reinterpret_cast<char*>(&size), sizeof(int));
    //cout << "Finished writing everything to file" << endl;
   
    fbin.close();
    //cout << "Leaving function" << endl;
    return;
}

---

You can't use sizeof(string) to determine the space needed on the file to store a string. You should use a fixed size space for that - there would be several different possible choices here, but you do need to use some method to define how large your string is.

Also, it is not absolutely necessary to use a fixed size record to be able to random access the file - however, if the records are NOT all the same size, then you would need some other way (such as an array of integer indicating "which record is where in the file").

--
Mats

>> The reason I am using binary rather than text is because, as I understand it, that is required for random access.

Your strings must have a fixed size for random access to work. Do you really need random access? If you're not sure or you don't really need it, then don't use binary i/o, use text based i/o with the stream operators << and >>.

If you absolutely need random access, then you must use fixed size strings. For that, I'd stop using the string class and instead use a character array of a fixed size. They are not as easy to use as the string class, but are necessary for fixed record length i/o that you pretty much have to have for random access in the file.

OK. Could I just convert between string and char array before/after writing/reading to the file? If I can, how can I convert a char array to a string?

Thanks!

Just pass it to a string constructor.
std::string s = mychararray;

>> Could I just convert between string and char array before/after writing/reading to the file? If I can, how can I convert a char array to a string?

You could do this only if you forced the strings to be a certain size (or smaller). However, it may make more sense to store character arrays in your struct if you have one and do the conversion when storing the data rather than when writing it and reading it.

To convert a character array to string (after reading) just assign it.

To convert a string to a character array (before writing) use strcpy or strncpy:

Code:

---

const int MAX_NAME_LEN = 100;

// ensure name is small enough to fit. There are other ways to do this, but this one works.
name.resize(MAX_NAME_LEN-1);

char namebuf[MAX_NAME_LEN];
strcpy(namebuf, name.c_str());

---