yashwant pinge wrote:
#include<iostream>
using namespace std;
template<class T, int size=100>
class Array
{
T array[size];
public:
T& operator [](int index)
{
return array[index];
}
Often you would also want a
const T& operator[](int) const
too.
int length() const
{
return size;
}
};
class Number
{
float f;
public:
Number(float ff=0.0f):f(ff)
{
}
Number& operator =(const Number& n)
{
f=n.f;
return *this;
}
This operator=() would be written by the compiler if you hadn't written
it yourself.
operator float const()
Why not
operator float() const
?
{
return f;
}
friend ostream& operator <<(ostream& os,const Number& x)
{
return os << x.f;
}
};
template<class T,int size=2>
class Holder
{
Array<T,size>*np;
public:
Holder():np(0)
{
}
T& operator [](int i)
{
if(!np) np = new Array<T,size>;
return np ->operator[](i);
}
int length() const
{
return size;
}
~Holder()
{
delete np;
}
You should take care. The compiler will generate
Holder(const Holder& other) : np(other.np) {}
and
Holder& operator=(const Holder& other) { np = other.np; }
If one of these are invoked, you would delete np twice. In addition, the
assignment operator is bound to leak memory. Remember the rule of three:
A class with any of {destructor, assignment operator, copy constructor}
generally needs all 3.
};
int main()
{
Holder<Number> h;
invokes Holder<Number>::Holder().
for(int i=0;i<2;i++)
h[i]=i; // why the number constructor
called ...?
h[i] calls Holder<Number>::operator[](int). The first time this
executes, !np is false, and an Array<Number, 2> is default constructed.
This creates an array of size 2 of Number, which constructs these two
numbers with Number::Number(0.0f), since this is the default constructor
of number.
Holder<Number>::operator[](int) then returns a reference to a Number
object. This number is assigned to, which means a call to
Number::operator=(const Number&), which is the only assignment operator
defined. This assignment operator can use a temporary Number object, and
this is constructed by first converting i to a float, and then using this
float as an argument to Number::Number(float). That is:
h[i] = i;
means
h.operator[](i).operator=(Number(float(i)))
for(int j=0;j<2;j++)
cout<<h[j]<<endl;
return 0;
}
Why the number constructor is called during the execution of line
" h[i]=i;"
--
rbh