Typecast将普通指针指向unique_ptr是一种不好的做法吗？

Question

I implemented a singly linked list using unique_ptr with mix of normal pointers.

I have this code:

template<typename B>
void linkedlist<B>::addNode(B x){
  node * n = new node;                      //initialize new node
  n->x = x;
  n->next = nullptr;                        //smart pointer

  if(head == nullptr){                      //if the list is empty
    head = (unique_ptr<node>)n;             //cast the normal pointer to a unique pointer

  }else{                                    //if there is an existing link
    current = head.get();                   //get the address that is being
                                            //pointed by the unique_ptr head


    while(current->next != nullptr)         //loop until the end then stop
      current = (current->next).get();

    current->next = (unique_ptr<node>) n;   //connect the new node to the  last node
  }
}

I heard that it's a bad practice, if so then can someone tell me why? Suggestions and tips for proper practices will also be appreciated.

Answer 1

While the cast syntax is slightly strange, it's exactly equivalent to the more conventional

unique_ptr<node>(n)

and so isn't itself bad practice. What is bad practice is to have the raw pointer hanging around at all, with a danger that it might leak if there is a code path that doesn't either delete it or transfer it to a smart pointer.

You should start with

unique_ptr<node> n(new node);

and transfer ownership by moving from it

head = std::move(n);

Answer 2

In your case it may not be an issue but casting existing raw pointers to unique_ptrs is a bit of a bad practice mainly due to the semantics involved. Unique_ptr will run a deleter when goes out of scope.

Consider the following

int ptr_method(int * i) {
    auto a = (unique_ptr<int>)i;
    return *a.get();
}

int main() {
    int i = 10;
    ptr_method(&i);
}

What happens to i when ptr_method returns ?