Intellisense fails for boost::shared_ptr with Boost 1.40.0 in Visual Studio 2008

Question

I'm having trouble getting intellisense to auto-complete shared pointers for boost 1.40.0. (It works fine for Boost 1.33.1.) Here's a simple sample project file where auto-complete does not work:

#include <boost/shared_ptr.hpp>

struct foo
{ bool func() { return true; }; };

void bar() {
    boost::shared_ptr<foo> pfoo;
    pfoo.get();      // <-- intellisense does not autocomplete after "pfoo."
    pfoo->func();    // <-- intellisense does not autocomplete after "pfoo->"
}

When I right-click on shared_ptr and do "Go to Definition," it brings me to a forward-declaration of the shared_ptr class in <boost/exception/exception.hpp>. It does not bring me to the actual definition, which is in <boost/smart_ptr/shared_ptr.hpp>. However, it compiles fine, and auto-completion works fine for "boost::." Also, auto-completion works fine for boost::scoped_ptr and for boost::shared_array.

Any ideas?

Answer 1

Intellisense has its own compiler, which is forgiving code errors (it has to be able to make sense of incomplete code), but sometimes simply fails to correctly parse correct code. The latter is especially true for demanding template code (which boost is notorious for).

Either live with it, or wait until Intellisense uses the "normal" compiler (was that announced for VC10 or for the version after that?), or try if Visual Assist's latest version is better.

Answer 2

For what it is worth, VC++ 2010 comes with a separate (EDG) compiler for Intellisense. Have you tried Boost 1.40 with VS2010?

Answer 3

I also recently ran into this and went searching for an answer. All I found was people saying Intellisense is going to be improved in VC10 or that I should improve it now using Visual Assist. I didn't like these answer so I experimented a bit. Here's the solution that fixes most of the issues (at the very least it fixes the issues shared_ptr had that scoped_ptr doesn't).

SOLUTION:

Change the forward declaration that Intellisense jumps to in exception.hpp to include the template parameter name T.

Change

template <class>
class shared_ptr;

To

template <class T>
class shared_ptr;

It seems that Intellisense considers the definition without a template parameter name to be a separate class and this is the root of the difference between shared_ptr and scoped_ptr.

Now, I mentioned that this hasn't solved all of my problems. Sometimes templated objects declared in header files don't retain there template type in the cpp files.

Ex.

// file.h
#include <boost/shared_ptr.hpp>

struct foo
{
    void funcA() {}
};

struct bar
{
    void funcB();
    boost::shared_ptr<foo> pfoo;
};

and then in the cpp file

// file.cpp
#include "file.h"

void bar::funcB()
{
    pfoo.get();      // <-- intellisense does autocomplete after "pfoo."
    pfoo->func();    // <-- intellisense does not autocomplete after "pfoo->"
}

Anyways, that's a non tested trimmed down example of an issue we still have but that's far less common so we can live with it until Intellisense improves.

Danger7789