How to make the operator of the type of transformation?

[Damin]

Hello, freinds

We should do the conversion of one type to another. If it is possible to modify the class to which drive, then so

class CDest (
CDest (const CSrc & src) ...

If it is possible to modify the class, which included, then so

class CSrc (
operator CDst () ...

If it is not possible to modify any of these classes, is it possible to organize the implicit conversion?

[MindSpace]

Hello, you wrote:

If you are not able to modify any of these classes, is it possible to organize the implicit conversion?

You can write its own specialization to boost:: lexical_cast. Such a transformation would not be implicit, but it will be packed in more or less a standard scheme.

[opaper]

Hello, Marty, you wrote:

If you are not able to modify any of these classes, is it possible to organize the implicit conversion?

All that comes to mind is:

struct TempSrc
(
private:
CSrc m_src;
TempSrc ()
(
)
public:
TempSrc (const CSrc & s_)
(
m_src = s_;
)
operator CDest ()
(
CDest dest;
dest.val = m_src.val;
dest.val1 = m_src.val1;
return &dest;
)
);

But the implicit conversion will fail, because the level of nesting should not be more than one.

[Reegan]

It is believed that the implicit transformation should be avoided. you Do not tell why you took this transformation?

[absolute55]

Originally Posted by Reegan

It is believed that the implicit transformation should be avoided. you Do not tell why you took this transformation?

There is a POD type of line used for the transmission line between binary modules, I want to convert it without extra writings in the std:: string.

[Zecho]

Why implicitly?

accept (MyCustom_cast <TOut> (in));

- And management and clearly write only for specialization TOut MyCustom_cast <TOut, TIn> (const TIn &);

or like this

/ / converter by default assumes that the type From appears to have normal To
template <class From, class To>
To customCastCnvt (const From & from)
(
return from;
)

////////////////////////////////////////////////// ////////////////////////
/ / layer, a reference to the retention of existing templates and From the operator to bring, is used customCastCnvt
template <class From>
struct CustomCastHolder
(
const From & _from;
CustomCastHolder (const From & from)
: _from (From)
(
)

template <class To>
operator To ()
(
return customCastCnvt <From, To> (_from);
)
);

////////////////////////////////////////////////// ////////////////////////
/ / interface function creates layer
template <class From>
CustomCastHolder <From> customCast (const From & from)
(
return CustomCastHolder <From> (from);
)

////////////////////////////////////////////////// ////////////////////////
/ / types of workers
struct D
(
int ind;
);
struct A
(
int ina;
operator D () const
(
D tmp = (ina);
return tmp;
)
);

struct B
(
int inb;
);
struct C
(
int inc;
C (const A & a)
: Inc (a.ina)
(

)
);


////////////////////////////////////////////////// ////////////////////////
/ / specialization of transformation for A => B
template <>
B customCastCnvt <A, B> (const A & from)
(
B tmp = (from.ina);
return tmp;
)

int main (int argc, char * argv [])
(
A a;
B b = customCast (a); / / customCastCnvt <A, B>
C c = customCast (a); / / C:: C (const A &)
D d = customCast (a); / / A:: operator D