Suche…


Einführung

Mit einer using Deklaration wird ein einzelner Name in den aktuellen Bereich eingefügt, der zuvor an anderer Stelle deklariert wurde.

Syntax

  • using typename ( opt ) nested-name- spezifier unqualifizierte-id ;
  • using :: unqualified-id ;

Bemerkungen

Eine using-Deklaration unterscheidet sich von einer using-Direktive , die den Compiler anweist, bei der Suche nach einem Namen in einem bestimmten Namespace zu suchen. Eine using-Direktive beginnt mit der using namespace .

Eine using-Deklaration unterscheidet sich auch von einer Alias-Deklaration, die einem vorhandenen Typ auf dieselbe Weise wie typedef einen neuen Namen gibt. Eine Alias-Deklaration enthält ein Gleichheitszeichen.

Namen einzeln aus einem Namespace importieren

Einmal using wird verwendet , um den Namen einzuführen cout aus dem Namensraum std in den Rahmen der main die std::cout - Objekt kann als bezeichnet wird cout allein.

#include <iostream>
int main() {
    using std::cout;
    cout << "Hello, world!\n";
}

Neu deklarieren von Mitgliedern aus einer Basisklasse, um das Ausblenden von Namen zu vermeiden

Wenn eine using-Deklaration im Klassenbereich vorkommt, darf nur ein Member einer Basisklasse neu deklariert werden. Beispielsweise ist die using std::cout im Klassenbereich nicht zulässig.

Oft wird der Name erneut deklariert, der sonst verborgen wäre. Im folgenden Code bezieht sich Derived1::foo(const char*) d1.foo nur auf Derived1::foo(const char*) und ein Kompilierungsfehler wird auftreten. Die Funktion Base::foo(int) ist ausgeblendet und wird überhaupt nicht berücksichtigt. d2.foo(42) ist jedoch in Ordnung, da die using-Deklaration Base::foo(int) in die Gruppe der Entities mit Name foo in Derived2 . Die Namenssuche findet dann sowohl foo s als auch die Überlastauflösung und wählt Base::foo .

struct Base {
    void foo(int);
};
struct Derived1 : Base {
    void foo(const char*);
};
struct Derived2 : Base {
    using Base::foo;
    void foo(const char*);
};
int main() {
    Derived1 d1;
    d1.foo(42);  // error
    Derived2 d2;
    d2.foo(42);  // OK
}

Erbauer erben

C ++ 11

Als Sonderfall kann eine using-Deklaration im Klassenbereich auf die Konstruktoren einer direkten Basisklasse verweisen. Diese Konstruktoren werden dann von der abgeleiteten Klasse geerbt und können zum Initialisieren der abgeleiteten Klasse verwendet werden.

struct Base {
    Base(int x, const char* s);
};
struct Derived1 : Base {
    Derived1(int x, const char* s) : Base(x, s) {}
};
struct Derived2 : Base {
    using Base::Base;
};
int main() {
    Derived1 d1(42, "Hello, world");
    Derived2 d2(42, "Hello, world");
}

Im obigen Code verfügen sowohl Derived1 als auch Derived2 über Konstruktoren, die die Argumente direkt an den entsprechenden Konstruktor von Base weiterleiten. Derived1 führt die Weiterleitung explizit aus, während Derived2 mit der C ++ 11-Funktion zum Erben von Konstruktoren implizit erfolgt.



Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow