Declaring functions

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]

Una dichiarazione di funzione introduce il nome della funzione e il suo tipo. Essa può apparire in qualsiasi ambito, ed è comunemente messo in file di intestazione.


ret`name(`params`);`	(1)

ret`name(`params`)`cvrefexceptattr`;`	(2)

`autoname(`params`)`cvrefexceptattr`->`ret`;`	(3)	(dal C++11)

Una definizione di funzione fornisce il corpo di una funzione. Può apparire solo nel namespace o classe.


decl`name(`params`){`body`}`	(4)

attrdecl`name(`params`)`cvrefexceptattrvirt`try`init-list`{`body`}` catch	(5)

attrdecl`name(`params`)`cvrefexceptattr`->`retvirt`try`init-list`{`body`}` catch	(6)	(dal C++11)

attrdecl`name(`params`)`cvrefexceptattrvirt`= 0 ;`	(7)

attrdecl`name(`params`)`cvrefexceptattrvirt`= default ;`	(8)	(dal C++11)

attrdecl`name(`params`)`cvrefexceptattrvirt`= delete ;`	(9)	(dal C++11)

[modifica]Spiegazione

1)

Dichiarazione di funzione tipica

2)

Dichiarazione di funzione completa

3)

Dichiarazione di funzione completa con tipo di ritorno finale

4)

Tipico non membro funzione definizione

5)

Definizione di funzione completa

6)

Definizione di funzione completa con tipo di ritorno finale

7)

Pure funzione membro virtuale

8)

Funzione membro inadempiente

9)

Soppresso funzione membro

attr(C++11)

-

Sequenza opzionale di qualsiasi numero di funzione di attributi, come [[noreturn]] o [[carries_dependency]]. Può comparire sia prima che dopo il nome della funzione

ret

-

il tipo restituito dalla funzione, può essere void se la funzione restituisce nulla. Non può essere array o tipo di funzione, anche se può essere un puntatore o un riferimento a tale. Obbligatorio per tutte le funzioni ad eccezione di costruttori, distruttori, e gli operatori di conversione, che non devono fornire un tipo di ritorno .

decl

-

dichiarazione di successione specificatore, che consiste di nessuno o alcune delle seguenti parole chiave: statica, extern, inline, virtual, explicit, friend, constexpr, in combinazione con il tipo restituito, ret

{{par | cv |{{tr| Opzionale const, volatile o constvolatile, applicabile solo ai non statici funzioni membro. Per una funzione membro di T classe, il tipo di [[cpp / lingua / questo| Optional const, volatile, or constvolatile, only applicable to non-static member functions. For a member function of class T, the type of the [[cpp/language/this}}|this pointer]] will be const T*, volatile T*, or constvolatile T* respectively. A member function declared const cannot modify members of *this.}}

ref(C++11)

-

Opzionale & o &&, applicabile solo ai non statici altre funzioni membro di costruttori o distruttori. Per una funzione membro di T classe, il tipo del parametro oggetto implicito ai fini della risoluzione di sovraccarico sarà T& o T&& rispettivamente: a && qualificato funzione membro può essere chiamato solo su un'espressione oggetto rvalue

except

-

sia dinamico-specifica eccezioni o noexcept-specifica

virt(C++11)

-

Opzionale override o final, applicabile solo ai non statici funzioni membro

->ret(C++11)

-

Trailing tipo di ritorno, applicabile solo se è retauto. Utile se il tipo dipende nomi degli argomenti, come template<class T, class U>auto add(T t, U u)-> decltype(t + u); o è complicato, come in auto fpif(int)->int(*)(int)

init-list

-

Costruttore inizializzatore lista, utilizzato solo nei costruttori

try

-

Funzione opzionale blocco try. Se presente, catch deve essere fornito

catch

-

Sequenza opzionale di catch-blocchi, applicabile solo su try viene utilizzato .

body

-

Il corpo della funzione, una (eventualmente vuoto) un'istruzione composta

params

-

La lista dei parametri

[modifica]Esempio 1: non membri funzioni

#include <iostream>#include <string>   // declaration in namespace(file) scope// (the definition is provided later)int f1();   // simple function with a default argument, returning nothingvoid f0(conststd::string& arg ="world"){std::cout<<"Hello, "<< arg <<'\n';}   // function returning a pointer to f0auto fp11()->void(*)(conststd::string&){return f0;}   // function returning a pointer to f0, pre-C++11 stylevoid(*fp03())(conststd::string&){return f0;}   int main(){ f0(); fp11()("test"); fp03()("again");int f2(std::string);// declaration in function scopestd::cout<< f2("bad12")<<'\n';}   // simple non-member function returning intint f1(){return42;}   // function with an exception specification and a function try blockint f2(std::string str)noexcepttry{returnstd::stoi(str);}catch(conststd::exception& e){std::cerr<<"stoi() failed!\n";return0;}

Output:

Hello, world Hello, test Hello, again stoi() failed! 0

[modifica]Esempio 2: funzioni membro

#include <iostream>#include <string>#include <utility>#include <exception>   struct S {int data;   // simple converting constructor (declaration) S(int val);   // simple explicit constructor (declaration)explicit S(std::string str);   // const member function (definition)virtualint getData()const{return data;}   };   // definition of the constructor S::S(int val): data(val){std::cout<<"ctor1 called, data = "<< data <<'\n';}   // this constructor has a catch clause S::S(std::string str)try: data(std::stoi(str)){std::cout<<"ctor2 called, data = "<< data <<'\n';}catch(conststd::exception&){std::cout<<"ctor2 failed, string was '"<< str <<"'\n";throw;// ctor's catch clause should always rethrow}   struct D : S {int data2;// constructor with a default argument D(int v1, int v2 =11): S(v1), data2(v2){}   // virtual member functionint getData()const override {return data*data2;}   // lvalue-only assignment operator D& operator=(D other)&{std::swap(other.data, data);std::swap(other.data2, data2);return*this;}};   int main(){ D d1 =1; S s2("2");try{ S s3("not a number");}catch(conststd::exception&){}std::cout<< s2.getData()<<'\n';   D d2(3, 4); d2 = d1;// OK: assignment to lvalue// D(5) = d1; // ERROR: no suitable overload of operator=}

Output:

ctor1 called, data = 1 ctor2 called, data = 2 ctor2 failed, string was 'not a number' 2 ctor1 called, data = 3

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

Declaring functions

[modifica]Spiegazione

[modifica]Esempio 1: non membri funzioni

[modifica]Esempio 2: funzioni membro

Navigazione

Strumenti