How can I achieve this behaviour?

[JKop]

class Cow
{
public:

void EatGrass() const {}
};

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}
};

int main()
{
Brow k;

k.EatGrass();
}
Is there any way I can achieve the above, whereby a Brow is implicitly
converted to a Cow? Here would be another example:

class Blah
{
private:

double a;

public:

operator double&()
{
return a;
}
};
int main()
{
Blah jk;

jk = 52.0;
}
-JKop

[Jonathan Turkanis]

"JKop" <NU**@NULL.NULL > wrote in message
news:W1******** **********@news .indigo.ie...

class Cow
{
public:

void EatGrass() const {}
};

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}
};

int main()
{
Brow k;

k.EatGrass();
}
Is there any way I can achieve the above, whereby a Brow is implicitly
converted to a Cow?

Yes:

class Brow
{
private:

Cow cow;

public:

Cow& operator. ()
{
return cow;
}
};

:-)

Seriously .. this is a reasona to prefer non-member functions to member
functions.

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}

operator const Cow&() const
{
return cow;
}
};

void EatGrass(const Cow&);

Jonathan

[JKop]

Jonathan Turkanis posted:

"JKop" <NU**@NULL.NULL > wrote in message
news:W1******** **********@news .indigo.ie...

class Cow
{
public:

void EatGrass() const {} };

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow; } };

int main()
{
Brow k;

k.EatGrass();
}
Is there any way I can achieve the above, whereby a Brow is implicitly
converted to a Cow?

Yes:

class Brow
{
private:

Cow cow;

public:

Cow& operator. ()
{
return cow;
}
};

:-)

By golly I love it!

So now we can do the following:

void SomeFunc(Cow& k);

int main()
{
Brow t;

SomeFunc(t); //operator Cow&
}

Plus we can access it's members:

int main()
{
Brow t;

t.EatGrass();
}

The only thing left is to access its operators:

int main()
{
Brow t;

t = 6;

//Assuming Cow has an assignment operator
}

Is there any easy way to do this, other than rhyming them all off:

class Brow
{
private:

Cow f;

public:

operator==(cons t Cow& r)
{
return f == r;
}

operator*(const Cow& r)
{
return f * r;
}
};

Templates would be required to get in all the operators and variable
argument types.
-JKop

[JKop]

For christ's sake it won't compile. You can't overload "."!

-JKop

[Ioannis Vranos]

Jonathan Turkanis wrote:

Yes:

class Brow
{
private:

Cow cow;

public:

Cow& operator. ()
{
return cow;
}
};

:-)

Seriously .. this is a reasona to prefer non-member functions to member
functions.

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}

operator const Cow&() const
{
return cow;
}
};

void EatGrass(const Cow&);

However constructors should be preferred when another class has to be
made compatible with the current class, and operator types() when our
current class has to become compatible with another class, of which we
have no access to its definition.


Regards,

Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

JKop wrote:

You can't overload "."!

Yes you can't. But I think the first one he provided was a joke.


Regards,

Ioannis Vranos

http://www23.brinkster.com/noicys

[Jonathan Turkanis]

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message
news:ch******** ***@ulysses.noc .ntua.gr...

Jonathan Turkanis wrote:

Yes:

class Brow
{
private:

Cow cow;

public:

Cow& operator. ()
{
return cow;
}
};

:-)

Seriously .. this is a reasona to prefer non-member functions to member
functions.

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}

operator const Cow&() const
{
return cow;
}
};

void EatGrass(const Cow&);

However constructors should be preferred when another class has to be
made compatible with the current class, and operator types() when our
current class has to become compatible with another class, of which we
have no access to its definition.

I was thinking of Cow as the class to which we didn't have access. We can still
define Brow as above, and

void EatGrass(const Cow& cow) { cow.EatGrass(); }

Jonathan

[Jonathan Turkanis]

"Ioannis Vranos" <iv*@guesswh.at .grad.com> wrote in message
news:ch******** ***@ulysses.noc .ntua.gr...

JKop wrote:

You can't overload "."!

Yes you can't. But I think the first one he provided was a joke.

Right. Maybe I should have used a different smiley: :-D ???

Jonathan

[PKH]

"JKop" <NU**@NULL.NULL > wrote in message
news:W1******** **********@news .indigo.ie...

class Cow
{
public:

void EatGrass() const {}
};

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}
};

int main()
{
Brow k;

k.EatGrass();
}
Is there any way I can achieve the above, whereby a Brow is implicitly
converted to a Cow? Here would be another example:

class Blah
{
private:

double a;

public:

operator double&()
{
return a;
}
};
int main()
{
Blah jk;

jk = 52.0;
}
-JKop

You could also use a ClassID approach like this :
( a bit more code than the other suggestions, but quite powerful)

typedef char ClassID;

class CClassIDBase
{
public:
static ClassID
m_cClassID;

virtual CClassIDBase* RequestClass(co nst ClassID& c)
{
return (&c == &m_cClassID) ? this : NULL;
}
};
class CCow : public CClassIDBase
{
public:
static ClassID
m_cClassID;

public:
void EatGrass(){}
virtual CClassIDBase* RequestClass(co nst ClassID& c)
{
return (&c == &m_cClassID) ? this : CClassIDBase::R equestClass(c);
}
};
class CBrow : CClassIDBase
{
public:
static ClassID
m_cClassID;

CCow
m_cCow;

public:
virtual CClassIDBase* RequestClass(co nst ClassID& c)
{
if (&c == &CCow::m_cClass ID)
{
return &m_cCow;
}
else
{
return (&c == &m_cClassID) ? this : CClassIDBase::R equestClass(c);
}
}
};
ClassID
CClassIDBase::m _cClassID = 0,
CCow::m_cClassI D = 0,
CBrow::m_cClass ID = 0;
int main(int argc, char* argv[])
{
CCow
*pcCow;

CBrow
cBrow;

if ((pcCow = (CCow*)cBrow.Re questClass(CCow ::m_cClassID)) != NULL)
{
pcCow->EatGrass();
}

return 0;
}

[Alf P. Steinbach]

* JKop:

class Cow
{
public:

void EatGrass() const {}
};

class Brow
{
private:

Cow cow;

public:

operator Cow&()
{
return cow;
}
};

int main()
{
Brow k;

k.EatGrass();
}
Is there any way I can achieve the above, whereby a Brow is implicitly
converted to a Cow?
Very simple, derive Brow from Cow:

class Brow: public Cow
{
};
Here would be another example:

class Blah
{
private:

double a;

public:

operator double&()
{
return a;
}
};
int main()
{
Blah jk;

jk = 52.0;
}

Give class Blah an assignment operator (which implies also a copy
constructor) and perhaps also a conversion to double,

class Blah
{
public:
Blah( Blah const& another ) { ... }
Blah( double number ) { ... }

Blah& operator=( double number )
{
...
return *this;
}

operator double() const
{
return ...;
}
};

What you cannot do (except by providing access to Blah internals)
is to have assignments to something of 'double' type affect a Blah.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?