Я неправильно применил наследство?

Итак, у вас есть дерево, узлы которого имеют два разных типа, происходящих из одной и той же базы, и вы хотите выполнить операцию с одним типом, но не над другим … это звучит как работа для шаблона посетителя. 🙂

Идея шаблона «посетитель ^» заключается в следующем: он предоставляет способ для элементов сложных структур (деревьев, графиков) работать по-разному в зависимости от их типа (который известен только во время выполнения), и где сама конкретная операция может также быть известным только во время выполнения, без необходимости изменять всю иерархию, к которой принадлежат элементы (т.е. избегать таких вещей, как реализация функции addToBalance «ошибка», о которой вы думали). (^ Это не имеет ничего общего с посещением, поэтому его, вероятно, неправильно назвали — это скорее способ достижения двойной диспетчеризации для языков, которые изначально не поддерживают его.)

Таким образом, вы можете иметь набор операций для выполнения над элементами, и операции могут быть, например, перегружен в зависимости от типа элемента. Простой способ сделать это — определить базовый класс для всех операций (ниже я называю его классом Visitor). Единственное, что он будет содержать, — это пустые функции — по одной для каждого типа элемента, над которым потенциально может быть выполнена операция. Эти функции будут переопределены конкретными операциями.

class Visitor {

virtual void Visit(ParentAccount*) { /* do nothing by default*/ }
virtual void Visit(ChildAccount*) { /* do nothing by default */ }
};

Теперь мы создаем определенный класс для выполнения AddToBalance ChildAccountтолько с

class AddToBalance : public Visitor {

public:
AddBalance(string _nameOfTarget, int _balanceToAdd) :
nameOfTarget(_nameOfTarget), balanceToAdd(_balanceToAdd) {}

void Visit(ChildAccount* _child) { //overrides Visit only for ChildAccount nodes
if(child->name == _name)
child->addToBalance(_balance); //calls a function SPECIFIC TO THE CHILD
}

private:
string nameOfTarget;
int _balanceToAdd;
};

Некоторые изменения в вашем исходном классе учетной записи.

class Account{
vector<Account*> children; //assume ALL Account objects could have children; \
//for leaf nodes (ChildAccount), this vector will be empty
string name;
virtual int getBalance() =0; //generic base class has no implementation

//no addToBalance function!

virtual void Accept(Visitor* _visitor) {
_visitor->Visit(this);
}
};

Обратите внимание на функцию Accept () в классе Account, которая просто принимает Visitor * в качестве аргумента и вызывает функцию Visit этого посетителя в this, Вот где происходит волшебство. На данный момент, тип this а также тип _visitor будет решен. Если this имеет тип ChildAccount и _visitor имеет тип AddToBalanceтогда Visit функция, которая будет вызываться в _visitor->Visit(this); будет void AddToBalance::Visit(ChildAccount* _child),

Который просто так случается называть _child->addToBalance(...); :

class ChildAccount : public Account{
int balance;
virtual int getBalance() { return balance; }
virtual void addToBalance(int amount) {
balance += amount;
}
};

Если this в void Account::Accept() был ParentAccountтогда пустая функция
Visitor::Visit(ParentAccount*) был бы вызван, так как эта функция не переопределяется в AddToBalance,

Теперь нам больше не нужно определять функцию addToBalance в ParentAccount:

class ParentAccount : public Account{
virtual int getBalance() {
int result = 0;
for (int i = 0; i < children.size(); i++)
result += children[i]->getBalance();
return result;
}
//no addToBalance function
};

Вторая самая забавная часть заключается в следующем: поскольку у нас есть дерево, у нас может быть общая функция, определяющая последовательность посещений, которая решает, в каком порядке посещать узлы дерева:

void VisitWithPreOrderTraversal(Account* _node, Visitor* _visitor) {
_node->Accept(_visitor);
for(size_t i = 0; i < _node->children.size(); ++i)
_node->children[i]->Accept(_visitor);

}

int main() {
ParentAccount* root = GetRootOfAccount(...);

AddToBalance* atb = new AddToBalance("pensky_account", 500);
VisitWithPreOrderTraversal(atb, root);

};

Самая интересная часть — это определение вашего собственного посетителя, который выполняет гораздо более сложные операции (например, накапливает суммы остатков только по всем дочерним счетам):

class CalculateBalances : public Visitor {

void Visit(ChildAccount* _child) {

balanceSum += _child->getBalance();

}
int CumulativeSum() {return balanceSum; }
int balanceSum;
}

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

Я бы предложил вам непосредственно представить эту структуру в коде:

class Account
{
public:
int getBalance();
void addToBalance(int amount);
// privates and implementation not shown for brevity
};class TreeNode
{
public:
// contains account instance on leaf nodes, and nullptr otherwise.
Account* getAccount();

// tree node members for iteration over children, adding/removing children etc

private:
Account* _account;
SomeContainer _children
};

Если теперь вы хотите пройтись по дереву, чтобы собрать остатки на счетах и ​​т. Д., Вы можете сделать это непосредственно в древовидной структуре. Это проще и менее запутанно, чем переходить через родительские учетные записи. Кроме того, ясно, что фактические учетные записи и содержащая их древовидная структура — это разные вещи.