Копирование дочернего класса в базовый - C++

Какая логика у компилятора, когда он делает такое присваивание? Кто может обьяснить.

У класса A есть дефолтный конструктор копирования и operator=. Они просто копируют члены класса. И т.к. B можно скастовать к A, то они ес-но могут использоваться в данном случае. Упрощенно, если ты напишешь функцию:

void copy_object( const A& a );

То ты сможешь вызвать ее и для A, и для B.

В первом случае работает, потому что slicing. Что, кстати, не очень-то и хорошо. Тупо срезать «лишние» поля и сделать вид, что так и было. Это багофича/фичебаг. Решить можно, унаследовав A как protected.

А во втором случае откуда инфу брать? Вот и нужно явно объявить оператор копирования, чтобы разрулить.

В первом случае работает, потому что slicing. Что, кстати, не очень-то и хорошо. Тупо срезать «лишние» поля и сделать вид, что так и было. Это багофича/фичебаг. Решить можно, унаследовав A как protected.

Это совершенно нормальное поведение для по сути функции:

inline A& operator=(A& p1, const A& p2) { p1.a = p2.a; return p1; }

Которая выбирается из множества в одну функцию (в данном случае). И багофичи тут нет, багофича была бы, если бы присваивание работало в обратную сторону.

Это совершенно нормальное поведение для по сути функции:

Так-то да, но много ты знаешь случаев когда слайсинг по делу используется?

Потому что поскольку тип B унаследован (причем публично, что важно) от A, то b, являясь объектом типа B, также является и объектом типа A в одном лице. А вот a является объектом типа A и больше ничем, поэтому дефолтный оператор присвоения и копирующий конструктор у него есть только для копирования/присвоения типа A.

Почитай про сигнатуру метода operator= и его дефолтную реализацию.

Кто-то уже про усечение сказал?

try {
    throw some_child_of_std_exception( "blablabla", 100, 100.1 )
} catch( const std::exception e ) {
    std::cout << e.what( );
}

try {
    throw some_child_of_std_exception( "blablabla", 100, 100.1 )
} catch( const std::exception &e ) {
    std::cout << e.what( );
}

Чем отличаются?

Написал я и подумал, что ничего толком не объяснил.

Вот так:

class A
{
public:
    int a;
};

class B : public A
{
public:
    int b;
};


int main()
{
    A a;
    B b;
    a = b; // 1
    static_cast<A>(b) = a; // 2
    return 0;
}

- будут работать оба присвоения. Просто в первом случае приведение типов неявное, а во втором - явное.

будут работать оба присвоения

Не будут, надо static_cast<A&>, а так ты присваиваешь значение временному объекту.

Алсо «return 0;» в С++ не нужен.

Кто-то уже про усечение сказал?

Майерс четверть века назад. ОП, читай его книги, пригодится.

В сях, кстати, тоже.

Ну да, ошибочка. Собственно, вот С++ не дает так легко выстрелить себе в ногу)

Зачем ты это мне пишешь? Это уже форменное дрочерство на такое внимание обращать.

Зачем ты это мне пишешь? Это уже форменное дрочерство на такое внимание обращать.

Это не дрочерство, это понимание основ С++. Не знаешь основ - этот язык не для тебя.

Вот именно потому, что к основам это не имеет никакого отношения, это и есть дрочерство.

к основам это не имеет никакого отношения

LOL

Правильно ли я понимаю, что при присваивании A = B, то происходит такое дефолтное усечение лишних полей, и по С++ позволяет такое неявное преобразование B к A. Но вот при присваивании B = A компилятор не разрешает неявное преобразование, и нужно явно преобразовывать?

да, не вроде как знаю, что дефолтная реализация какая-то такая:

A& operator=(const A&);

Именно он в твоем примере выполняется. Какие могут быть еще вопросы?

вопросов уже нет:) спасибо большое

В A создается дефолтный operator=, который принимает в качестве аргумента константную ссылку на A, а так как это ссылка, то туда можно подсунуть не A, а дочерний класс a, потому что по ссылкам работает полиморфизм.

Второй способ, хочешь сказать, работает?