L'appel d'une const fonction plutôt que de sa non-const version

J'ai essayé d'envelopper quelque chose de semblable à Qt de données partagée des pointeurs pour mes fins, et après essai, j'ai trouvé que, lorsque la const fonction doit être appelée, à sa non-const version a été choisi à la place.

Je compile avec C++0x options, et voici un code minimal:

struct Data {
    int x() const {
        return 1;
    }
};

template <class T>
struct container
{
    container() {
        ptr = new T();
    }


    T & operator*() {
        puts("non const data ptr");
        return *ptr;
    }

    T * operator->() {
        puts("non const data ptr");
        return ptr;
    }

    const T & operator*() const {
        puts("const data ptr");
        return *ptr;
    }

    const T * operator->() const {
        puts("const data ptr");
        return ptr;
    }

    T* ptr;
};

typedef container<Data> testType;

void testing() {
    testType test;
    test->x();
}

Comme vous pouvez le voir, les Données.x est un const fonction, de sorte que l'opérateur -> appelés doivent être const un. Et quand je commenter la non-const, il compile sans erreurs, donc c'est possible. Et pourtant, mon terminal imprime:

"non const données ptr"

Est-ce un bug de GCC (j'ai 4.5.2), ou est-il quelque chose que je suis absent?