Using namespaces - c++

Question

I have the below code
#include<iostream>
namespace first{
void test()
{
std::cout<<"This is the first one \n";
}
}
namespace second{
void test()
{
std::cout<<"This is the second one \n ";
}
}
int main()
{
using namespace first;
test();
using namespace second;
test();
return 0;
}
The above code gives me compilation error of calling of overloaded function test.
My doubt why cannot the second using statement using namespace second hides the first namespace?
Next I tried declaring the namespace inside a function body, this may sound strange but i tried to check whether i can do that or not, It also resulted in the compilation error. Which makes me wonder is it only at the global scope that I can declare the namespaces?
My third and last question is, is there any way by which I can only declare the two function with the same signature inside two different namespaces and the define them outside the outside the namespace block? Like below
#include<iostream>
namespace first{
void test();
}
namespace second{
void test();
}
int main()
{
return 0;
}
Again idk whether my question is valid or not.

Answer 1

I assume both of the using statements precede the call of test() (as distinct from one before and one after, as you have presented it) since, otherwise, the code is fine.
Namespaces do not hide each other. using namespace first makes the identifiers (types, variable, function names, etc) in first become candidates for matching in subsequent code.
By preceding the call of test() with
using namespace first;
using namespace second;
the effect is that both first::test() and second::test() become candidates for matching a subsequent unqualified usage of test(). The compiler has no reason to prefer one over the other - they are both equally valid matches - so the compiler rejects the code due to ambiguity over which one to select.
Also, test() is not overloaded in your example. Two distinct functions in different namespaces are declared and defined. Their full names (like first::test() and second::test() are distinct.
To answer your second question, namespaces can be declared within namespaces.
For your third question, defining the functions separately from their declaration, is possible;
namespace first
{
void test();
}
void first::test()
{
std::cout<<"This is the first one \n";
}

Answer 2

The error you get is not because of an overload, but because of ambiguity of test(): The compiler "sees" two definitions, first::test() and second::test(), with no hint which one to use.
using namespace second; adds the identifiers from second:: to the global namespace; it does not hide any that are already global (either defined globally or previously introduced via using namespace). That's just the way it works.
Also, namespaces can be declared either at global scope, or inside other namespaces; they cannot be declared inside function bodies (as you found out).
That being said, "trial and error" (what does a given compiler accept or not) is a bad habit. What you're learning is not "the language", but a specific implementation. The difference will come back to haunt you if your code is one day expected to compile on a different implementation, or run on a different platform.
In order to resolve the ambiguity, you can always use the fully qualified names, first::test() and second::test(), both when defining and when calling the functions.