Simple shared pointer I wrote a simple shared pointer, which I think works pretty well. I would like to see your review of it.

This is the header file:

#pragma once

#include &lt;algorithm&gt;

template &lt;class T&gt;
class SharedPointer
{
private:
    T* ptr;
    int* counter;

    void swapp(SharedPointer&amp; first, SharedPointer&amp; second);

public:
    SharedPointer(void);
    SharedPointer(T* val);
    SharedPointer(const SharedPointer&amp; sp);

    T&amp; operator*();
    T* operator-&gt;();
    SharedPointer&amp; operator=(const SharedPointer&amp; sp);
    ~SharedPointer(void);
};

template &lt;class T&gt;
void SharedPointer&lt;T&gt;::swapp(SharedPointer&amp; first, SharedPointer&amp; second)
{
    using std::swap;

    swap(first.ptr, second.ptr);
    swap(first.counter, second.counter);
}

template &lt;class T&gt;
SharedPointer&lt;T&gt;::SharedPointer(void)
{
    ptr = new T;
    counter = new int;
    *counter = 1;
}

template &lt;class T&gt;
SharedPointer&lt;T&gt;::SharedPointer(T* val) : ptr(val)
{
    counter = new int;
    *counter = 1;
}

template &lt;class T&gt;
SharedPointer&lt;T&gt;::SharedPointer(const SharedPointer&amp; sp)
{
    ptr = sp.ptr;
    counter = sp.counter;
    ++(*counter);
}

template &lt;typename T&gt;
T&amp; SharedPointer&lt;T&gt;::operator*()
{
    return *ptr;
}

template &lt;typename T&gt;
T* SharedPointer&lt;T&gt;::operator-&gt;()
{
    return ptr;
}

template &lt;class T&gt;
SharedPointer&lt;T&gt;&amp; SharedPointer&lt;T&gt;::operator=(const SharedPointer&amp; sp)
{
    SharedPointer temp(sp);
    swapp(*this,temp);

    return *this;
}

template &lt;class T&gt;
SharedPointer&lt;T&gt;::~SharedPointer(void)
{
    if(--(*counter) == 0)
    {
        delete ptr;
        delete counter;
    }
}
Foreword

When developing your own version of some standard library or tool, I suggest you to specify how close to the standard version is along with the purpose behind it.
So, for istance:


Is it standard compliant?
Does it address anything missing?




Interface

What I find missing:


How can I reset the pointer?
How can I know how many "visitors" there are(that is, how do I get counter)? Note: It could be useful, but don't go too far and break the encapsulation!
An efficient way to visit the object, that is an alternative to std::weak_ptr: 
How do I allocate/deallocate particular objects?




Implementation


#pragma once is not standard. Although almost all compilers implement it and seems like to be faster than header guards, I recommend these last ones at least until it gets standardized.
Why counter is allocated dynamically?
I understand you may not name swapp swap; however, there are better names, such as:

m_swap
internal_swap

C++, unlike C, makes no difference between function() and function(void). 
Yes, they're both correct; but the first one is much more common.
new can throw std::bad_alloc. Especially in the second constructor, if new threw when allocating/constructing counter, ptr would be leaked.