Can I undo the effect of "using namespace" in C++?

With using namespace I make the whole contents of that namespace directly visible without using the namespace qualifier. This can cause problems if using namespace occurs in widely used headers - we can unintendedly make two namespaces with identical classes names visible and the compiler will re开发者_运维问答fuse to compile unless the class name is prepended with the namespace qualifier.

Can I undo using namespace so that the compiler forgets that it saw it previously?

No, but you can tell your coworkers that you should never have a using directive or declaration in a header.

As others said, you can't and the problem shouldn't be there in the first place.
The next-best thing you can do is bring in your needed symbols so that they are preferred by the name look-up:

namespace A { class C {}; }
namespace B { class C {}; }
using namespace A;
using namespace B;

namespace D {
    using A::C; // fixes ambiguity
    C c;
}

In some cases you can also wrap the offending includes with a namespace:

namespace offender {
#  include "offender.h"
}

No, C++ Standard doesn't say anything about "undo". The best you are allowed to do is to limit scope of using:

#include <vector>

namespace Ximpl {

using namespace std;    
vector<int> x;

}

vector<int> z; // error. should be std::vector<int>

But unfortunately using namespace Ximpl will bring all names from std namespace as well.

Not to my knowledge... But as a rule I only use "using namespace" in .cpp files.

The closest, that I'll try to use in header files is following:

//example.h

#ifndef EXAMPLE_H_
#define EXAMPLE_H_


/**
 * hating c++ for not having "undo" of using namespace xx
 */
#define string std::string
#define map std::map

class Example {
public:
    Example (const char *filename);
    Example (string filename);
    ~Example ();
private:
    map<string,complicated_stuff*> my_complicated_map;

};

#undef string
#undef map

#endif //EXAMPLE_H_

after all, defines are #undef -able. There are 2 problems: 1. it is ugly 2. separate #define and #undef for each name from the corresponding namespace are used

As stated you should not use using namespace sth in header files. When you need functionality from a namespace in your implementation you can leverage scopes like this:

void func() {
    // some code agnostic to your namespace.
    {
        using namespace sth;
        // some code aware of sth.
    }
    // some other code agnostic to your namespace.
}