C++
Med hjälp av deklaration
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
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.