Linked List with c++ class

Only see 1 bug:

void ConnectedPoint::connectTo(const ConnectedPoint& point)
{
  next = new ConnectedPoint(point.index(),point.position());
  *(next->next) = *(point.next);
}

In other places where you connect things (copy constructor/assignment) you delete the list of object pointed at by next before overwriting. You don't do that here. So if next is not a nullptr then you will leak.

Simplify

Your code is based on the fact that the next pointer owns a unique version of the object it points at. Whenever you do any manipulation of lists you preserve this by making sure you dynamically create copies of the object (which is fine). But there is already a class that will do this for you.

 std::unique_ptr<ConnectedPoint>  next;

std::unique_ptr is not only designed to correctly do ownership semantics by using you are explicitly telling everybody that you are using ownership semantics and they need to read less of your code to understand the semantics of your object.

Assignment does not provide strong gurantee

ConnectedPoint& ConnectedPoint::operator=(const ConnectedPoint& point)
{
  if(this == &point)
  {
    return *this;
  }

  // Delete the old state
  delete next;
  next = nullptr;

  // STUFF

  // What happens if this fails?
  next = new ConnectedPoint(*(point.next));

  // If an exception is generated (it may be caught higher up in the stack).
  // At this point your object now has lost the state it used to have and
  // never got the new state. So the behavior of your code could be eratic
  // after this point.


  // MORE STUFF
}

The Strong Exception gurantee basically says either the operation works correctly OR (the operation fails with an exception AND the object is unchanged). TO do this you need to use a more conservative technique. But its easy. You just use what is called the copy and swap idium.

ConnectedPoint& ConnectedPoint::operator=(const ConnectedPoint& point)
{
    ConnectedPoint copy(point);
    copy.swap(*this);
    return *this;
}
ConnectedPoint::swap(ConnectedPoint& rhs)
{
    using std::swap;
    swap(m_index,    rhs.m_index);
    swap(m_position, rhs.m_position);
    swap(next,       rhs.next);
}

The first thing people notice is that there is no test for self assignment.

  if(this == &point)
  {
    return *this;
  }

This is because it is no longer needed as we always make a copy. Sure this makes it less efficient when we do self assignment (add it back in if you really want). But self assignment though possible is actually very rare. So you are optimizing for a very rare condition at the expense of the normal operation. So normal operations are slowed down (the thing that happens all the time) while we optimize for things that are unlikely to happen.