Linked List with c++ class I am playing with a sort of linked list using C++ classes. I have used a lot of C linked lists (struct based) during C programming course, but there was no behavior. Thus, I am a bit confused about the correct definition of a class containing a pointer to another object of the same class.
Here is the header:

#ifndef CONNECTEDPOINT_H
#define CONNECTEDPOINT_H

#include "vector3d.h"

class ConnectedPoint 
{
  using Position = Vector3D&lt;double&gt;;

public:
  ConnectedPoint(unsigned index, const Position&amp; pos);
  ~ConnectedPoint();
  ConnectedPoint(const ConnectedPoint&amp; point);
  ConnectedPoint&amp; operator=(const ConnectedPoint&amp; point);

  void connectTo(const ConnectedPoint&amp; point);

  unsigned index() const {return m_index;}
  const Position&amp; position() const {return m_position;}
  Position&amp; position() {return m_position;}
  ConnectedPoint* getNext() {return next;}

private:
  unsigned m_index;
  Position m_position;
  ConnectedPoint* next;
};
#endif // CONNECTEDPOINT_H


and the implementation file:

#include "connectedpoint.h"
ConnectedPoint::ConnectedPoint(unsigned index, const ConnectedPoint::Position&amp; pos)
  : m_index(index)
  , m_position(pos)
  , next(nullptr)
{

}

ConnectedPoint::~ConnectedPoint()
{
  if(next != nullptr)
  {
    delete next;
    next = nullptr;
  }
}

ConnectedPoint::ConnectedPoint(const ConnectedPoint&amp; point)
  : m_index(point.m_index)
  , m_position(point.m_position)
{
  if(point.next == nullptr)
  {
    this-&gt;next = nullptr;
  }
  else
  {
    next = new ConnectedPoint(*(point.next));
  }
}

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

  delete next;
  next = nullptr;

  m_index = point.m_index;
  m_position = point.m_position;

  if(point.next != nullptr)
  {
    next = new ConnectedPoint(*(point.next));
  }

  return *this;
}

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


Vector3D is just a class template which holds 3 coordinates and allows standard mathematical vector operations. Here its behaviors are not used.

Basically I would like to know:

Is this a proper implementation for such a class? Are there mistakes both in the approach and in the implementation?
Only see 1 bug:
void ConnectedPoint::connectTo(const ConnectedPoint&amp; point)
{
  next = new ConnectedPoint(point.index(),point.position());
  *(next-&gt;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&lt;ConnectedPoint&gt;  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&amp; ConnectedPoint::operator=(const ConnectedPoint&amp; point)
{
  if(this == &amp;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&amp; ConnectedPoint::operator=(const ConnectedPoint&amp; point)
{
    ConnectedPoint copy(point);
    copy.swap(*this);
    return *this;
}
ConnectedPoint::swap(ConnectedPoint&amp; 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 == &amp;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.