#include <iostream>
#include <stdio.h>

void foo()
{
    std::cout << "\r\nGlobal\r\n";
}


template <typename T> class Base {
public:
    void foo()
    {
        std::cout << "\r\nBase\r\n";    }
};

template <typename T> class Derived : public Base<T> {
public:
    int call_foo ()  {
        foo();
        return 1;
    }
};


int main(int argc, char* argv[])
{
    //foo = 666;

    Derived<int> h;
    h.call_foo();

    //std::cout << h.get_foo() << std::endl;
    return 0;
}

VC(2008 и старшие): 
Base
GCC(4.6.1):
Global

SM>И как с этим вообще жить ? Почему так ?

::foo(); // вызываем глобальную функцию
this->foo(); // вызываем свою

SM>>И как с этим вообще жить ? Почему так ?

U>this->foo(); // вызываем свою

struct B
{
    void f() {}
};

template <class T>
    struct D : T
{
    using T::f;

    void g()
    {
        f();
    }
};

int main()
{
    D<B>().g();
}

U>::foo(); // вызываем глобальную функцию
this->>foo(); // вызываем свою
U>

typedef public Base<T> base;
base::foo();

SM>>Почему так ?

E>Ну потому, что хорошего решения данной проблемы нет. Мне одно время аргументация коммитета казалось логичной, но я попробовал писать и так и так, и понял, что нифига не помогает two-phase name lookup от РЕАЛЬНЫХ проблем, а вот неинтуитивности и писанины добавляет. Так что лично мне подход от MS нравится больше. Но лучше всего писать так, что бы оба подхода давали один и тот же результат...

// foo.h
inline void foo() { cout << "hello " << bar(0) << endl; }
#define FOO() ((void)( cout << "hello " << bar(0) << endl; )) // полный аналог

// a.cpp
#include "foo.h" // объявление foo идёт перед объявлением зависимости, это существенно
const char* bar(char) { return "a"; }
void aaa() { foo(); FOO(); }

// b.cpp
#include "foo.h"
const char* bar(int) { return "b"; }
void bbb() { foo(); FOO(); }

// main.cpp
void aaa();
void bbb();
int main() { aaa(); bbb(); }

// foo.h
template<class T> struct Foo : T
{
  void hello() const { cout << "hello " << bar(0) << endl; }
};
struct V {};

// a.cpp
#include "foo.h"
const char* bar(char) { return "a"; }
void aaa() { Foo<V>().hello(); }

// a.cpp
#include "foo.h"
const char* bar(int) { return "b"; }
void bbb() { Foo<V>().hello(); }