Help with simple file I/O :)

[Kush]

Hello All,

I am having problem writing some data to file and I do not understand
my mistake / misconception.
I am trying to write some simple text to file but the text is rather
output to screen!

Below is my entire code from my problem, but I just want to focus on
the method "write_percenta ge_per_side_to_ file(ofstream &os)". From my
understanding I am passing an ofstream object which I declared in main(
) as "ofstream os = ("C:\\output.tx t", ios::out);" into this method,
and since I declared this as an output stream object, that using:

os << "Text"

Would write this to the filename I specified in my declaration of "os".

Any help is appreciated!

Cheers,

Kush

----------------------------------------------------------------------------------------------------------------------------------------
#include <iostream.h>
#include <math.h>
#include <fstream.h>

//*************** *************** *************** ***********Clas s
definitions
class coordinate
{
private:
int x, y;
public:
void initialize(int a, int b);
int provide_x_coord inate(void);
int provide_y_coord inate(void);
};

class side
{
private:
coordinate left_side, right_side;
public:
void initialize(int ax, int ay, int bx, int by);
double length(void);
};

class property
{
private:
side side1, side2, side3, side4;
double perimeter(void) ;
public:
void initialize(void );
void write_percentag e_per_side_to_f ile(ofstream &os);
};

//*************** *************** *************** ***********coor dinate
void coordinate::ini tialize(int a, int b)
{
x = a;
y = b;
}

int coordinate::pro vide_x_coordina te(void)
{
return x;
}

int coordinate::pro vide_y_coordina te(void)
{
return y;
}

//*************** *************** *************** ***********side
void side::initializ e(int ax, int ay, int bx, int by)
{
left_side.initi alize(ax, ay);
right_side.init ialize(bx, by);
}

double side::length(vo id)
{
int left_x, left_y, right_x, right_y;

left_x = left_side.provi de_x_coordinate ();
left_y = left_side.provi de_y_coordinate ();
right_x = right_side.prov ide_x_coordinat e();
right_y = right_side.prov ide_y_coordinat e();

return ( sqrt( ((right_x - left_x) * (right_x - left_x)) + ((right_y -
left_y) * (right_y - left_y)) ) );
}

//*************** *************** *************** ***********prop erty
void property::initi alize(void)
{
side1.initializ e(1, 6, 10, 10);
side2.initializ e(10, 10, 36, 4);
side3.initializ e(36, 4, 0, 0);
side4.initializ e(0, 0, 1, 6);
}

double property::perim eter(void)
{
return (side1.length() + side2.length() + side3.length() +
side4.length() );
}

void property::write _percentage_per _side_to_file(o fstream &os)
{
os << "The percentage length of side1 relative to the perimeter is "
<< (side1.length() / perimeter() ) * 100 << endl
<< "The percentage length of side2 relative to the perimeter is " <<
(side2.length() / perimeter() ) * 100 << endl
<< "The percentage length of side3 relative to the perimeter is " <<
(side3.length() / perimeter() ) * 100 << endl
<< "The percentage length of side4 relative to the perimeter is " <<
(side4.length() / perimeter() ) * 100 << endl;
os.close();
}

//*************** *************** *************** ***********main ()

void main(void)
{
property lot;
lot.initialize( );
ofstream os = ("C:\\output.tx t", ios::out);
lot.write_perce ntage_per_side_ to_file(os);
}
//*************** *************** *************** ***********end of program

[Salt_Peter]

Kush wrote:

Hello All,

I am having problem writing some data to file and I do not understand
my mistake / misconception.
I am trying to write some simple text to file but the text is rather
output to screen!

Below is my entire code from my problem, but I just want to focus on
the method "write_percenta ge_per_side_to_ file(ofstream &os)". From my
understanding I am passing an ofstream object which I declared in main(
) as "ofstream os = ("C:\\output.tx t", ios::out);" into this method,
and since I declared this as an output stream object, that using:

os << "Text"

Would write this to the filename I specified in my declaration of "os".

Any help is appreciated!

Cheers,

Kush

----------------------------------------------------------------------------------------------------------------------------------------
#include <iostream.h>
#include <math.h>
#include <fstream.h>

#include <iostream>
#include <cmath>
#include <fstream>

>
//*************** *************** *************** ***********Clas s
definitions
class coordinate
{
private:
int x, y;
public:
void initialize(int a, int b);
int provide_x_coord inate(void);
int provide_y_coord inate(void);
};

class coordinate
{
int x, y;
public:
coordinate(int a, int b);
int getx() const;
int gety() const;
};

>
class side
{
private:
coordinate left_side, right_side;
public:
void initialize(int ax, int ay, int bx, int by);
double length(void);
};

class side
{
coordinate left_side, right_side;
public:
side(int ax, int ay, int bx, int by);
side(const coordinate& ls, const coordiante& rs);
double length() const;
}

>
class property
{
private:
side side1, side2, side3, side4;
double perimeter(void) ;
public:
void initialize(void );
void write_percentag e_per_side_to_f ile(ofstream &os);
};

//*************** *************** *************** ***********coor dinate
void coordinate::ini tialize(int a, int b)
{
x = a;
y = b;
}

coordinate::coo rdinate(int a, int b) : x(a), y(b)
{
}

>
int coordinate::pro vide_x_coordina te(void)
{
return x;
}

int coordinate::get x() const
{
return x;
}

>
int coordinate::pro vide_y_coordina te(void)
{
return y;
}

//*************** *************** *************** ***********side
void side::initializ e(int ax, int ay, int bx, int by)
{
left_side.initi alize(ax, ay);
right_side.init ialize(bx, by);
}

again, use ctor. Why? Because there are more ctors than meet the eye:
def ctor, parametized ctor, copy ctor and assignment operator - which
itself is not a ctor. If you don't write the default ctors and op=, the
compiler must generate them anyways. And the compiler will not default
initialize members unless you tell it to.

>
double side::length(vo id)
{
int left_x, left_y, right_x, right_y;

left_x = left_side.provi de_x_coordinate ();
left_y = left_side.provi de_y_coordinate ();
right_x = right_side.prov ide_x_coordinat e();
right_y = right_side.prov ide_y_coordinat e();

return ( sqrt( ((right_x - left_x) * (right_x - left_x)) + ((right_y -
left_y) * (right_y - left_y)) ) );
}

//*************** *************** *************** ***********prop erty
void property::initi alize(void)
{
side1.initializ e(1, 6, 10, 10);
side2.initializ e(10, 10, 36, 4);
side3.initializ e(36, 4, 0, 0);
side4.initializ e(0, 0, 1, 6);
}

double property::perim eter(void)
{
return (side1.length() + side2.length() + side3.length() +
side4.length() );
}

void property::write _percentage_per _side_to_file(o fstream &os)

You should be passing the std::ofstream by std::ostream reference:
void property::write _percentage_per _side_to_file(s td::ostream &os)

{
os << "The percentage length of side1 relative to the perimeter is "
<< (side1.length() / perimeter() ) * 100 << endl
<< "The percentage length of side2 relative to the perimeter is " <<
(side2.length() / perimeter() ) * 100 << endl
<< "The percentage length of side3 relative to the perimeter is " <<
(side3.length() / perimeter() ) * 100 << endl
<< "The percentage length of side4 relative to the perimeter is " <<
(side4.length() / perimeter() ) * 100 << endl;
os.close();
}

//*************** *************** *************** ***********main ()

void main(void)
{
property lot;
lot.initialize( );
ofstream os = ("C:\\output.tx t", ios::out);

Where is the error checking? How do you what, if anything, failed?

std::ofstream ofs;
ofs.open("C:\\o utput.txt");
if(!ofs || !ofs.is_open() )
{
std::cerr << "error while opening file for output.\n";
return -1;
}

lot.write_perce ntage_per_side_ to_file(os);
}
//*************** *************** *************** ***********end of program

[James Willmott]

Salt_Peter wrote:

coordinate::coo rdinate(int a, int b) : x(a), y(b)

What is this construct doing? I haven't seen a function defined like
this before.

Thanks,

jw.

[Salt_Peter]

James Willmott wrote:

Salt_Peter wrote:

coordinate::coo rdinate(int a, int b) : x(a), y(b)

What is this construct doing? I haven't seen a function defined like
this before.

Coders who consider pointers to be friends have few acquaintances.

Thanks,

jw.

Its constructing an instance of coordinate using an "init list" with a
and b as parameters to initialize the x and y members. Very fundamental
in C++ and usefull since the ctor does not need to allocate the 2
integers and *then* initialize their values. allocation +
initialization is simultaneously carried out.

Set a breakpoint in the ctors and watch the members x and y:

#include <iostream>

class coordinate
{
int x, y;
public:
// def ctor + init list
coordinate() : x(0), y(0)
{
std::cout << "coordinate()\n ";
}
// parametized ctor + init list
coordinate(int a, int b) : x(a), y(b)
{
std::cout << "ctor coordinate(int, int)\n";
}
// copy ctor
coordinate(cons t coordinate& copy)
{
std::cout << "copy ctor coordinate\n";
x = copy.x;
y = copy.y;
}
};

int main()
{
coordinate coord; // def ctor invoked
coordinate another(99,11); // parametized ctor invoked
coordinate coord2(coord); // copy ctor invoked
coordinate coord3 = another; // also a copy since
}

/* output:
coordinate()
ctor coordinate(int, int)
copy ctor coordinate
copy ctor coordinate
*/

Can you see why this is usefull? Its absolutely impossible to create an
instance of coordinate where x and y are left un-initialized by
mistake. Say goodbye to bugs, thanks to the creator of the class.
Next: assignment operator.

By the way, other languages also have the compiler provide default
ctors, they just don't tell you about it nor give you access to them.
C++ takes a different view, ctors are one of its cornerstones.

[Kai-Uwe Bux]

James Willmott wrote:

Salt_Peter wrote:

>coordinate::co ordinate(int a, int b) : x(a), y(b)

You forgot to quote the empty body:
{
}

>
What is this construct doing? I haven't seen a function defined like
this before.

It's a constructor using an initializer list. Are you sure you never saw
that? It should be explained in any book on C++.
Best

Kai-Uwe Bux

[James Willmott]

Kai-Uwe Bux wrote:

James Willmott wrote:

>>Salt_Peter wrote:

>>>coordinate:: coordinate(int a, int b) : x(a), y(b)

You forgot to quote the empty body:
{
}

>>What is this construct doing? I haven't seen a function defined like
this before.

It's a constructor using an initializer list. Are you sure you never saw
that? It should be explained in any book on C++.

My C++ book doesn't even have namespaces in it.

I've never heard of initialiser lists, but now that I know what they're
called I can research them more myself. :)

Thanks,
jw.

[James Willmott]

Kai-Uwe Bux wrote:

James Willmott wrote:

>>Salt_Peter wrote:
coordinate::c oordinate(int a, int b) : x(a), y(b)

{
}

What's the benefit of doing that versus...

coordinate::coo rdinate(int a, int b){
x=a;
y=b;
}

They seem to have the same end result at first glance?

>>What is this construct doing? I haven't seen a function defined like
this before.

It's a constructor using an initializer list. Are you sure you never saw
that? It should be explained in any book on C++.

My C++ book doesn't even have namespaces in it. :)

I've never heard of initialiser lists, but now that I know what they're
called I can research them more myself.

Thanks,
jw.

[Emmanuel Deloget]

James Willmott a écrit :

Kai-Uwe Bux wrote:

James Willmott wrote:

>Salt_Peter wrote:
coordinate::co ordinate(int a, int b) : x(a), y(b)

{
}

What's the benefit of doing that versus...

coordinate::coo rdinate(int a, int b){
x=a;
y=b;
}

They seem to have the same end result at first glance?

But they don't work in the same way. The version with the initializer
list constructs x and y with the corresponding values, while the second
version construct them, then assign the value. While this is not very
important for simple types, it can make a huge difference for more
complex type where both the construction and the code for operator=()
is slower. This is also the only way to construct sub objects that
doesn't have a default constructor, or to assign references. For
instance:

class C
{
int& a;
public:
C(int val)
{
a = val;
}
};

Doesn't work, because the reference requires to be initialized before
you enter in the constructor body. You have to use a initializer list
in this case.

>What is this construct doing? I haven't seen a function defined like
this before.

Of course you did: if class B inherit class A, how does B call the
constructor of A?

My C++ book doesn't even have namespaces in it. :)

I really suggest you to pick another book then :)

Regards,

-- Emmanuel Deloget, Artware

[Earl Purple]

James Willmott wrote:

Kai-Uwe Bux wrote:

James Willmott wrote:

>Salt_Peter wrote:
coordinate::co ordinate(int a, int b) : x(a), y(b)

{
}

What's the benefit of doing that versus...

coordinate::coo rdinate(int a, int b){
x=a;
y=b;
}

They seem to have the same end result at first glance?

May I suggest that you "FAQ off" .. well go and read this and the rest
of the FAQ because you'll learn a lot from it.

http://www.parashift.com/c++-faq-lit....html#faq-10.6

[James Willmott]

Emmanuel Deloget wrote:

>>What's the benefit of doing that versus...

coordinate::c oordinate(int a, int b){
x=a;
y=b;
}

They seem to have the same end result at first glance?

But they don't work in the same way. The version with the initializer
list constructs x and y with the corresponding values, while the second
version construct them, then assign the value. While this is not very
important for simple types, it can make a huge difference for more
complex type where both the construction and the code for operator=()
is slower. This is also the only way to construct sub objects that
doesn't have a default constructor, or to assign references. For
instance:

class C
{
int& a;
public:
C(int val)
{
a = val;
}
};

Doesn't work, because the reference requires to be initialized before
you enter in the constructor body. You have to use a initializer list
in this case.

class C
{
int& a;
public:
C(int val) : a(val)
{
}
};

Like this then?

>>>>What is this construct doing? I haven't seen a function defined like
this before.

Of course you did: if class B inherit class A, how does B call the
constructor of A?

Ok, yes I did, but I didn't recognise it as such.

>>My C++ book doesn't even have namespaces in it. :)

I really suggest you to pick another book then :)

I intend to.

Thanks,

jw.