Is it possible to reuse variable names with using namespace? - c++

Question

For example, initially I have a sample program:
#include<iostream>
#include<algorithm>
using namespace std;
int main() {
int a[3];
sort(begin(a),end(a));
cin;
}
Now I want to modifystd::cin(to provide more functions like invoke a function when input fails). So I introduces a headermystd.h like:
#include<iostream>
#include<algorithm>
//begin of mystd.h
namespace mystd {
struct cin_wrapper {
}cin;
}
//end of mystd.h
using namespace std;
int main() {
int a[3];
sort(begin(a),end(a));
mystd::cin;
}
But the change seems to be not convenient.(Users must mention all components using std::sort;using mystd::cin; or replace all cin with mystd::cin. using namespace std;using mystd::cin; causes the cin ambiguous)
In fact I'm going to write a modified standard library and make the use of it as convenient as the original one. The ideal code I wish users can write is:
(PS: this means mystd can be just used as std, not indicates I want to encourage users to use using namespace everywhere)
#include<iostream>
#include<algorithm>
#include "mystd.h"
using namespace mystd;
int main() {
int a[3];
sort(begin(a),end(a));//std::sort
cin;//mystd::cin
}
//or
int main() {
int a[3];
mystd::sort(mystd::begin(a),mystd::end(a));//sort, begin, end from std
mystd::cin;
}
I've tried to add using namespace std; in mystd but it also causes ambiguity.
One complicated solution I can image is to create a using statement like using std::string; in mystd for all std members not modified.
Is there a more practical way for me to implement mystd.h?

Answer 1

If you really insist on doing this, you can manage to do so by introducing your using statements at nested scopes. For example:
using namespace std;
int main() {
using namespace mystd;
int a[3];
sort(begin(a), end(a));//std::sort
cin_wrapper w;//mystd::cin
}
Anything involving using namespace std; should be avoided though (using other, more restricted namespaces isn't so bad, but that one is a huge truckload of cans of worms you're opening).

Answer 2

This isn't a good idea, because it is very fragile.
Imagine that someone writes your "ideal" code. Then, one day, you write mystd::sort that accepts a Range instead of two iterators.
Suddenly the meaning of the existing code has changed unexpectedly, and it starts to fail to compile because it wasn't anticipating that the number of parameters should now be one instead of two.

Answer 3

Your requirement is seamlesly implemented by the invention of "namespace".
If "productB" is your product with the same names as in "productA, you want to rewrite; then you decide, which names to be used by your users via some "using" statements in your interface file "productB.h" .
source file productA.h :
namespace productA
{
void f1();
void f2();
}
your source file productB.h : here you decide, what to use :
namespace productB
{
void f1();
void f2();
}
using productA::f1;
using productB::f2;
implementation:
#include <iostream> // std::cout
#include "productA.h"
#include "productB.h"
void productA::f1() { std::cout << "called A::f1" <<std::endl; }
void productA::f2() { std::cout << "called A::f2" <<std::endl; }
void productB::f1() { std::cout << "called B::f1" <<std::endl; }
void productB::f2() { std::cout << "called B::f2" <<std::endl; }
application: very convenient
#include "productA.h"
#include "productB.h"
int main () {
f1();
f2();
}
output:
called A::f1
called B::f2
notice: nothing is ambigous