Gibt es irgendwelche tricks, die Sie verwenden std::cin zur Initialisierung einer const-variable?

Gemeinsame std::cin Nutzung

int X;
cin >> X;

Der größte Nachteil dieser ist, dass X nicht const. Es kann sich leicht vorstellen, bugs, und ich bin auf der Suche nach irgendeinem trick, um der Lage sein, erstellen Sie einen const-Wert, und schreiben Sie es nur einmal.

Die naive Lösung

//Naive
int X_temp;
cin >> X_temp;
const int X = X_temp;

Könnte man natürlich verbessern, indem Sie X, um const&; dennoch sind die original-variable verändert werden können.

Ich bin auf der Suche nach einem kurzen und clevere Lösung, wie dies zu tun. Ich bin sicher, ich bin nicht der einzige, profitieren von einer guten Antwort auf diese Frage.

//EDIT: möchte ich die Lösung einfach erweiterbar auf andere Arten (sagen wir mal, alle PODs, std::string und beweglich-kopierbar Klassen mit trivialen Konstruktor) (wenn es nicht sinnvoll ist, bitte lassen Sie mich wissen in den Kommentaren).

  • ist die variable, die Sie wünschen zu initialisieren einer Klasse?
  • Die ersten zwei Zeilen einer Funktion zurückgeben int 🙂 const int X = read_cin();
  • nicht unbedingt, Nein.
  • Setzen ersten 2 Zeilen deiner Lösung in eine Funktion und zurück X_temp.
  • Ändern const int zu const int& nicht noch etwas verbessern. Zweite ist fast genau das gleiche wie const int * const so werden Sie kopieren sizeof(int*) und in const int Sie kopieren sizeof(int), also wahrscheinlich genau die gleiche Menge an Daten. Mit Verweis auf int hat keinen Sinn - sollten Sie wahrscheinlich nicht verwenden Referenz auf die leb-en.
  • Dies erfordert eine Funktion, die für jede Art, die ich Lesen möchte.
  • Bitte Lesen Sie den zu Bearbeiten.
  • Ich persönlich mag die "naive Lösung", die Sie setzen. Der Wert, den Sie Lesen in der user ist offensichtlich NICHT eine Konstante ist, dann sind Sie ausdrücklich kopieren Sie den Wert in einen anderen Wert was Sie Versprechen wird sich nicht ändern, indem Sie es markieren const. Es ist etwas hässlich, aber scheint genau zu passen, was passiert.
  • Ihre "naive" Lösung ist, wie es getan werden sollte. Niemand profitiert von einer riesigen, bombastischen Klasse Schnittstelle für die Durchführung einer so einfachen, banalen Aufgabe. Wenn Sie finden, sich selbst das schreiben lange, komplizierte Funktionen, nur um eine variable zu setzen, das ist ein Sicheres Zeichen sagen, dass etwas gründlich schief gegangen in das Programm-design.
  • Aber mit der naiven Weise, ich habe zum erstellen einer temp-variable für jede Art werde ich aus dem stream gelesen: string TempString; int TempInt; und so weiter... ich dachte nur, man könnte Kapseln in einer Funktion, so wird es sein, die Unbenannt ist.
  • erfordert eine Funktion, die für jede Art, die ich Lesen möchte." Machen Sie es eine read_cin<int>() dann 🙂

InformationsquelleAutor Bartek Banachewicz | 2012-09-05
  1. 22

    Ich würde wahrscheinlich entscheiden Sie sich für die Rückkehr eine optional, da die streaming-scheitern könnte. Um zu testen, ob es auch (im Fall, dass Sie wollen, um die Zuweisung eines Wert), verwenden Sie get_value_or(default), wie im Beispiel gezeigt.

    template<class T, class Stream>
boost::optional<T> stream_get(Stream& s){
  T x;
  if(s >> x)
    return std::move(x); //automatic move doesn't happen since
                         //return type is different from T
  return boost::none;
}

    Live-Beispiel.

    Weiter sicherzustellen, dass der Benutzer bekommt keine wall-of-überlast angezeigt, wenn T ist nicht input-streamable, Sie können schreiben Sie eine Eigenschaft der Klasse, die prüft, ob stream >> T_lvalue gültig ist und static_assert wenn es ' s nicht:

    namespace detail{
template<class T, class Stream>
struct is_input_streamable_test{
  template<class U>
  static auto f(U* u, Stream* s = 0) -> decltype((*s >> *u), int());
  template<class>
  static void f(...);

  static constexpr bool value = !std::is_void<decltype(f<T>(0))>::value;
};

template<class T, class Stream>
struct is_input_streamable
  : std::integral_constant<bool, is_input_streamable_test<T, Stream>::value>
{
};

template<class T, class Stream>
bool do_stream(T& v, Stream& s){ return s >> v; }
} //detail::

template<class T, class Stream>
boost::optional<T> stream_get(Stream& s){
  using iis = detail::is_input_streamable<T, Stream>;
  static_assert(iis::value, "T must support 'stream >> value_of_T'");
  T x;
  if(detail::do_stream(x, s))
    return std::move(x); //automatic move doesn't happen since
                         //return type is different from T
  return boost::none;
}

    Live-Beispiel.

    Ich bin mit einem detail::do_stream Funktion, da sonst s >> x würden noch analysiert werden, innerhalb get_stream und Sie möchten bekommen noch die wall-of-überlastungen, die wir wollten vermeiden, wenn die static_assert feuert. Delegieren Sie diesen Vorgang, um eine andere Funktion macht diese Arbeit.

    • Ich würde behaupten, dass dies die einzige akzeptable Lösung. Aber gut, ich bin seltsam.
    • Das ist ein guter Weg, um zu definieren weird, genauso wie die post ist ein gutes Beispiel für overkill 🙂
    • Strukturieren Sie Ihren code fließen, so dass Sie const Objekte? Ich denke nicht, dass das bisschen übertrieben ist.
    • Was tun Sie mit einem optionalen const?! "Hier ist eine Konstante... vielleicht"?
    • eine Konstante kann einen Wert enthalten". Warum ist das komisch? Es ist das nicht – andere Sprachen tun, die ganze Zeit (Haskell,...) und C++ hat die große Wohltat, dass diese als gut.
    • War die "overkill" richtet sich an die static_assert? Wenn ja, empfehle ich Ihnen die Fehlermeldung wenn Ihr T macht nicht - support-input-streaming. Ich sehr viel halte, diesen nicht zu viel des guten, aber man könnte vielleicht die Schuld der Implementierung spuckt diese riesige Liste an Erster Stelle... würde ich nicht tun, dass, obwohl, denn hier können Sie entdecken, wenn man nur einen Tippfehler gemacht hat oder etwas anderes, wenn Sie die Implementierung einer überladenen Funktion (man sagt auch warum, die Funktion war SFINAE würde, wenn das passiert).
    • Es war dazu gedacht, etwas tongue-in-cheek. Ich Schätze die finesse der Lösung. Ich war nur amüsiert an, wie groß eine Lösung der scheinbar einfache Wunsch zu initialisieren X hatte ausgefällt 🙂
    • Wie auch immer, ich bin der Annahme es als die einzige Antwort, die ist vollkommen richtig.

    InformationsquelleAutor Xeo
  2. 18

    Nutzen Sie lambdas für solche Fälle:

       const int x = []() -> int {
                     int t;
                     std::cin >> t;
                     return t;
                 }();

    (Beachten Sie die extra () am Ende).

    Anstelle des Schreibens einen separaten Funktionen, dies hat den Vorteil, dass Sie nicht herumhüpfen in der Quell-Datei, beim Lesen den code.

    Edit: Da in den Kommentaren hieß es, dass dies geht gegen die TROCKENE Regel, Sie könnten sich die Vorteile auto und 5.1.2:4 zu reduzieren, Typ-Wiederholung:

    5.1.2:4 Staaten:

    [...] Wenn ein lambda-Ausdruck nicht enthalten ist eine trailing-return-Typ, ist es, als
    wenn der trailing-return-type kennzeichnet den Typ:

    • wenn die compound-Anweisung ist von der form

      { attribute-specifier-seq(opt) return expression ; }

      den Typ der zurückgegebenen Ausdruck nach lvalue-zu-rvalue-Konvertierung (4.1),
      array-to-pointer-conversion (4.2), und-Funktion-nach-Zeiger-Konversion (4.3);

    • ansonsten nichtig.

    So könnten wir ändern den code wie folgt Aussehen:

       const auto x = [] {
                     int t;
                     std::cin >> t;
                     return t;
                  }();

    ich kann mich nicht entscheiden ob das besser ist, aber, da der Typ nun "versteckt" innerhalb des lambda-body...

    Edit 2: In den Kommentaren wurde darauf hingewiesen, dass nur das entfernen der name des Typs, wo es möglich ist, nicht in einem "TROCKEN-richtigen" code.
    Auch die trailing-return-type-Abzug in diesem Fall ist derzeit tatsächlich eine Erweiterung der MSVC++ sowie g++ und (noch) nicht standard.

    • Hm, können Sie überspringen die erste Reihe von () nur nach der []?
    • Nicht, wenn Sie wollen, um eine trailing return type.
    • wow, ich mag lambda-Ausdrücke eine Menge... aber das sieht einfach hässlich! (Kein Kommentar über die Qualität der Antwort an alle, wie der code landet auf der Suche sichtbar)
    • Ich mag das denken, aber es scheint zu verletzen TROCKNEN der Regel für mich.
    • Wenn Sie geben einen trailing-return-Typ,haben Sie auch zu schreiben, aus der lambda-Deklarator. Leider habe ich nicht finden können, den genauen Absatz in der standard jetzt. Es könnte sein, §5.1.2.4. In diesem Fall können Sie auch weglassen trailing return type insgesamt. Um ehrlich zu sein, mein wissen von lambas nicht, dass deep noch.
    • Wie für die TROCKENEN: Sie könnte verwenden auto, aber das würde nur sparen Sie sich eine Wiederholung.
    • es ist in der Grammatik in 5.1.2:1; lambda-Deklarator ist optional, aber wenn enthalten, es muss ein - parameter-Erklärung-Klausel, bevor Sie die optional trailing-return-type. Die Semantik eines weggelassen lambda-Deklarator oder ein ausgelassenes trailing-return-type sind definiert in Ziffer 5.1.2:4.
    • Der return-Typ kann nicht weggelassen werden, wenn es mehr als eine Anweisung in der lambda-Körper, siehe stackoverflow.com/questions/6240894/...
    • Wie ich verstanden habe (und mit VC11 getestet) ist es, der return-Typ kann abgeleitet werden, wenn es nur eine return-Anweisung innerhalb des lambda-Körper. Siehe auch MSDN:Lambda-Ausdruck Syntax
    • das ist eine Erweiterung, die sowohl MSVC und g++ zu implementieren, aber es ist (noch) nicht standard-C++. Problem 975 open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#975 ist derzeit in Begutachtung und sieht wahrscheinlich angenommen werden. Die aktuelle Sprache benötigt noch immer einen Körper von der form { attribute-specifier-seqopt return expression ;}.
    • Der wahre Geist von TROCKEN Umgestaltung des Musters in eine Funktion, so dass Sie am Ende mit z.B. const auto i = extract<int>(std::cin); nicht, dass Sie das Muster kürzer.
    • ecatmur, @LucDanton : Ah, ich sehe. Vielen Dank, Ihr beiden. Ich bin mir nicht sicher, wie Sie Sie Bearbeiten meine Antwort jetzt, wenn..

    InformationsquelleAutor lx.
  3. 12

    Einem leichten zwicken zu lx.'s lambda-Lösung:

    const int x = [](int t){ return iss >> t, t; }({});

    Deutlich weniger TROCKEN Verletzung; kann vollständig eliminiert werden, durch ändern const int x zu const auto x:

    const auto x = [](int t){ return iss >> t, t; }({});

    Einer weiteren Verbesserung; Sie können konvertieren Sie die Kopie in einen Zug, da sonst der Komma-operator unterdrückt die Optimierung in 12,8:31 (Move-Konstruktor unterdrückt durch den Komma-operator):

    const auto x = [](int t){ return iss >> t, std::move(t); }({});

    Beachten Sie, dass dies potenziell noch weniger effizient als die lx.'s lambda, als profitieren können NRVO in der Erwägung, dass dies immer noch ein move-Konstruktor. Auf der anderen Seite eine Optimierung der compiler sollte in der Lage sein, zu optimieren, eine nicht-Nebeneffekt-Lager bewegen.

    • Ich mag Ihre Letzte Beispiel
    InformationsquelleAutor ecatmur
  4. 5

    Können Sie eine Funktion aufrufen, um das Ergebnis zurückzugeben, und initialisieren Sie in der gleichen Anweisung:

    template<typename T>
const T in_get (istream &in = std::cin) {
    T x;
    if (!(in >> x)) throw "Invalid input";
    return x;
}

const int X = in_get<int>();
const string str = in_get<string>();

fstream fin("myinput.in",fstream::in);
const int Y = in_get<int>(fin);

    Beispiel: http://ideone.com/kFBpT

    Wenn Sie C++11, können Sie angeben, den Typ nur einmal, wenn Sie die auto&& Stichwort.

    auto&& X = in_get<int>();
    • Braucht mehr Fehler überprüfen!
    • Könntest du ein default-Wert parameter zu entfernen Mehrdeutigkeit? Wie in_get(T temp = T())?
    • Sie müssen explizit angeben template-Argumente: pastebin.com/G5dFUsSi
    • Ok, sortierte die Probleme, und mit ideone.com um zu beweisen, dass es funktioniert.
    • Ich löschte meinen vorherigen Kommentar, denn ich habe erkannt, dass die Versorgung mit einem "temp" - variable eigentlich bedeutet das schreiben eine Art.
    • Sie können auto statt neu-die Angabe der Art.
    • Warum auto&& über const auto?

    InformationsquelleAutor ronalchn
  5. 3

    Gehe ich davon aus, das Sie initialisieren möchten, eine globalen variable, da für eine lokale variable, es scheint nur, wie eine sehr ungeschickte Wahl auf drei Linien der einfachen und verständlichen Anweisungen, um eine Konstante von zweifelhaftem Wert.

    Auf globaler Ebene, wir können keine Fehler in der Initialisierung, also müssen wir mit Ihnen umgehen irgendwie. Hier sind einige Ideen.

    Erste, eine vorgefertigte kleine Bau-Helfer:

    template <typename T>
T cinitialize(std::istream & is) noexcept
{
    T x;
    return (is && is >> x) ? x : T();
}

int const X = cinitialize<int>(std::cin);

    Beachten Sie, dass die globalen Initialisierungen dürfen keine Ausnahmen auslösen (unter Schmerzen std::terminate), und dass die Eingabe-Vorgang möglicherweise fehl. Alle sagten, es ist wahrscheinlich ziemlich schlecht design zum initialisieren der globalen Variablen aus Benutzereingaben in einer solchen Weise. Vielleicht ein fataler Fehler wäre, die angezeigt werden:

    template <typename T>
T cinitialize(std::istream & is) noexcept
{
    T x;

    if (!(is && is >> x))
    {
        std::cerr << "Fatal error while initializing constants from user input.\n";
        std::exit(1);
    }

    return x;
}

    Genau zu klären, meine position nach einiger Diskussion in den Kommentaren: In einem lokalen Bereich würde ich nie resort, um solch eine peinliche Krücke. Da wir verarbeiten externen, vom Benutzer gelieferten Daten, wir haben im Grunde zu Leben, scheitern als Teil der normalen Ablaufsteuerung:

    void foo()
{
    int x;

    if (!(std::cin >> x)) { /* deal with it */ }
}

    Ich lasse es bis zu Ihnen zu entscheiden, ob das ist zu viel zu schreiben oder zu schwer zu Lesen.

    • Es ist mehr wie cininitialize_int. Etwas allgemeiner wäre besser.
    • Sie können ganz einfach machen es eine Vorlage und ersetzen Sie die -1 durch T() (das wäre auch besser in der int version, da -1 ist nur ein spezieller Wert, ohne sinnvolle Bedeutung. Ok, 0 ist nicht viel besser, aber zumindest ist es das Ergebnis null/Wert-Initialisierung).
    • Vorlage zu lösen wäre, dass im Handumdrehen
    • Der fatale Fehler scheint ein wenig übertrieben. Vielleicht machen Sie einen optionalen zusätzlichen parameter für ein Fehler-flag, wenn Sie wirklich nicht wollen, Ausnahmen? Das bedeutet, Sie haben eine veränderliche variable irgendwo, aber eine veränderliche error-flag scheint viel erträglicher für mich. Auf der anderen Seite, Reihenfolge der Initialisierung der globals ist zu verrückt für eine so Weise zu sein, gesund sowieso, imho, und damit vielleicht eine Ausnahme zu werfen ist akzeptabel.
    • Auslösen einer Ausnahme von einer globalen Initialisierung beendet das Programm.
    • Global initialisers dürfen exceptions werfen (für einige Werte von "darf" - wird es zu einem Aufruf std::terminate); und es gibt keine Anzeichen dafür, dass die OP will Sie initialisieren globals auf diese Weise.
    • Btw, ich glaube nicht, dass Sie brauchen, um zu überprüfen, ob der stream selbst ist gültig, dies geschieht in operator>> sowieso.
    • Ich weiß, ich weiß... ich war in einer sehr booleschen Stimmung. Und seit C++11 ich mag hinzufügen && wo ich kann. Zeigen Sie?
    • Stoppen Sie den FUD über Ausnahmen. Eine Ausnahme bei der dynamischen Initialisierung wird NICHT Ursache etwas schlimmes passieren. die Vermietung der Ausnahme Flucht werden. Als solche gibt es keine Notwendigkeit für jeden Anrufer zu tragen die Last der mit einem solchen subpar Methode der Fehlerberichterstattung. Ausnahmen, und wenn jemand will, um die Funktion zu verwenden, die in einem SSDO Initialisierung Sie kümmert, um z.B. wickeln Sie den Aufruf in eine try-catch-block in einen lambda-Ausdruck. Ich weiß, du bist besser als irrational Angst vor Ausnahmen.
    • Meine Funktion ist konzipiert für den einzigen Zweck der Durchführung der OP, die Anforderungen und die Beantwortung seiner Frage. Es ist nicht ein universelles Werkzeug für etwas, das können Sie bereits tun. Also ich habe alles was ich brauche für die OP Zweck in die Funktion... ist das so schlimm? Das ist auch der Grund, warum ich werde nicht wild mit Verallgemeinerungen. Es war nicht nötig, und ja ich könnte, aber manchmal sollte man nicht mehr als eine Socke auf einem Fuß, wie jemand einmal sagte.
    • Die OP zwar nicht ausdrücklich sagen, dass dieses ist zum initialisieren der namespace-Gültigkeitsbereich von Variablen. Unabhängig davon, ist eine zukünftige Besucher vielleicht nehmen Sie aus Ihrer Antwort auf Nennwert und richtig halten, dass die Verwendung von Ausnahmen in SSDO Initialisierungen ist unlösbar.
    • Gut... das wäre bedauerlich, und ich hoffe, dass die Worte "Globale Initialisierung" macht dieses Besondere Bedingung klar. Ich glaube wirklich nicht, dass die Antwort (nicht die Kommentare!) ist das irreführend. Und ja, ich könnte beschreiben auch die Initialisierung in anderen zusammenhängen aber wieder, kann man nur zu Fuss so weit auf einer Socke...
    • I don ' T care über Ihre Socken. Der Punkt ist, dass das auslösen bei der dynamischen Initialisierung ist in Ordnung, solange Sie zu fangen. Was Sie sagen, fliegt einfach das Gesicht, und die Festsetzung, dass bedeutet nicht, dass das hinzufügen von Socken.
    • Hmm, ist ein schwerwiegender Fehler ausgegeben, gefolgt von std::exit ist in der Tat viel besser als ein std::terminate von einer "uncaught exception".

    InformationsquelleAutor Kerrek SB
  6. 2

    Sicher, dass Sie tun können dieses nur den Bau einer temporären istream_iterator. Zum Beispiel:

    const auto X = *istream_iterator<int>(cin)

    Es ist erwähnenswert, hier, dass Sie ' re Verzicht auf alle Hoffnung auf Fehler überprüfen, wenn Sie dies tun. Die in der Regel in der Einnahme von Eingaben von einem Benutzer würden nicht als die Klügste... aber hey, vielleicht haben Sie kuratierte diese Eingabe irgendwie?

    Live Beispiel

    • Ziemlich erstaunlich, dass niemand hat gedacht, dass für 5 Jahre!
    • Ich kann nur vermuten, dass dies bezieht sich vor allem auf das fehlende Fehler zu überprüfen? Ich benutze dies eine Menge mit istringstreams und ifstreams, die ich kontrollieren kann. Aber... ja ich weiß nich es scheint, wie die naheliegendste Antwort?
    InformationsquelleAutor Jonathan Mee
Schreibe einen Kommentar