a_ptr->b = b_ptr;
b_ptr->a = a_ptr;

a_ptr.reset();
b_ptr.reset();
// A and B are now unreachable, so cycle_ptr cleans them up properly.
}

## Reference

Doxygen output is [viewable online](https://www.stack.nl/~ariane/cycle_ptr/).

## Overview

This library contains three pointers, which form the core of its interface.

1. ``cycle_ptr::cycle_member_ptr`` represents a relationship between two
objects.
2. ``cycle_ptr::cycle_gptr`` represents a global pointer
(that's what the ``g`` stands for... I should not be allowed to come up
with names).
This pointer is also used for function arguments and variables at function
scope.
3. ``cycle_ptr::cycle_weak_ptr`` represents a weak pointer to an object.

``cycle_ptr::cycle_member_ptr`` and ``cycle_ptr::cycle_gptr`` operate similar
to ``std::shared_ptr``.
``cycle_ptr::cycle_weak_ptr`` is the equivalent of ``std::weak_ptr``.

## Dealing With Collections

Consider a collection: ``std::vector>``.

This collection is not suitable for use inside an object that participates
in the cycle\_ptr graph, as the link would not be modeled.

The alternative is to use ``std::vector>``,
but this would not be usable outside of an object participating in the graph.

The solution to this, is to use ``cycle_ptr::cycle_allocator``.
This allocator adapts an allocator ``Alloc``, by allowing cycle\_member\_ptr
to deduce its owner at construction.

class MyClass;

using MyClassVector = std::vector<
cycle_ptr::cycle_gptr,
cycle_ptr::cycle_allocator>>>;

class MyClass
: public cycle_ptr::cycle_base // Used as argument to allocator.
{
// Vector instantiated with allocator that enforces ownership from *this.
MyClassVector data = MyClassVector(MyClassVector::allocator_type(*this));
};

// Create a MyClassVector that does not have an owner object.
MyClassVector notAMember = MyClassVector(MyClassVector::allocator_type(cycle_ptr::unowned_cycle));

void example(cycle_ptr::cycle_gptr ptr) {
MyClass.data = notAMember; // Using copy assignment from std::vector.
}

With this allocator, copy construction should *always* supply an allocator
such that ownership is explicitly stated.
While move constructor silently succeeds, care should be taken not to break
ownership rules.

The vector in this example uses pointers to demonstrate usage, but it works
equally well with structs or classes containing member pointers.

## Configuring