I have a class template which inherits from a base class template.

The base class template has a data member with a member function template which I want to call from within my super class.

I know that in order to disambiguate the call to the member function template, I have to use the `template` keyword, and I have to explicitly refer to `this` in the super class.

`this->base_member_obj.template member_function<int>();`

All this is good and well, except that the codebase I'm using has made the rather unfortunate mistake of importing the entirety of `namespace std`, and the template member function I'm trying to call is called `set`. Somewhere in the framework `std::set` is included, and this causes GCC to think I'm trying to declare a `std::set` rather than call the member function `set`.

GCC 4.7 throws an error **invalid use of 'class std::set'**

**See below for an example showing the error**. If you comment out `using namespace std` the code compiles fine.

Sadly it is not feasible for me to go through the entire codebase, remove every `using namespace std` call, and prefix every call to anything inside the std namespace with `std::`

Is there any other way around this?

```
#include <set>
using namespace std; // comment this out to compile fine

struct blah
{
    template<typename T>
    void set()
    { }
};

template<typename T>
struct base
{
    blah b;
};

template<typename T>
struct super : base<super<T>>
{
    void fun()
    {
        this->b.template set<int>(); // this line breaks
    }
};

int main()
{
    super<int> s;
    s.fun();

    return 0;
}

```