Advertisements

I’m struggling with OOP again. I tried to implement signgly linked list, here’s the code:

```
template <typename T>
class node
{
T value;
node* next;
public:
node(const T& n)
{
this->value = n;
this->next = nullptr;
}
~node()
{
//is it ok to leave destructor empty in my case?
}
};
template <typename T>
class list
{
node<T>* head;
node<T>* tail;
public:
list()
{
this->head = nullptr;
this->tail = nullptr;
}
list(const list& arr)
{
*this = list(); //<================== the line I mentioned
node* current_this = this->head;
node* current_arr = this->arr;
while (current_arr != nullptr)
{
current_this = new node(current_arr);
current_arr = current_arr->next;
current_this = current_this->next;
}
}
list(list&& arr)
{
this->head = arr.head;
this->tail = arr.tail;
arr = list(); //<================== the line I mentioned
}
~list()
{
node* current = this->head;
while (current != nullptr)
{
node* next = current->next;
delete current;
current = next;
}
}
};
```

I wrote some lines without thinking, i.e. `arr = list()`

and `*this = list()`

. I didn’t implemented `operator=`

so there should be some troubles. I thought compiler has decided to generate copy/move assigment for me, so I decided to add these lines, just for curiosity sake:

```
list& operator=(const list& arr) = delete;
list& operator=(list&& arr) = delete;
```

But it still compiled and I don’t understand why. What’s the deal here? Shoudn’t assignment be forbidden and therefore `arr = list()`

and `*this = list()`

be illegal?

### >Solution :

Templates aren’t evaluated unless/until you instantiate them. If you don’t use the copy or move constructor, then their bugs don’t produce errors.