Sök…


Introduktion

En using deklaration introducerar ett enda namn i det nuvarande räckvidden som tidigare förklarades någon annanstans.

Syntax

  • använda typnamn ( opt ) nested-name-specific unqualified-id ;
  • använder :: unqualified-id ;

Anmärkningar

En användardeklaration skiljer sig från ett användningsdirektiv som säger kompilatorn att titta i ett visst namnområde när man letar upp något namn. Ett användningsdirektiv börjar med att using namespace .

En användardeklaration skiljer sig också från en aliasdeklaration, som ger ett nytt namn till en befintlig typ på samma sätt som typedef . En aliasdeklaration innehåller lika tecken.

Importera namn individuellt från ett namnområde

En gång using används för att införa namnet cout från namnområdet std i tillämpningsområdet för den main funktion, std::cout kan objektet benämnas cout ensam.

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

Redeklarera medlemmar från en basklass för att undvika att dölja namn

Om en användardeklaration inträffar i klassens omfattning är det endast tillåtet att förklara en medlem i en basklass. Att using std::cout är till exempel inte tillåtet inom klassomfånget.

Ofta är namnet som återanmälts ett som annars skulle döljas. I koden d1.foo hänvisar till Derived1::foo(const char*) d1.foo bara till Derived1::foo(const char*) och ett kompilationsfel kommer att inträffa. Funktionen Base::foo(int) döljs inte alls. d2.foo(42) är dock bra eftersom användningsdeklarationen ger Base::foo(int) in i uppsättningen enheter som heter foo i Derived2 . Namnuppslag hittar sedan både foo och överbelastningsupplösning väljer 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
}

Arvande konstruktörer

C ++ 11

Som ett speciellt fall kan en användardeklaration i klassomfång hänvisa till konstruktörerna av en direkt basklass. Dessa konstruktörer ärvs sedan av den härledda klassen och kan användas för att initialisera den härledda klassen.

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");
}

I ovanstående kod har både Derived1 och Derived2 konstruktörer som vidarebefordrar argumenten direkt till motsvarande konstruktör av Base . Derived1 utför vidarebefordran uttryckligen, medan Derived2 , med C ++ 11-funktionen för att ärva konstruktörer, gör det implicit.



Modified text is an extract of the original Stack Overflow Documentation
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow