<p>I'm storing an object (<code>TTF_Font</code>) in a <code>shared_ptr</code> that is provided to me from a third-party API. I cannot use new or delete on the object, so the <code>shared_ptr</code> is also provided a "freeing" functor.</p>

<pre><code>// Functor
struct CloseFont
{
    void operator()(TTF_Font* font) const
    {
        if(font != NULL) {
            TTF_CloseFont(font);
        }
    }
};

boost::shared_ptr&lt;TTF_Font&gt; screenFont;

screenFont = boost::shared_ptr&lt;TTF_Font&gt;( TTF_OpenFont("slkscr.ttf", 8), CloseFont() );
</code></pre>

<p>If, later, I need to explicitly free this object is it correct to do this:</p>

<pre><code>screenFont.reset();
</code></pre>

<p>And then let <code>screenFont</code> (the actual <code>shared_ptr</code> object) be destroyed naturally?</p>

shared_ptr<>::reset() will drop the refcount by one.  If that results in the count dropping to zero, the resource pointed to by the shared_ptr<> will be freed.
So I think the answer for you is, yes that will work.  Or you can simply let the screenFont variable be destructed due to dropping out of scope or whatever, if that's what's about to happen.
To be clear, the normal usage of shared_ptr<> is that you let it be destructed naturally, and it will deal with the refcount and freeing the resource when it drops to zero naturally.  reset() is only required if you need to release that particular instance of the shared resource before the shared_ptr<> would be naturally destructed.