Ist es möglich, Variablennamen mit dem Namespace wiederzuverwenden?

Question

Zum Beispiel habe ich zunächst ein Beispielprogramm:

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

Jetzt möchte ich ändern std::cin (um mehr Funktionen zu bieten wie eine Funktion aufrufen, wenn der Eingang ausfällt). So stelle ich einen Header mystd.h wie:.

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

Aber die Änderung nicht bequem zu sein scheint (. Anwender alle Komponenten erwähnen muß using std::sort;using mystd::cin; oder all cin mit mystd::cin ersetzen using namespace std;using mystd::cin; bewirkt, dass die cin mehrdeutig)

In der Tat Ich werde eine modifizierte Standardbibliothek schreiben und sie so praktisch wie die ursprüngliche verwenden. Der ideale Code I Benutzer wünschen schreiben kann, ist:

(PS: Das bedeutet mystd kann genauso std verwendet werden, nicht angibt Ich möchte Benutzer ermutigen using namespace überall zu verwenden)

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

Ich habe versucht, hinzufügen using namespace std; in mystd, aber es verursacht auch Mehrdeutigkeit.

Eine komplizierte Lösung, die ich Bild erstellen kann, ist eine using-Anweisung wie using std::string; in mystd für alle Std-Mitglieder nicht geändert zu erstellen.

Gibt es einen praktischeren Weg für mich, mystd.h zu implementieren?

Answer 1

Wenn Sie wirklich auf tun dies darauf bestehen, Sie können verwalten, dies zu tun, indem Sie Ihre using Aussagen bei verschachtelten Bereichen einzuführen. Zum Beispiel:

using namespace std; 

int main() { 
    using namespace mystd; 

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

Alles using namespace std; Beteiligung sollte vermieden werden, wenn (mit anderem, eingeschränktem Namespaces nicht so schlecht ist, aber das ist eine große LKW-Ladung von Dosen von Würmern Sie öffnen).

Answer 2

Dies ist keine gute Idee, weil es sehr zerbrechlich ist.

Stellen Sie sich vor, jemand schreibt Ihren "idealen" Code. Dann schreiben Sie eines Tages mystd::sort, das einen Bereich anstelle von zwei Iteratoren akzeptiert.

Plötzlich hat sich die Bedeutung des vorhandenen Codes unerwartet geändert, und es beginnt nicht zu kompilieren, weil es nicht erwartet hat, dass die Anzahl der Parameter jetzt eins statt zwei sein sollte.

Answer 3

Ihre Anforderung wird durch die Erfindung von "Namespace" nahtlos umgesetzt.

Wenn "productB" Ihr Produkt mit den gleichen Namen wie in "productA" ist, möchten Sie es umschreiben; dann entscheiden Sie, welche Namen Ihre Benutzer über einige "using" -Anweisungen in Ihrer Schnittstellendatei "productB. h“

Quelldatei productA.h.

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

Quelldatei ProduktB.h: hier Sie sich entscheiden, was zu verwenden:

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

Umsetzung:

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

Anwendung: sehr bequem

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

Ausgang:

called A::f1 
called B::f2 

Hinweis: nichts ist ambig