Bare bones SinglyLinkedList in C++11 I have done a bare bones implementation of a singly linked list in C++, which works:

Node class

template &lt;typename T&gt;
class ListNode{
    template &lt;typename U &gt; friend class SinglyLinkedList;
private:
    T data_;
    ListNode&lt;T&gt;* next_;
public:
    ListNode(void):
            data_{0},
            next_{nullptr}{}
    ListNode(T data_):
            data_{data_},
            next_{nullptr} {}

};


List class:

template &lt;typename T&gt;
class SinglyLinkedList{
private:
    ListNode&lt;T&gt;* head_;
    std::size_t size_;
public:
    SinglyLinkedList():
            head_{nullptr},
            size_{0}{}

    void insert(T item){
        ListNode&lt;T&gt; * p{new ListNode&lt;T&gt;(item)};
        if (size_ == 0){
            head_ = p;
        }else{
            p-&gt;next_ = head_;
            head_ = p;
        }
        size_++;
    }
    std::size_t getSize(){
        return size_;
    }

};


Here's what I'm looking to learn and understand:


Where is the newed up Node in the insert deleted (released)?
Is there a way to implement this without new at all?
Is there a difference between the following lines?

ListNode(void): data_{0}, next_{nullptr}{}


and

ListNode(void): data_(0), next_(nullptr){}
It seems to me that the ListNode type is part of the SinglyLinkedList. So there's no reason for that to be visible outside the SLL. I suggest making it a nested/private/hidden/secret class. (There are many ways to hide it, pick the one you like.)
Your method names are confusing. The std namespace has any number of collections defined. Pick one of them, and model your naming on that. For example: std::vector has a size method that returns the size. It also defines push_back and pop_back. Alternatively, std::list also defines push_front and pop_front. You need to pick a usage model for your SLL, and then choose method names compatible with it.
What, no iterators?