С++: рождение родительского класса в дочерний класс

Ответ 1

Вы столкнулись с ситуацией, которую мы называем срезом объектов, которая является общей проблемой в языках со значениями семантики, такими как С++.

Нарезка объектов происходит, когда вы назначаете значение подтипа новому местоположению (вашей переменной connection) супер-типа. Это вводит новую копию экземпляра, но супер тип, а не подтип, поэтому вы теряете информацию о конкретном классе, который вы хотели бы создать.

Чтобы избежать этого, у вас есть несколько параметров.

В классическом подходе используются указатели:

Base * connection;
connection = new YourConcreteType();

Затем, чтобы использовать этот объект, вы должны его устранить, используя оператор звездочки (*):

(*connection).function();
connection->function();    // syntactic sugar, semantically equivalent

Не забыть: вы должны удалить объект после использования:

delete connection;

Чтобы упростить это, С++ представляет два понятия: ссылки и интеллектуальные указатели. В то время как первое имеет ограничение, которое назначается только один раз, оно является синтаксически простым. Последнее похоже на подход указателя, но вам не нужно заботиться об удалении, поэтому вы с меньшей вероятностью столкнетесь с ситуацией утечки памяти:

std::shared_ptr<Base> connection;

connection = make_shared<YourConcreteType>(); // construction via 'make_shared'

// ... use as if it were just a pointer ...

connection->function();

// no delete!

Существуют также другие типы "умного указателя", такие как unique_ptr, которые можно использовать, если вы не собираетесь передавать указатель (если он остается в области видимости).

Теперь вы можете реализовать функции в обоих классах отдельно. Чтобы использовать полиморфизм, это означает, что во время выполнения вызывается либо функция одного подкласса, либо другого подкласса, в зависимости от того, какой из них был создан, вы должны объявить функции в базовом классе как virtual, иначе, определение функции в Base будет вызываться независимо от конкретного типа, который вы создали.

В вашем случае вы хотите вызвать функцию, которая должна делать что-то другое, в зависимости от типа. В то время как ваш подход состоял в том, чтобы ввести две разные функции, а именно A и B, вы можете просто объявить одну функцию, называть ее handleEvent как чистую виртуальную (= абстрактную) функцию в базовом классе, что означает "эта функция должна быть реализована в подклассах" и определить ее в двух подклассах самостоятельно:

Base {
    ....
    virtual void handleEvent(...) = 0; // "= 0" means "pure"
};

// Don't provide an implementation

Client {
    void handleEvent(...); // override it
};

// define it for Client:
void Client::handleEvent(...) {
    ...
}

Host {
    void handleEvent(...); // override it
};

// define it for Host:
void Host::handleEvent(...) {
    ...
}

Ответ 2

Когда вы это сделаете:

Base connection;

Вы создаете объект connection, который имеет точно память, необходимую для типа Base.

Когда вы это сделаете:

connection = Client();

вы не расширяете выделенную или преобразованную память connection в экземпляр Client. Вместо этого вы создаете более крупный объект, который "нарезается" на меньший.

То, что вы хотите сделать, - это указатели на использование (или ссылки или интеллектуальные указатели), так что то, что вы храните, - это просто адрес объекта, который может быть одним типом или другим типом. Вот так:

Base *connection;
...
connection = new Client();

Первый оператор создает указатель на Base типизированный объект, а второй выделяет память для Client типизированного, инициализирует его и присваивает свой адрес connection.

Ответ 3

Если вы хотите использовать Base по-прежнему, вам нужно будет сделать это, чтобы использовать эти функции:

if (Button1) {
    dynamic_cast<Client*>(connection)->A();
} else {
    dynamic_cast<Host*>(connection)->B();   
}  

И вам нужно будет установить соединение с указателем. Base * connection.

Это не идеальный вариант. Вы должны исследовать другой способ сделать это, как в других ответах.

Ответ 4

Во-первых, эта строка

connection = Client();

использует оператор присваивания для установки состояния connection, a Base из временного объекта Client. connection все еще является объектом Base. Вы можете сделать следующее:

std::unique_ptr<Base> makeBase(someFlagType flag)
{
  if (flag) {
    return std::unique_ptr<Base>(new Cient);
  } else {
    return std::unique_ptr<Base>(new Host);
  }
}

Тогда

std::unique_ptr<Base> b = makeBase(myFlag);
b->someBaseMethod();

Что касается части каста, я бы сказал, что если вам приходится бросать дочерний тип, вы должны подумать о дизайне классов.