Здравствуйте, коллеги!

Надо сделать преобразование одного типа в другой.
Если есть возможность модифицировать класс, к которому приводим, то тогда так

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

Если есть возможность модифицировать класс, который приводим, то тогда так

class CSrc{
operator CDst() ...

Если нет возможности модифицировать ни один из этих классов, можно ли организовать неявное преобразование?

Здравствуйте, Marty, Вы писали:

M>Если нет возможности модифицировать ни один из этих классов, можно ли организовать неявное преобразование?

Можно написать свою специализацию для boost::lexical_cast. Такое преобразование не будет неявным, но зато оно будет укладываться в более или менее стандартную схему.

Здравствуйте, Marty, Вы писали:

M>Если нет возможности модифицировать ни один из этих классов, можно ли организовать неявное преобразование?

ИМХО нет. Операторы приведения типа и даже = должны быть мемберами.
Единственное что приходит в голову, это:

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;
    }
};

Но неявного преобразования не получится, т.к. уровень вложенности не должен быть больше одного.

Здравствуйте, Marty, Вы писали:

Существует мнение, что неявных преобразований следует избегать.
Не расскажешь, зачем тебе понадобилось такое преобразование?

Здравствуйте, Bell, Вы писали:

B>Здравствуйте, Marty, Вы писали:

B>Существует мнение, что неявных преобразований следует избегать.
B>Не расскажешь, зачем тебе понадобилось такое преобразование?

Есть POD тип со строкой, используется для передачи строки между двоичными модулями, хочу его преобразовывать без лишней писанины в std::string.

Здравствуйте, Marty, Вы писали:

M>Здравствуйте, Bell, Вы писали:

B>>Здравствуйте, Marty, Вы писали:

B>>Существует мнение, что неявных преобразований следует избегать.
B>>Не расскажешь, зачем тебе понадобилось такое преобразование?

M>Есть POD тип со строкой, используется для передачи строки между двоичными модулями, хочу его преобразовывать без лишней писанины в std::string.

А зачем неявно?

...
accept(MyCustom_cast<TOut>(in));
...

— и управляемо и наглядно, напишите только специализацию для TOut MyCustom_cast<TOut, TIn>(const TIn &);

или например так

//конвертор по умолчанию предполагает что тип From уже нормально приводится к To
template <class From, class To>
To customCastCnvt(const From &from)
{
    return from;
}

//////////////////////////////////////////////////////////////////////////
//прослойка, удерживающая ссылку на From и имеющая шаблонный оператор приведения, испольующий 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);
    }
};

//////////////////////////////////////////////////////////////////////////
//интерфейсная функция, создает прослойку
template <class From>
CustomCastHolder<From> customCast(const From &from)
{
    return CustomCastHolder<From>(from);
}

//////////////////////////////////////////////////////////////////////////
//рабочие типы
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)
    {

    }
};


//////////////////////////////////////////////////////////////////////////
//специализация преобразования для 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