how do I make this work c$++,$ the assignment is to make raw pointers into smart pointers$-$ the error is c$2280$ on line $73($iterator& operator$++()$ function

#pragma once

#include

#include

#include

using namespace std;

template

class List $\{$

private:

class Node $\{$

public:

T data;

unique$\_$ptr prev;

unique$\_$ptr next;

bool isHiddenNode $=$ false;

$\}$;

unique$\_$ptr head;

unique$\_$ptr tail;

public:

class const$\_$iterator $\{$

protected:

unique$\_$ptr current;

T& retrieve$()$ const $\{$ return current$->$data; $\}$

const$\_$iterator$($unique$\_$ptr p$)$ : current$($p$)\{\}$

friend class List;

public:

explicit const$\_$iterator$()$ : current$($nullptr$)\{\}$

T& operator$*()$ const $\{$

return retrieve$()$;

$\}$

const$\_$iterator& operator$++()\{$

current $=$ current$->$next;

return $*$this;

$\}$

const$\_$iterator operator$++($int$)\{$

const$\_$iterator old $=*$this;

$++(*$this$)$;

return old;

$\}$

bool operator$==($const const$\_$iterator& rhs$)$ const $\{$

return current $==$ rhs$.$current;

$\}$

bool operator!$=($const const$\_$iterator& rhs$)$ const $\{$

return $!(*$this $==$ rhs$)$;

$\}$

$\}$;

public:

class iterator : public const$\_$iterator $\{$

protected:

iterator$($unique$\_$ptr p$)$ : const$\_$iterator$($p$)\{\}$

friend class List;

public:

explicit iterator$()\{\}$

T& operator $*()\{$

return const$\_$iterator::retrieve$()$;

$\}$

const T& operator$*()$ const $\{$

return const$\_$iterator::operator$*()$;

$\}$

iterator& operator$++()\{$

this$->$current $=$ const$\_$iterator::current$->$next;

return $*$this;

$\}$

iterator operator$++($int$)\{$

iterator old $=*$this;

$++(*$this$)$;

return old;

$\}$

$\}$;

private:

void setupList$()\{$

unique$\_$ptr newNode $=$ new Node$()$;

newNode$->$next $=$ tail;

newNode$->$prev $=$ head;

head$->$next $=$ newNode;

tail$->$prev $=$ newNode;

$\}$

void deleteListContents$()\{$

unique$\_$ptr current $=$ head$->$next;

unique$\_$ptr temp $=$ nullptr;

while $($current $!=$ tail$->$prev$)\{$

temp $=$ current$->$next;

delete current;

current $=$ temp;

$\}$

$\}$

public:

List$()\{$

head $=$ new Node$()$;

head$->$isHiddenNode $=$ true;

tail $=$ new Node$()$;

tail$->$isHiddenNode $=$ true;

head$->$prev $=$ nullptr;

head$->$next $=$ tail;

tail$->$prev $=$ head;

tail$->$next $=$ nullptr;

$\}$;

List$($T newData$)\{$

setupList$()$;

$($head$->$next$)->$data $=$ newData;

$\}$

explicit List$($List& rhs$)\{$

$//$ copy constructor

deleteListContents$()$;

head $=$ rhs$.$head;

tail $=$ rhs$.$tail;

$\}$

virtual ~List$()\{$

$//$ And a destructor

deleteListContents$()$;

$//$ deleteListContents$()$ leaves the head pointer, so explicit

$//$ delete req'd

delete head;

$\}$

bool empty$()\{$

return $($head$->$next $==$ tail$)$;

$\}$

$//$ iterator related methods

iterator begin$()\{$ return $\{$ head$->$next $\}$; $\}$

iterator end$()\{$ return tail; $\}$

const$\_$iterator cbegin$()$ const $\{$

return $\{$ head$->$next $\}$;

$\}$

const$\_$iterator cend$()$ const

$\{$

return $\{$ tail $\}$;

$\}$

iterator erase$($iterator itr$)\{$

unique$\_$ptr p $=$ itr.current;

iterator iterToReturn$\{$ p$->$next $\}$;

p$->$prev$->$next $=$ p$->$next;

p$->$next$->$prev $=$ p$->$prev;

return iterToReturn;

$\}$

iterator insert$($iterator itr, const T& x$)\{$

unique$\_$ptr p $=$ itr.current;

unique$\_$ptr newNode $=$ new Node$\{$ x$,$ p$->$prev, p $\}$;

p$->$prev $=$ p$->$prev$->$next $=$ newNode;

$\}$

iterator erase$($iterator from, iterator to$)\{$

iterator itr $=$ from;

while $($itr $!=$ to$)\{$

itr $=$ erase$($itr$)$;

$\}$

return to;

$\}$

$//$ And the methods for the rest

void push$\_$front$($T data$)\{$

if $($this$->$empty$())\{$

setupList$()$;

unique$\_$ptr actualHead $=$ head$->$next;

actualHead$->$data $=$ data;

$\}$

else $\{$

unique$\_$ptr actualHead $=$ head$->$next;

unique$\_$ptr newNode $=$ new Node$()$;

newNode$->$data $=$ data;

newNode$->$next $=$ actualHead;

actualHead$->$prev $=$ newNode;

newNode$->$prev $=$ head;

head$->$next $=$ newNode;

$\}$

$\}$

void push$\_$back$($T data$)\{$

if $($this$->$empty$())\{$

setupList$()$;

unique$\_$ptr actualTail $=$ tail$->$prev;

actualTail$->$data $=$ data;

$\}$

else $\{$

unique$\_$ptr actualTail $=$ tail$->$prev;

unique$\_$ptr newNode $=$ new Node$()$;

newNode$->$data $=$ data;

newNode$->$prev $=$ actualTail;

actualTail$->$next $=$ newNode;

newNode$->$next $=$ tail;

tail$->$prev $=$ newNode;

$\}$

$\}$

T front$()\{$

unique$\_$ptr actualHead $=$ head$->$next;

return $($actualHead$->$data$)$;

$\}$

T back$()\{$

unique$\_$ptractualTail $=$ tail$->$prev;

return $($actualTail$->$data$)$;

$\}$

void pop$\_$back$()\{$

if $(!$empty$())\{$

unique$\_$ptr lastNode $=$ tail$->$prev;

tail$->$prev $=$ lastNode$->$prev;

unique$\_$ptrnewLastNode $=$ tail$->$prev;

newLastNode$->$next $=$ tail;

delete lastNode;

lastNode $=$ nullptr;

$\}$

else $\{$

std::cerr $<<$ "pop$\_$back$()$: Attempt to pop from empty list. $"<<$ std::endl;

$\}$

$\}$

void pop$\_$front$()\{$

if $(!$empty$())\{$

unique$\_$ptr firstNode $=$ head$->$next;

head$->$next $=$ firstNode$->$next;

unique$\_$ptr newFirstNode $=$ head$->$next;

newFirstNode$->$prev $=$ head;

delete firstNode;

firstNode $=$ nullptr;

$\}$

else $\{$

std::cerr $<<$ "pop$\_$back$()$: Attempt to pop from empty list. $"<<$ std::endl;

$\}$