// Foo.h
namespace bar {
    class Foo {
    public:
        Foo ();
    };
}

// Foo.cpp
#include "Foo.h"
using namespace bar;

Foo::Foo () {
    //...
}

// Baz.h
namespace bar {
    void baz ();
}

// Baz.cpp
#include "Baz.h"
using namespace bar;

void baz () {
    // ,,,
}

K>>// Baz.h
K>>namespace bar {
K>>    void baz ();
K>>}

K>>// Baz.cpp
K>>#include "Baz.h"
K>>using namespace bar;

K>>void baz () {
K>>    // ,,,
K>>}
K>>

// Baz.h
namespace bar
{
  void baz();
}
// Baz.cpp
#include "Baz.h"
namespace bar
{
   void baz()
   {
   }
}
// или
bar::baz()
{
}

Every name is introduced in some portion of program text called a declarative region, which is the largest part of the program in which that name is valid, that is, in which that name may be used as an unqualified name to refer to the same entity. In general, each particular name is valid only within some possibly discontiguous portion of program text called its scope.

The names declared by a declaration are introduced into the scope in which the declaration occurs

A using-directive specifies that the names in the nominated namespace can be used in the scope in which the using-directive appears after the using-directive. During unqualified name lookup (3.4.1), the names appear as if they were declared in the nearest enclosing namespace which contains both the using-directive and the nominated namespace.

namespace test
{
  void foo( ); //1
}

void foo( ) //2
{}

int main( void )
{}

Two function declarations of the same name refer to the same function if they are in the same scope and have equivalent parameter declarations

A name can be hidden by an explicit declaration of that same name in a nested declarative region or derived class

namespace test
{
  void foo( ); //1
}

using namespace test;
void foo( ) //2
{}

int main( void )
{}

namespace test
{
  void foo( ); //1
}

using test::foo;
void foo( ) //2
{}

int main( void )
{}

If a function declaration in namespace scope or block scope has the same name and the same parameter types as a function introduced by a using-declaration, and the declarations do not declare the same function, the program is ill-formed.

Members of a named namespace can also be defined outside that namespace by explicit qualification (3.4.3.2) of the name being defined, provided that the entity being defined was already declared in the namespace and the definition appears after the point of declaration in a namespace that encloses the declaration’s namespace.

A declarator-id shall not be qualified except for the definition of a member function (9.3) or static data member (9.4) outside of its class, the definition or explicit instantiation of a function or variable member of a namespace outside of its namespace, or the definition of a previously declared explicit specialization outside of its namespace, or the declaration of a friend function that is a member of another class or namespace (11.4). When the declarator-id is qualified, the declaration shall refer to a previously declared member of the class or namespace to which the qualifier refers, and the member shall not have been introduced by a using-declaration in the scope of the class or namespace nominated by the nested-name-specifier of the declarator-id.

namespace ex1
{
  void baz( void );
}
void ex1::baz( void ){} //OK

//обратите внимание, 
//этот случай очень напоминает пример в исходном сообщении.
namespace ex21
{
  namespace ex22
  {
    void baz( void );
  }
}
using namespace ex21;
void ex22::baz( void ){} //OK

namespace ex31
{
  namespace ex32
  {
    void baz( void );
  }
  using ex32::baz;
}
void ex31::baz( void ){} //Error

namespace ex41
{
  void baz( void );
}
namespace ex42
{
  void ex41::baz( void ){} //Error
}

int main( void )
{}

A member function may be defined (8.4) in its class definition, in which case it is an inline member function (7.1.2), or it may be defined outside of its class definition if it has already been declared but not defined in its class definition. A member function definition that appears outside of the class definition shall appear in a namespace scope enclosing the class definition.

If the definition of a member function is lexically outside its class definition, the member function name shall be qualified by its class name using the :: operator.

struct test
{
  void baz( void );
};
void test::baz( void ){} //OK

namespace ex2
{
  struct test2
  {
    void baz( void );
  };
}
using namespace ex2;
void test2::baz( void ){} //OK

namespace ex3
{
  struct test3
  {
    void baz( void );
  };
}
using ex3::test3;
void test3::baz( void ){} //OK

namespace ex41
{
  namespace ex42
  {
    struct test4
    {
      void baz( void );
    };
  }
}
void ex41::ex42::test4::baz( void ){} //OK

//баг GCC 3.4.2
struct test5
{
  void baz( void );
};
namespace ex5
{
  void test5::baz( void ){} //Error
}

int main( void )
{}