"Howard" <alicebt@hotmail.com> wrote in message
news:lftee.705876$w62.510623@bgtnsc05-news.ops.worldnet.att.net...[color=blue]
>
> "codigo" <codigo@codigo.trap.com> wrote in message
> news:Kwsee.6250$VL3.628014@news20.bellglobal.com.. .[color=green]
> >
> > "sam" <sam++@--.com> wrote in message[/color][/color]
news:d5db53$fro$1@news.hgc.com.hk...[color=blue][color=green][color=darkred]
> >> Hi,
> >>
> >> Can anyone tell me how to print a file name from ifstream?
> >>
> >> the following cout code does not print the filename I created with
> >> ifstream preivous:
> >>
> >> ifstream is;
> >> is.open ("text.txt");
> >>
> >> cout << "filename in ifstream: " << is << endl;
> >>
> >> Sam.[/color]
> >
> > That doesn't make sense. The only way a file name would find itself in[/color][/color]
an[color=blue][color=green]
> > ifstream is if the filename was read / parsed from the specified file.
> >[/color]
>
> Well, that's true, given the actual design of the filestream. But it's
> certainly *concievable* to envision a filestream class design that
> maintained the filename as a member which could be queried. Of course,[/color]
that[color=blue]
> would mean using something like "is.name", not just "is", but it's[/color]
possible.
Possible it certainly is, in fact its trivial. Would it be desireable,
probably not. The issue here is why provide access to a provided constant
string filename parameter? The OP can just as well pass a variable to the
ifstream and then manipulate the variable without bothering the ifstream or
object. I would think that efficiency is a primary concerns in the design of
such a mutating object.
[color=blue]
>[color=green]
> > Don't you think that the input file stream should jealously protect the
> > provided filename parameter from modification during file stream
> > processing
> > (even when the parameter is required to be a constant, such as in this
> > case)? Shouldn't this fact pop out as logicly obvious in any object that
> > is,
> > or will be, processing a stream?
> >
> > How would you feel if i was able to change your parachute to an umbrella
> > between the time you boarded the plane, jumped and hit the ground? Do[/color][/color]
you[color=blue][color=green]
> > beleive that a programmer doesn't have the responsability to protect[/color][/color]
that[color=blue][color=green]
> > parachute?
> >
> > Don't laugh. The consequences of not protecting the ifstream's parameter
> > would be worse. Not because the ifstream never gets to hit the ground,[/color][/color]
but[color=blue][color=green]
> > because the whole world that is in (the program) enters a state of
> > unexpected behaviour (UB).
> >[/color]
>
> Well, that's a bit over-dramatic, in my opinion. Nobody said anything[/color]
about[color=blue]
> changing the name while the stream is open, did they? And even if one[/color]
were[color=blue]
> able to attempt to change the variable while the file was open, that[/color]
doesn't[color=blue]
> mean that the world would come crashing down. It *might* screw up a given
> file system if the filename were changed while the file was open, but the[/color]
OS[color=blue]
> could (and likely does) forbid that anyway, which would mean that even if
> the filestream class allowed the attempt to change it, the actual action
> would fail in that instance, most likely with an exception of some sort,
> which it could catch as needed.
>
> -Howard
>[/color]
Which brings us back to the crux of the problem. I can understand checking a
file stream's error condition bits, but why a *supplied* parameter?
#include <iostream>
#include <fstream>
#include <string>
class FileStream
{
const std::string m_filename;
std::ifstream m_ifs;
std::string m_sdata;
public:
FileStream(std::string s) : m_filename(s), m_ifs(), m_sdata("") { }
~FileStream() { }
std::string getFilename() const
{
return m_filename;
}
const std::string getData()
{
m_ifs.open(m_filename.c_str());
if (!m_ifs)
{
m_sdata = "error opening file " + m_filename;
return m_sdata;
}
std::getline(m_ifs, m_sdata);
return m_sdata;
}
};
int main()
{
std::string s("data.dat");
FileStream fs(s);
std::cout << fs.getFilename() << std::endl;
std::cout << fs.getData();
return 0;
}
output:
data.dat
the only data string
whats wrong with...
int main()
{
std::string s("data.dat");
FileStream fs(s);
std::cout << s << std::endl;
std::cout << fs.getData();
return 0;
}
and forego having to provide the getFilename() member function?
