Mercury13

class IC {   // interface
public:
  virtual int getC() = 0;
  virtual ~IC() = default;
};

class C : public IC {
public:
  int getC() final { return 42; }
};

class B {
public:
  IC* buddy() const { return fBuddy; }
  void setBuddy(IC* aBuddy) { fBuddy = aBuddy; }
  void someJob() const { if (fBuddy) std::cout << fBuddy->getC() << std::endl; }
private:
  IC* fBuddy = nullptr;
};

class A {
public:
  A() { b.setBuddy(&c); }
private:
  C c;
  B b;
}

template <class T>
class ChunkMap
{
public:
    // Data access
    //------------------------------------------------------------------------//
    /// @return  data at index t, or empty value
    T get(size_t t) const;

    //------------------------------------------------------------------------//
    /// Sets data at index t (empty value to erase)
    void put(size_t t, T x);

    //------------------------------------------------------------------------//
    /// Erases range [0..maxPlus)
    void eraseTo(size_t aMaxPlus);

    // Info
    size_t nChunks() const { return fChunks.size(); }
    bool isEmpty() const { return fChunks.empty(); }

    //------------------------------------------------------------------------//
    /// @return  the number that is beyond all chunks
    size_t ceil() const;

    //------------------------------------------------------------------------//
    /// @return  actual number of records in the map
    size_t size() const;

    //------------------------------------------------------------------------//
    /// @return  lowest value in the map; (0, empty) if empty
    std::pair<size_t, T> lowerValue() const;

    //------------------------------------------------------------------------//
    /// @return  highest value in the map; (0, empty) if empty
    std::pair<size_t, T> upperValue() const;

    //------------------------------------------------------------------------//
    /// @return  (t1, v), t1 <= t;  (0, empty) if none
    std::pair<size_t, T> lowerOrEq(size_t t) const;

    template <class Body> void loop(const Body& r) const;
    template <class Body> void loopFrom(size_t aMin, const Body& r) const;

    //------------------------------------------------------------------------//
    ///  Loops all data. Body is bool-convertible.
    ///  Return true → go on.
    ///  Return false → stop and return false.
    template <class Body> bool loopBool(const Body& r) const;

    void clear() { fChunks.clear(); }

    constexpr static T emptyValue() { return std::numeric_limits<T>::max(); }
    static bool isEmptyValue(const T& x) { return (x == emptyValue()); }

    constexpr static unsigned chunkSize() { return Chunk::SIZE; }

private:
    struct Chunk
    {
        enum { SIZE = 8 };
        Fix1d<T, SIZE> data;   // мой шаблон, массив фиксированного размера с проверкой на выход за границы

        Chunk();
        bool isEmpty() const;
        std::pair<size_t, T> lowerValue(size_t aKey) const;
        std::pair<size_t, T> upperValue(size_t aKey) const;
    };
    typedef std::map<size_t, Chunk> Chunks;
    Chunks fChunks;
};

int foo()
{
   int y = ...;
   if (y < 0)
     y = -y;
   return y;
}

void bar()
{
   int x = foo();
   if (x != 0)
      bar();
   foo();
}

void main()
{
  int z = foo();
  bar();
}