//header
namespace N
{
   class C
   {
      void func();
   }
}

//cpp file
namespace N
{
   void C::func()
   {
      ..
   }
}

// header такой же

//cpp file
using namespace N;

void C::func()
{
   ..
}

J>// header такой же

J>//cpp file
J>using namespace N;

J>void C::func()
J>{
J>   ..
J>}
J>

//cpp file
void N::C::func()
{
   ..
}

#include <iostream>

using namespace std;
int error_code = 1;

int main(int argc, char * argv[])
{
  //...

  cout << error_code << endl;// surprise (probably)
  return 0;
}

J>Не знал что при definition-е функции компилятор также занимается поиском в пространствах имён к какому именно это определение относится. Что компилер ищет про неймспейсам при использовании чего то (класса, функции) — это общеизвестно, но вот этот случай я вижу вообще впервые. Имхо это ненужная диковинка для гиков

namespace N
{

  enum Blabla
  {
  };

  // prefix (++my_member)
  Blabla& operator++(Blabla& orig);

  // postfix (my_member++)
  Blabla operator++(Blabla& orig, int);
}

using namespace N;


// prefix (++my_member)
Blabla& operator++(Blabla& orig)
{
  return orig;
}

// postfix (my_member++)
Blabla operator++(Blabla& orig, int)
{
  return ++orig;
  // error C2593: 'operator ++' is ambiguous
  // could be 'N::Blabla &operator ++(N::Blabla &)'
  // or       'N::Blabla &N::operator ++(N::Blabla &)'
  // while trying to match the argument list '(N::Blabla)'
}

// prefix (++my_member)
Blabla& operator++(Blabla& orig)
{
  return orig;
}

namespace N {
  class C {
    typedef int D;
    D member(D x);
  };
}

N::C::D // здесь контекст ещё самый верхний, namespace :: - поэтому нужно тип квалифицировать полностью
N::C::member // по этой же причине полностью квалифицируем имя члена
( // а вот с этого места контекст - N::C::
  D x
)
{ ... }
// вышли из определения - вернулись к исходному ::

///////////////

auto // чёрт его знает, какой тип
N::C::member
(D x) -> D // в этой строке уже известно про N::C
{ ... }

namespace N
{
  class T {};

  void foo(T); // объявили N::foo(N::T)
}

using namespace N;
void foo(T); // объявили ::foo(N::T)
void foo(T) {...} // определили ::foo(N::T)

int main()
{
  // в поле зрения есть и ::N::foo, и ::foo
  foo(T());
}

#include <iostream>
using namespace std;

namespace N
{
    struct T {};
    T foo(T);
    T& operator++(T&);
}
auto N::foo(T t) -> T { return t; }
auto N::operator++(T& t) -> T& { return t; }

using namespace N;
/* --- если раскомментировать - будут неоднозначности
T foo(T t) { return t; }
T& operator++(T& t) { return t; }
*/

int main() {
    // your code goes here
    T t;
    ++t;
    foo(t);
    cout << "ok\n";
    return 0;
}

К>namespace N
К>{
К>  class T {};

К>  void foo(T); // объявили N::foo(N::T)
К>}

К>using namespace N;
К>void foo(T); // объявили ::foo(N::T)
К>void foo(T) {...} // определили ::foo(N::T)

К>int main()
К>{
К>  // в поле зрения есть и ::N::foo, и ::foo
К>  foo(T());
К>}
К>

// common_header.h
namespace N
{
  struct T
  {
    static void static_method();
    void method();
  };

  void func();
}

// file1.cpp
#include "common_header.h"

using namespace N;
void T::static_method() {}
void T::method() {}
void func() {}


// file2.cpp
#include "common_header.h"
void test()
{
  T t;
  t.method();           // линкуется успешно
  T::static_method();   // линкуется успешно
  func();               // не линкуется
}

J>PS: Я таки нашёл главную разницу, свободные функции, объявлённые в namespace, не связываются при их определении без явного указания их неймспейса, а методы связываются. Теперь можно бегать и тыкать носом народ

#include <iostream>
using namespace std; // пёс с ним, это ideone подвёрстывает

namespace N
{
    namespace M
    {
        void f();
    }//ns M
}//ns N

using namespace N;

void M::f() { cout<<"N::M::f"<<endl; } // пример (частично) квалифицированного имени свободной функции

using namespace M;

int main() {
    f();
    M::f();
    N::M::f();
    return 0;
}