Member access operators

Questa pagina è stata tradotta in modo automatico dalla versione in ineglese della wiki usando Google Translate.

La traduzione potrebbe contenere errori e termini strani. Muovi il puntatore sopra al testo per vedere la versione originale. Puoi aiutarci a correggere gli gli errori. Per ulteriori istruzioni clicca qui.

Click here for the English version of this page

Linguaggio C + +

Temi generali

Preprocessore
Commenti
Parole chiave

Tabella ASCII
Sequenze di escape
La storia del C + +

Controllo del flusso

Dichiarazioni esecuzione condizionale

if statement

switch statement

Iterazione dichiarazioni

`for` loop
range-`for` loop(C++11)

`while` loop
`do-while` loop

Vai dichiarazioni

`continue` statement
`break` statement

`goto` statement
`return` statement

Funzioni

dichiarazione di funzione

lambda funzione dichiarazione

funzione di modello

specificatore inline

eccezioni specifiche(deprecato)

noexcept specificatore(C++11)

Eccezioni

tiro espressione

blocco try-catch

Spazi dei nomi

namespace dichiarazione

alias dello spazio dei nomi

Tipi

tipi fondamentali
composti tipi
enumerazione tipi

sindacali tipi
tipi di funzione

decltype specifier(C++11)

Specifiers

cv specificatori

Durata di stoccaggio specificatori

constexpr specificatore(C++11)

specificatore auto(C++11)

alignas specificatore(C++11)

Inizializzazione

predefinito di inizializzazione
valore di inizializzazione
inizializzazione a zero
copiare inizializzazione
inizializzazione diretta

inizializzazioni di aggregazione
elenco di inizializzazione(C++11)
inizializzazione delle costanti
riferimento inizializzazione

Letterali

letterali interi
caratteri letterali
virgola mobile letterali
stringhe letterali

letterali booleani
nullptr(C++11)
definito dall'utente(C++11)

Espressioni

valore categorie
ordine di valutazione

operatori
precedenza degli operatori

rappresentazioni alternative

Utilities

Tipi

typedef declaration

Tipo alias dichiarazione(C++11)

attributi(C++11)

Lancia

conversioni implicite

const_cast conversion

static_cast conversion

dynamic_cast conversion

reinterpret_cast conversion

Fusione C-stile e funzionale

Occupazione della memoria

new expression

delete expression

Classi

classe di dichiarazione
`this` pointer
specificatori di accesso

amico specificatore
liste di inizializzazione

Specifiche per una classe di funzioni proprietà

funzione virtuale
ignorare specificatore(C++11)
identificatore finale(C++11)

esplicito(C++11)
statico

Funzioni membro speciali

costruttore di default
costruttore di copia
spostare costruttore(C++11)

copiare assegnazione
spostare l'assegnazione(C++11)
distruttore

Modelli

classe template

funzione di modello

modello di specializzazione

parametri confezioni(C++11)

Varie

Montaggio in linea

[edit]

Accede a un membro di un oggetto.

Operator name	Syntax	Overloadable	Prototype examples (for class T)
Operator name	Syntax	Overloadable	Inside class definition	Outside class definition
array subscript	`a[b]`	Yes	R& T::operator[](const T2& b);	N/A
indirection (variable pointed to by `a`)	`*a`	Yes	R& T::operator*();	R& operator*(T &a);
address of	`&a`	Yes	R* T::operator&();	R* operator&(T &a);
member of object	`a.b`	No	N/A	N/A
member of pointer	`a->b`	Yes	R* T::operator->()	N/A
pointer to member of object	`a.*b`	No	N/A	N/A
pointer to member of pointer	`a->*b`	Yes	R* T::operator->*(R)	R* T::operator->*(T, R)
'Nota' Original: Notes The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Come con la maggior parte dei sovraccarichi definiti dall'utente, tipi di ritorno deve corrispondere tipi di ritorno forniti dagli operatori builtin modo che gli operatori definiti dall'utente possono essere utilizzati nello stesso modo come il built-in. Tuttavia, in una definita dall'utente overload dell'operatore, qualsiasi tipo può essere utilizzato come tipo di ritorno (compresa void). Una eccezione è `operator->`, che deve restituire un puntatore. Original: As with most user-defined overloads, return types should match return types provided by the builtin operators so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including void). One exception is `operator->`, which must return a pointer. The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Indice

[modifica]Spiegazione

Matrice indice operatore fornisce l'accesso agli elementi della matrice interna

Indiretto', membro del puntatore e puntatore a membro del puntatore operatori forniscono semantica puntatore per ogni oggetto.
Original:
indirection, member of pointer and pointer to member of pointer operators provide pointer semantics for any object.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Membro del puntatore' e puntatore a membro del puntatore operatori di restituire un puntatore all'oggetto reale che verrà utilizzato per l'accesso dei membri.
Original:
member of pointer and pointer to member of pointer operators return a pointer to the actual object which will be used for member access.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifica]Built-in operatore pedice

Per ogni tipo di oggetto T (possibilmente cv-qualificata), la firma seguente funzione partecipa risoluzione di sovraccarico:


T& operator[](T*, std::ptrdiff_t);

T& operator[](std::ptrdiff_t, T*);

I non-pointer operando può essere una qualsiasi espressione di tipo enumerazione integrale o senza ambito, è conversione implicita di std::ptrdiff_t. Il A[B] espressione è esattamente identico al *(A+B) espressione, cioè, l'operando puntatore (che può essere un risultato di matrice a puntatore conversione, e che deve puntare ad un elemento di qualche matrice o uno oltre la fine) viene regolata punto ad un altro elemento della matrice stessa, seguendo le regole di puntatore aritmetica, e viene poi dereferenziato.

#include <iostream>   int main(){int a[4]={1,2,3,4};int* p =&a[2];std::cout<< p[1]<< p[-1]<<1[p]<<(-1)[p]<<'\n';}

Output:

[modifica]Built-in operatore di rinvio

Per ogni tipo di T che è o tipo di oggetto (possibilmente cv-qualificata) o il tipo di funzione (non-const o ref-qualificata), la firma seguente funzione partecipa risoluzione di sovraccarico:


T& operator(T);

L'operando del built-in operatore di rinvio è un puntatore a oggetto o una funzione, e il risultato è il lvalue che il puntatore punta a. Si noti che un puntatore al tipo incompleto possono essere dereferenziati, ad esempio, quando si inizializza un riferimento.

#include <iostream>int f(){return42;}int main(){int n =1;int* pn =&n;   int& r =*pn;// lvalue can be bound to a referenceint m =*pn;// indirection + lvalue-to-rvalue conversion   int(*fp)()=&f;int(&fr)()=*fp;// function lvalue can be bound to a reference }

[modifica]Built-in operatore di indirizzo

L'operando del built-in operator& o è un'espressione lvalue di qualsiasi tipo o il nome completo di una funzione non statica member / oggetto della classe. Questo operatore non partecipa risoluzione dell'overload, norme speciali vengono utilizzati:

Se l'operando è un'espressione lvalue di un certo tipo T, operator& crea e restituisce un prvalue di T* tipo, con la stessa qualifica cv, che indica l'oggetto designato dal operando. Se l'operando è di tipo incompleto, il puntatore può essere formato, ma se questo tipo incompleto sembra essere una classe che definisce la sua operator& propria, il comportamento è indefinito. Per gli operandi di tipo definito dall'utente con operator&, std::addressof può essere utilizzato per ottenere il puntatore vero.

Se l'operando è il nome di una funzione di sovraccarico, l'indirizzo può essere presa soltanto se il sovraccarico può essere risolto a causa di contesto, vale a dire, il risultato di operator& viene utilizzato per inizializzare un oggetto, in un'espressione cast, a sinistra di una cessione, come parametro di funzione o in una dichiarazione di ritorno.

Se l'operando è un nome completo di un membro non statico, ad esempio, &Class::member, il risultato è un puntatore a funzione di membro prvalue o puntatore a oggetto membro del T tipo in C classe. Si noti che né &member né Class::member nemmeno (&Class::member) può essere utilizzato per inizializzare un puntatore a membro.

void f(int){}void f(double){}struct A {int i;};struct B {void f();};int main(){int n =1;int* pn =&n;// pointerint A::* mp =&A::i;// pointer to member objectvoid(B::*mpf)()=&B::f;// pointer to member function   // auto pf2 = &f; // error: ambiguous overloaded function typevoid(*pf)(int)=&f;// overload resolution due to initializationauto pf2 =static_cast<void(*)(int)>(&f);// overload resolution due to cast}

[modifica]Built-in operatori di accesso utente

L'operando di sinistra del built-in operator. e operator-> è un'espressione di tipo di classe completo T (per operator.) o puntatore a completare tipo di classe T* (per operator->, che viene valutata prima che l'operatore può essere chiamato. L'operando di destra è il nome di un oggetto o di una funzione membro membro del T o di una delle classi T di base, ad esempio expr.member, opzionalmente qualificata, ad esempio expr.name::member, eventualmente preceduti dalla parola chiave modello', ad esempio expr.template member.
Original:
The left operand of the built-in operator. and operator-> is an expression of complete class type T (for operator.) or pointer to complete class type T* (for operator->, which is evaluated before the operator can be called. The right operand is the name of a member object or member function of T or of one of T's base classes, e.g. expr.member, optionally qualified, e.g. expr.name::member, optionally prepended by the keyword template, e.g. expr.template member.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

A->B L'espressione è esattamente equivalente a (*A).B per i tipi incorporati. Se un operator-> definito dall'utente viene fornito, operator-> viene chiamato nuovamente sul valore che restituisce, in modo ricorsivo, fino a quando viene raggiunto il operator-> che restituisce un puntatore normale. Dopo di che, la semantica builtin vengono applicati a tale puntatore.

Nel expr.B espressione

1)

se B ha T& tipo, il risultato è un lvalue T.

2)

B se è un membro di dati statici di T tipo, il risultato è un lvalue T per indicare questo membro dati static.

3)

B se è un membro non statico di dati T tipo, il risultato è un lvalue se expr è un lvalue, il risultato è xValue se expr è un xValue, e il risultato è un prvalue altrimenti. B Se non viene dichiarata essere un membro mutevole', il cv-qualificazione del risultato è l'unione di cv-qualifiche del expr e B. Se B è mutevole, il cv-qualificazione del risultato è l'unione di volatili-qualifiche.
Original:
if B is a non-static data member of type T, the result is an lvalue if expr is an lvalue, the result is xvalue if expr is an xvalue, and the result is a prvalue otherwise. If B is not declared to be a mutable member, the cv-qualification of the result is the union of cv-qualifications of expr and B. If B is mutable, the cv-qualification of the result is the union of volatile-qualifications.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

4)

se B è una funzione membro statica, il risultato è un lvalue che designa la funzione statica memeber. Essenzialmente, expr viene valutata e scartata in questo caso.

5)

B se è un non-static funzione membro, il risultato è un tipo speciale di prvalue che può essere utilizzato solo come di sinistra operando in una chiamata di funzione di espressione, e per nessun altro scopo.

6)

B se è un membro di enumerazione, il risultato è un prvalue del.

7)

se B è un tipo nidificato, il programma è mal formato (non compilare)

8)

se expr ha non di classe di tipo scalare e B è il nome del tipo o decltype specificatore designazione dello stesso tipo (meno cv-qualifiche), il risultato è un tipo speciale di prvalue che può essere utilizzato solo come di sinistra operando in una chiamata di funzione di espressione, e per nessun altro scopo. La chiamata di funzione viene chiamata chiamata pseudo distruttore ', che non accetta argomenti, ritorna void, e non esegue alcuna altra azione di valutazione iniziale di expr.

#include <iostream>template<typename T>struct P {typedef T* ptr;};template<typename T>struct A {class B {};enum E {RED =1, BLUE =2};int n;staticint sn;int f(){return10+n;}staticint fs(){return4;} A(int n): n(n){}   // keyword template needed to refer to a dependent template membervoid g(){ T obj;int* p = obj.template ptr<int>; p->~T();// T is int, this calls int's pseudo destructor}};template<>int A<P<int>>::sn=2;   int main(){ A<P<int>> a(1);std::cout<< a.n<<' '<< a.sn<<' '// << A::sn also works<< a.f()<<' '<< a.fs()<<' '// A::fs() also works<< a.RED<<' '// nested type not allowed// << a.B // nested type not allowed;}

Output:

1 2 11 4 1

[modifica]Built-in puntatore a terzi operatori di accesso

L'operando di destra sia di operator.* e operator->* è un'espressione di tipo puntatore a membro in classe T. Per operator.*, l'operando di sinistra è un'espressione di T tipo di classe, o di una classe derivata in cui T è inequivocabile di base accessibile. Per operator->*, l'operando di sinistra è un puntatore a T o alla sua base.

Per ogni combinazione di tipi B, D, T, dove D o è la stessa B o una classe derivata da B, e T è o tipo di oggetto o di una funzione, la firma seguente funzione partecipa risoluzione di sovraccarico:


T& operator->(B, T D::*);

in cui entrambi gli operandi possono essere cv qualificata, nel qual caso il tipo di ritorno di cv-qualificazione è l'unione del. cv-qualificazione degli operandi.

E1->*E2 L'espressione è esattamente equivalente a (*E1).*E2 per tipi predefiniti.

Per il expr.*ptr espressione

1)

Se il tipo dinamico di expr non contiene l'elemento a cui si riferisce ptr , il comportamento è indefinito

2)

cv-qualificazione regole sono le stesse per operatore socio accesso, con una regola aggiuntiva:.. un puntatore a membro che si riferisce ad una mutevole membro non può essere utilizzato per modificare il membro di un oggetto const.

4)

Se è expr punti rvalue e ptr a una funzione membro con & ref-qualificazione, il programma è mal formata

5)

Se expr è lvalue e punti ptr a una funzione membro con && ref-qualificazione, il programma è mal formato

6)

Il risultato di expr.*ptr dove ptr è un puntatore a membro dati ha la stessa categoria valore expr.

7)

Il risultato di expr.*ptr dove ptr è un puntatore a funzione membro è una sorta di specail prvalue che può essere usato solo come a sinistra l'argomento di una espressione chiamata di funzione e per nessun altro scopo.

8)

Se ptr è un valore puntatore nullo, il comportamento è indefinito

#include <iostream>struct S { mutable int mi;int f(int n){return mi+n;} S(int n): mi(n){}};struct D :public S { D(int n): S(n){}};   int main(){int S::* pmi =&S::mi;int(S::*mpf)(int)=&S::f;   const S s(7);// s.*pmi = 10; // cannot modify through mutablestd::cout<< s.*pmi <<'\n';   D d(7);// base pointers work with derived object D* dp =&d;std::cout<<(d.*mpf)(7)<<' '<<(dp->*mpf)(8)<<'\n';}

Output:

7 14 15

[modifica]Libreria standard

Operatore Pedice è sovraccaricato da molte classi contenitore standard


operator[]	accede specifico bit Original: accesses specific bit The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	fornisce l'accesso indicizzato alla matrice gestita Original: provides indexed access to the managed array The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	accede al carattere richiesto (metodo pubblico)[modifica]

operator[]	accedere elemento specificato Original: access specified element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	accedere elemento specificato Original: access specified element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	accedere elemento specificato Original: access specified element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	accedere elemento specificato Original: access specified element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	accedere elemento specificato Original: access specified element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	accede a un elemento in base all'indice Original: accesses an element by index The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	ottiene rvalue riferimento all'elemento indicizzati Original: obtains rvalue reference to indexed element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator[]	get / set elemento valarray, fetta, o maschera Original: get/set valarray element, slice, or mask The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator[]	rendimenti indicati sub-partita Original: returns specified sub-match The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

Gli operatori di accesso riferimento indiretto e membro sono sovraccaricati da molti iteratori e classi puntatore intelligente


operator* operator->	dereferenzia puntatore all'oggetto gestito Original: dereferences pointer to the managed object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator* operator->	dereferenzia puntatore all'oggetto gestito Original: dereferences pointer to the managed object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator* operator->	accede l'oggetto gestito Original: accesses the managed object The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator*	restituisce un riferimento a questo raw_storage_iterator Original: returns a reference to this raw_storage_iterator The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator* operator->	dereferenzia l'iteratore decrementato sottostante Original: dereferences the decremented underlying iterator The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)[modifica]

operator*	no-op (metodo pubblico)

operator*	no-op (metodo pubblico)

operator*	no-op (metodo pubblico)

operator* operator->	accede alla punta-all'elemento Original: accesses the pointed-to element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator* operator->	ottiene una copia della corrente element accesses membro dell'elemento corrente Original: obtains a copy of the current element accesses a member of the current element The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator*	no-op (metodo pubblico)

operator* operator-> (dal C++11)	ottiene una copia della corrente character accesses un membro del carattere corrente, se `CharT` ha membri Original: obtains a copy of the current character accesses a member of the current character, if `CharT` has members The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator*	no-op (metodo pubblico)

operator* operator->	accede alle attuali match accesses un membro della partita in corso Original: accesses the current match accesses a member of the current match The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

operator* operator->	accede al corrente result accesses un membro del risultato corrente Original: accesses the current result accesses a member of the current result The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (metodo pubblico)

{{{1}}}

[modifica]Vedi anche

Precedenza degli operatori

Common operators
assegnazione	incrementǊdecrement	aritmetica	logico	confronto	memberǊaccess	altra
a = b a = rvalue a += b a -= b a *= b a /= b a %= b a &= b a \|= b a ^= b a <<= b a >>= b	++a --a a++ a--	+a -a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b	!a a && b a \|\| b	a == b a != b a < b a > b a <= b a >= b	a[b] a &a a->b a.b a->b a.*b	a(...) a, b (type) a ?:
Special operators
`static_cast` converte un tipo a un altro tipo compatibile Original: `static_cast` converts one type to another compatible type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `dynamic_cast` converte classe virtuale di base per class derivato Original: `dynamic_cast` converts virtual base class to derived class The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `const_cast` converte il tipo di tipo compatibile con diversi cv qualifiers Original: `const_cast` converts type to compatible type with different cv qualifiers The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `reinterpret_cast` converte tipo type incompatibile Original: `reinterpret_cast` converts type to incompatible type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `new` alloca memory Original: `new` allocates memory The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `delete` dealloca memory Original: `delete` deallocates memory The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `sizeof` interroga la dimensione di un type Original: `sizeof` queries the size of a type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `sizeof...` interroga le dimensioni di un parametro confezione(dal C++11) Original: `sizeof...` queries the size of a parametro confezione(dal C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `typeid` interroga le informazioni sul tipo di una type Original: `typeid` queries the type information of a type The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `noexcept` controlla se un'espressione può lanciare una (dal C++11) un'eccezione Original: `noexcept` checks if an expression can throw an exception (dal C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. `alignof` query requisiti di allineamento di un (dal C++11) tipo Original: `alignof` queries alignment requirements of a type (dal C++11) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Linguaggio
Concetti
Libreria di Utilità
Stringhe
Contenitori
Algoritmi
Iteratori
Libreria matematca
Input/output
Localizzazione
Espressioni regolari(C++11)
Operazioni atomicche(C++11)
Multithreading(C++11)

cppreference.com

Namespace

Varianti

Visite

Azioni

Member access operators

Indice

[modifica]Spiegazione

[modifica]Built-in operatore pedice

[modifica]Built-in operatore di rinvio

[modifica]Built-in operatore di indirizzo

[modifica]Built-in operatori di accesso utente

[modifica]Built-in puntatore a terzi operatori di accesso

[modifica]Libreria standard

[modifica]Vedi anche

Navigazione

Strumenti