Можно ли повторно использовать имена переменных с использованием пространства имен?

Question

Например, изначально у меня есть пример программы:

#include<iostream> 
#include<algorithm> 
using namespace std; 
int main() { 
    int a[3]; 
    sort(begin(a),end(a)); 
    cin; 
} 

Теперь я хочу изменить std::cin (для обеспечения более функций, как вызвать функцию, когда вход не удается). Поэтому я вводит заголовок mystd.h как:.

#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; 
} 

Но изменения, кажется, не очень удобно (. Пользователь должен перечислить все компоненты using std::sort;using mystd::cin; или заменить все cin с mystd::cinusing namespace std;using mystd::cin; вызывает cin неоднозначные)

В самом деле Я собираюсь написать модифицированную стандартную библиотеку и использовать ее так же удобно, как и исходную. Идеальный код, который я хочу пользователи могут писать это:

(PS: это означает, что mystd можно просто использовать в качестве std, не означает, я хочу, чтобы поощрять пользователей использовать using namespace везде)

#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; 
} 

Я пробовал добавить using namespace std; в mystd, но это также вызывает неоднозначность.

Одним из сложных решений, которые я могу сделать, является создание оператора using, такого как using std::string;, в mystd для всех членов std, не измененных.

Есть ли более практичный способ для меня реализовать mystd.h?

Answer 1

Если вы действительно настаиваете на этом, вы можете сделать , представив свои инструкции using во вложенных областях. Например:

using namespace std; 

int main() { 
    using namespace mystd; 

    int a[3]; 
    sort(begin(a), end(a));//std::sort 
    cin_wrapper w;//mystd::cin 
} 

using namespace std; Все, связанное следует избегать, хотя (с использованием других, более ограниченных пространств имен не так уж плохо, но это один огромный грузовик банок червей вы открывающих).

Answer 2

Это не очень хорошая идея, потому что она очень хрупкая.

Представьте, что кто-то пишет ваш «идеальный» код. Затем, однажды, вы пишете mystd::sort, который принимает диапазон вместо двух итераторов.

Внезапно значение существующего кода неожиданно изменилось, и оно начинает не скомпилироваться, потому что оно не ожидало, что теперь количество параметров должно быть единым, а не двумя.

Answer 3

Ваше требование выполнено с помощью внедрения «пространства имен».

Если «productB» - это ваш продукт с тем же именем, что и в «productA», вы хотите переписать его, а затем вы решите, какие имена будут использоваться вашими пользователями через некоторые «используемые» операторы в вашем файле интерфейса «productB». ч»

исходный файл productA.h:.

namespace productA 
{ 
    void f1(); 
    void f2(); 
} 

ваш исходный файл productB.ч: здесь вы решили, что использовать:

namespace productB 
{ 
    void f1(); 
    void f2(); 
} 
using productA::f1; 
using productB::f2; 

реализация:

#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; } 

Применение: очень удобно

#include "productA.h" 
#include "productB.h" 
int main() { 
    f1(); 
    f2(); 
} 

выход:

called A::f1 
called B::f2 

уведомление: ничего неопределенный