Блог

Предполагая, что у меня есть базовый класс A и общедоступный производный класс B, как я должен назначить объект подобъекту базового класса B?

 class A {...};
class B : public A {...};
A a(..);
B b(..);
static_cast<Aamp;>(b) = a; ???
  

Это выполнимо без написания оператора присваивания для B? Существуют ли какие-либо потенциальные проблемы с приведением b к Aamp;? Соответствует ли это стандарту?

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

 struct TimeMachineThing_Data {
..
..
};

class TimeMachineThing : private TimeMachineThing_Data
{
    static std::stack<TimeMachineThing_Data> m_stateHistory;

    void SaveState() {
        m_stateHistory.push_back( static_cast<TimeMachineThing_Dataamp;>(*this) );
    }

    void RestoreState() {
        static_cast<TimeMachineThing_Dataamp;>(*this) = m_stateHistory.front();
        m_stateHistory.pop_front();
    }
};
  

Это очень полезно и полностью законно.

(Здесь частное наследование, поэтому только внутренне TimeMachineThing — Это TimeMachinetime_Data)

Еще один.

 struct StructWithHundresField {
  string title;
  string author;
  ...

  StructWithHundresField() {
    ...
  }
};

class EasyResetClass : public StructWithHundresField {
  int not_reset_this_attriute;
public:
  void ResetToInitialStateAtAnyTime() {
    static_cast<StructWithHundresFieldamp;>(*this) = StructWithHundresField();
  }
}
  

Это действительно плохая идея. A — базовый, B — производный тип. Преобразуя B в A, вы теперь используете оператор присваивания A, который не будет касаться каких-либо дополнительных производных данных. В конце этого назначения по- b прежнему считается типом B , хотя теперь он содержит A . Это противоположно тому, как предполагается использовать наследование.

Изменение строки на b = reinterpret_cast<Bamp;>(a); было бы еще хуже. Тогда вы будете притворяться, что a это a B , когда это не так, и вы читаете недопустимую память.

Если вы действительно хотите выполнить такое назначение, вы хотите:

 class B : public A {
    Bamp; operator= (const Aamp; a) { ... }
};
  

Затем вы можете написать функцию для копирования информации из A , и как-то справиться с дополнительной информацией в производном типе B , плюс это позволило бы вам просто написать:

 b = a;
  

В C (как и в других языках ООП) наследование устанавливает связь Is-A .

То есть, если B публично наследует A, B = A.

Вы всегда можете привести экземпляр B к ссылке без каких-либо проблем.

Подумайте на минуту о том, хорошая ли это идея. Помните, что если у вас есть B подкласса A, то каждый B является A, но не каждый A является B. Например, каждая собака является млекопитающим, но не каждое млекопитающее является собакой. Если у вас есть конкретный объект B, попытка присвоить ему объект A в большинстве случаев не является математически четко определенной. Более того, в мире C , поскольку ваш объект B статически типизирован как B, вы никогда не сможете присвоить ему объект типа A таким образом, чтобы он перестал быть B. В лучшем случае вы собираетесь перезаписать только часть объекта B без изменения какой-либо части, специфичной для B.

Назначение нарезки безопасно только в том случае, если ваш базовый класс находится в стандартной компоновке: https://en.cppreference.com/w/cpp/types/is_standard_layout . Даже лучше, если ваш производный класс также имеет стандартную компоновку.

В частности, ваш базовый класс не должен содержать виртуальных методов или виртуального деструктора, а все нестатические элементы данных должны иметь одинаковый контроль доступа (например public , или private ). У вашего базового класса может быть сам базовый класс, и у него могут быть элементы данных, которые являются объектами других классов, но все те классы, которые вы таким образом наследуете в свой базовый класс, также должны иметь стандартный макет.

Если ваш базовый класс имеет стандартную компоновку, то нет ничего плохого в назначении ему нарезки, поскольку это гарантированно касается только элементов данных базового класса. Однако все остальные случаи небезопасны.

Я бы сказал, что вам нужен оператор присваивания, который специально копирует объект A в объект B.

В общем, неплохо иметь его любым способом при копировании объектов того же типа. Но объекты разных типов делают это еще более важным.

static_cast<TimeMachineThing_Dataamp;>(*this) = m_stateHistory.front(); может быть переписан без приведения как TimeMachineThing_Data amp; data = *this; data = m_stateHistory.front(); .

Каждый должен знать, что присваивание является ковариантным двоичным оператором и поэтому не может корректно работать с виртуальными функциями. Это верно для большинства двоичных операторов, но присваивание является особенным, поскольку оно является частью языка C .

Если вы используете OO, ваши объекты должны быть недоступны копированию и всегда представлены указателями. Уникальность идентификатора объекта является сердцем OO: объекты не являются значениями, они имеют уникальное значение (их адрес).

Если вы играете со значениями, вы должны использовать соответствующие концепции: функциональное программирование (FP). Это замыкания (прикладные объекты), переключатели, шаблоны, варианты и другие вещи.

Постарайтесь получить четкое представление о каждом из них, прежде чем смешивать их. В общем случае FP включает OO, такова общая методология: OO — это особый случай, который в особых обстоятельствах обеспечивает безопасную динамическую отправку. Отправка OO является линейной, что означает, что она обрабатывает неограниченный набор подтипов, но она также применяется только к свойствам (функции с одним параметром variant, а именно объект) и не может работать ни для чего более высокого порядка (функции с более чем одним параметром variant). аргумент). Назначение — это просто еще одна 2-арная функция, следовательно, ее нельзя отправлять с помощью виртуальных функций.