Mercury13

bool operator()(two *t)
{
    return t->getA()==a;
}

максРазмер : целое
началоМаксВетви: узел

проц максВетвь(узел : Узел, началоВетви: Узел, текРазмер: целое)
  в зависимости от степени узла «узел»
    если 0:
      если текРазмер > максРазмер
        максРазмер = текРазмер
        началоМаксВетви = началоВетви
    если 1: максВетвь(единственныйCын, началоВетви, текРазмер + 1)
    если 2+:
      для всех сыновей
        максВетвь(сын, сын, 1)

максВетвь(корень, корень, 1)

class LevelObject
{
private:
   Level& level;  // Сцылка на уровень, по определению неизменная
   int x, y;           // Присваивать.
}

#include <iostream>

class Level
{
public:
    int value;
    Level(int aValue) : value(aValue) {}
};

class LevelChild
{
protected:
    Level& level;  // не присваивать
public:
    LevelChild(Level& aLevel) : level(aLevel) {}
    LevelChild operator=(LevelChild&) { return *this; }   // ничего не делающая операция «присвоить»
};

class LevelObject: public LevelChild
{
protected:
    int x, y;
public:
    LevelObject(Level& aLevel, int aX, int aY) : LevelChild(aLevel), x(aX), y(aY) {}
    void print();
};

void LevelObject::print()
{
    std::cout << "(" << x << ", " << y << ") at level " << level.value << std::endl;
}

int main()
{
    Level l1(1);  LevelObject o1(l1, 1, 2);
    Level l2(2);  LevelObject o2(l2, 3, 4);
    o1.print();
    o2.print();
    o2 = o1;
    o2.print();
}

class LevelObject
{
private:
   Level* level;  // На сей раз уже копируется
   Array3 pos;    // Какой-то инкапсулированный объект-массив
   std::wstring name;   // тоже инкапсулированный объект
}

Data.Win.ADODB.TADOQuery

Type  | Visibility | Source             | Unit           | Parent 
class | public     | Data.Win.ADODB.pas | Data.Win.ADODB | Data.Win.ADODB 
                   | Data.Win.ADODB.hpp |

Node nullNode = { NULL, NULL, NULL, BLACK };
class NodeHandle {
private:
  Node* data;
  Node* getData() const { return data ?data : &nullNode; }
public:
  NodeHandle() : data(&nullNode) {}
  NodeHandle(Node* x) : data(x) {}
  NodeHandle& operator=(Node* x) { data = x; return *this; }
  bool operator == (const Node* x) const { return (data == x); }
  bool operator != (const Node* x) const { return (data != x); }
  bool operator == (const NodeHandle& x) const { return (data == x.data); }
  bool operator != (const NodeHandle& x) const { return (data != x.data); }
  Node* operator ->() const { return getData(); }
  Node& operator *() const { return *getData(); }
  operator Node*() const { return getData(); }
}