Re: initial value of reference to non-const must be an lvalue
asm23 wrote:
[SNIP]
Thanks for your reply. And Thanks for pointing out some mistakes in
my code. Now, I have change the whole code to standard type, which I
use namespaces. ALL works very well And NO "initial value ....." warnings
any more.
Just some further comments on your code.
#include <iostream>
using namespace std;
This is generally frowned up except for the most trivial of programs. It is
a quick way to not have to worry about namespaces, but once you start
getting more complicated programs it can cause problems. using namespace
std; brings everything in std into the unnamed namespace. For trivial
programs this is usually not an issue, but sooner or later you're going to
wind up using some code you download somewhere where someing in their code
decided to make a structure called string, which will now conflict with
std::string. or list. or vector. or map...
My solution: never use "using..." at all. I always preeceed the namespace
whre used. I.E. I would code the line as:
friend std::ostream& operator<<( std::ostream&, complex& );
Another good solution: only bring into the unnamed namespace the things you
need from std.
using std::ostream;
"using namespace std;" is not wrong, per se, it's just generally not
considered the best practice. And it should never be used in a header.
class complex {
double re, im; //Private members of class
Okay, you have a commant stating that these are private members. So you're
using 27+ characters to comment something out that you might as well
document much better by preceeding htis line with:
private:
I.E.
class complex {
private:
double re, im;
Yes, it is not needed. But it documents your code with code and you no
longer need the comment.
public:
complex() { re=0.0; im=0.0; } //Empty Constructor
Sooner or later you are going to have to learn about initialization lists,
and sooner is probably better than later. Some things can only be
initialized in initialization lists (base classes, references, etc...)
Using an initilaization list the above would become:
complex(): re(0.0), im(0.0) {};
It takes a little getting used to and at first looks weird as heck, but
after you finally get used to it it becomes natural. It's also a bit more
effecient although for trivial types such as double you won't notice a
difference, for some large class with heavy constructors and assignment
operators you probabably would.
complex(double r, double i=0.0) //Constructor from 2 doubles
{ re=r; im=i; }
Same comment about the initializastion list. However. You have 2
constructors that you can use by three differet ways: I.E.
complex();
complex( 1.0 );
complex ( 1.0, 2.0 );
but why use 2 when you can accomplish the same thing in one constructor?
complex( double r = 0.0, double i = 0.0 ): re(r), im(i) {}
which will support no paramters, one parameter or two parameters and do the
exact same thing as your two constructors.
friend ostream& operator<<(ostream&, complex&);
friend inline complex operator+(complex, complex);
};
inline complex operator+(complex a1, complex a2) //Add 2 complex
numbers {
return complex(a1.re+a2.re, a1.im+a2.im);
}
ostream& operator<<(ostream& os, complex & cnum) //Output a complex
number
{
os << "(" << cnum.re << "," << cnum.im << ") "; return os;
}
int main(void)
In C++ this would be written as
int main()
void is generally not used in C++ to indicate no parameters, an empty
parameter list is. Again, it's not wrong to use void, just not considered
the best practice.
{
complex a(1,2), b(3,4); //Define complex numbers
complex c=a+b;
cout << c << endl; //Print sum
int a1=2;
int b1=3;
cout<<a1+b1 <<endl;
return 0;
}
//----------------------------------------------------------------
--
Jim Langston
tazmaster@rocketmail.com