Question

I have been writing some code with basically this structure

namespace util {
    void read (int &);
    template <typename T>
    void read (T &);
}

void foo ();

using namespace util;

namespace { // A
    void read (MyType &, int);

    void do_something () {
        MyType t;
        int i;
        // using util::read; // B
        read (i); // C
        read (t,i); // D
    }
}

void foo () {
    do_something ();
}

At first line C wasn’t compiling unless I fully qualify it as util::read(i) or uncommented line B, but that makes line D fail.

Specialising the template util::read isn’t possible because the number of arguments is different (until C++0x).

Turning line A into namespace util isn’t an option because I don’t want to export the new read.

I could rename read(MyType&,int) but that breaks ahem style.

Is there a way to make these cross-namespace overloads work nicely? Is there a good reason that they shouldn’t?

Answer 1

Yes, it’s hard. In fact, it’s impossible.

The best you can do is to hide names. You’re right to employ using (B) to get around the complications that name hiding brings into the mix, when you’re also overloading functions — D should still function in this case. Please show the error you got for it.