Come usare il vettore C ++

Un array è una serie di stessi tipi di oggetti in posizioni di memoria consecutive. Un array non può aumentare la riduzione del minerale di lunghezza. Un vettore è come un array, ma la sua lunghezza può essere aumentata o ridotta. Un vettore, quindi, ha molte più operazioni che un array. C ++ ha molte librerie, tutte che formano la libreria standard C ++. Una di queste biblioteche è la libreria del contenitore. Un contenitore è una raccolta di oggetti e alcune operazioni possono essere eseguite sulla raccolta. I contenitori C ++ possono essere raggruppati in due set: contenitori di sequenza e contenitori associativi. I contenitori di sequenza sono vettoriali, array (non lo stesso array discusso in precedenza), deque, forward_list ed elenco. Queste sono raccolte diverse (strutture di dati simili a array) e ognuna offre distinti compromessi. Qualsiasi programmatore dovrebbe sapere come decidere se utilizzare un vettore, un array, un deque, un forward_list o un elenco. Quando un programmatore ha bisogno di una struttura che richieda più operazioni rispetto a quelle associate a un array normale, l'array ordinario non dovrebbe essere utilizzato. Se l'attività comporta inserzioni e eliminazioni frequenti nel mezzo della sequenza, è necessario utilizzare un elenco o forward_list. Se l'attività comporta inserzioni e eliminazioni frequenti all'inizio o alla fine di una sequenza, dovrebbe essere usato un deque. Un vettore dovrebbe essere usato quando non sono richiesti questo tipo di operazioni. Questo articolo mostra come utilizzare il vettore C ++. Avrai bisogno di una certa conoscenza di puntatori, riferimenti e matrici C ++ per comprendere questo articolo.

Classe e oggetti

Una classe è un insieme di variabili e funzioni che funzionano insieme, in cui le variabili non hanno valori assegnati. Quando i valori vengono assegnati alle variabili, una classe diventa un oggetto. Valori diversi dati alla stessa classe derivano in oggetti diversi; cioè, oggetti diversi possono essere della stessa classe ma hanno valori diversi. La creazione di un oggetto da una classe è anche noto come istanziazione dell'oggetto.

Il termine vettore descrive una classe. Un oggetto creato da un vettore ha un nome scelto dal programmatore.

È necessaria una funzione che appartiene a una classe per istanziare un oggetto dalla classe. In C ++, quella funzione ha lo stesso nome del nome della classe. Oggetti diversi creati (istanziati) dalla classe hanno nomi distinti dati a ciascuno di essi dal programmatore.

Creazione di un oggetto da una classe significa costruire l'oggetto; Significa anche istanziare l'oggetto.

La classe vettoriale

La classe Vector è già stata definita ed è in biblioteca. Per utilizzare la classe vettoriale, un programmatore deve includere l'intestazione vettoriale nel file con la seguente direttiva di preelaborazione:

#includere

Una volta inclusa l'intestazione, tutte le funzionalità vettoriali (membri dei dati e funzioni dei membri) diventano accessibili. Per utilizzare l'oggetto conteggio per output i dati sul terminale (console), l'intestazione dell'oggetto deve anche essere inclusa. Per scrivere un programma con il vettore, come minimo, le seguenti intestazioni devono essere incluse:

#includere
#includere

Istanziare un vettore

int foo [10];

Sopra è la dichiarazione di un array con il nome "foo" e il numero di elementi "10."Questa è una serie di numeri interi. La dichiarazione di un vettore è simile. Per un vettore, il numero di elementi è facoltativo, poiché la lunghezza del vettore può aumentare o diminuire.

A questo punto del programma, la classe Vector è già stata definita nella biblioteca e l'intestazione è stata inclusa. Il vettore può essere istanziato come segue:

Std :: Vector VTR (8);

Qui, il vettore è della funzione di costruttore speciale. Il tipo di dati che il vettore terrà è "int", tra parentesi angolari. Il termine "VTR" è il nome scelto dal programmatore per il vettore. Infine, "8", tra parentesi, è il numero provvisorio di numeri interi che il vettore avrà.

Il termine "std" sta per lo spazio dei nomi standard. Questo termine deve essere seguito da un doppio colon, in questo contesto. Chiunque può scrivere la propria libreria di classe vettoriale e usarla. Tuttavia, C ++ ha già una libreria standard con nomi standard, tra cui "Vector."Per utilizzare un nome standard, il nome standard deve essere preceduto da std :: . Per evitare di digitare Std :: Ogni volta nel programma per un nome standard, il file del programma può iniziare come segue:

#includere
#includere
Utilizzo dello spazio dei nomi std;

Sovraccaricare una funzione

Quando due o più firme della funzione diverse hanno lo stesso nome, si dice che quel nome sia sovraccarico. Quando viene chiamata una funzione, il numero e il tipo di argomenti determinano quale funzione viene eseguita.

Costruire un vettore

Costruire un vettore significa istanzia (creazione) un oggetto vettoriale. La funzione del costruttore è sovraccarica come segue:

Nome vettoriale

Questo crea un vettore di lunghezza zero e tipo “t."La seguente istruzione crea un vettore di lunghezza zero del tipo" float "con il nome" vtr: "

vettore VTR;

Nome vettoriale (N)

Questo crea un vettore con n elementi di tipo “t."Una dichiarazione per questo vettore con quattro elementi galleggianti è la seguente:

vettore VTR (4);

Nome vettoriale (N, T)

Questo crea un vettore di N elementi inizializzati sul valore t. La seguente affermazione crea un vettore di 5 elementi, in cui ogni elemento ha il valore 3.4:

vettore VTR (5, 3.4);

Costruire con l'inizializzazione

Un vettore può essere costruito (creato) e inizializzato contemporaneamente, in uno dei seguenti due modi:

vettore vtr = 1.1, 2.2, 3.3, 4.4;

O

vettore VTR 1.1, 2.2, 3.3, 4.4;

Si noti che non ci sono parentesi subito dopo il nome dell'oggetto. Parentesi usate subito dopo che il nome dell'oggetto dovrebbe avere l'elenco inizializzatore, come segue:

vettore VTR (1.1, 2.2, 3.3, 4.4);

Un vettore può essere costruito e inizializzato in seguito con l'elenco iniziale. In questo caso, le parentesi non verranno utilizzate:

vettore VTR;
vtr = 1.1, 2.2, 3.3, 4.4;

Vector V2 (V1)

Questo è un costruttore di copie. Crea un vettore V2 come copia del vettore V1. Il seguente codice illustra questo:

vettore VTR1 (5, 3.4);
vettore VTR2 (VTR1);

Assegnare un vettore durante la costruzione

Durante la costruzione, è possibile creare un vettore vuoto mentre un altro è assegnato, come segue:

vettore VTR1 1.1, 2.2, 3.3, 4.4;
vettore VTR2 = VTR1;

La seconda affermazione è equivalente a:

vettore vtr2 = 1.1, 2.2, 3.3, 4.4;

const vector

Un vettore const è un vettore i cui elementi non possono essere cambiati. I valori in questo vettore sono di sola lettura. Quando creato, il vettore appare come segue:

const vector VTR 1.1, 2.2, 3.3, 4.4;

In questo tipo di vettore, nessun elemento può essere aggiunto o rimosso. Inoltre, nessun valore può essere modificato.

Costruire con iteratore

Un modello fornisce una rappresentazione generica per un tipo di dati. Un iteratore fornisce una rappresentazione generica della scansione attraverso i valori di un contenitore. La sintassi per creare un vettore con un iteratore è la seguente:

modello
vettore (inputterator first, inputterator Last, const allocatore & = allocatore ());

Ciò costruisce un vettore per l'intervallo [primo, ultimo) utilizzando l'allocatore specificato, che sarà discusso più avanti in questo articolo.

Distruggere un vettore

Per distruggere un vettore, semplicemente permettergli di uscire dalla portata e distruggere viene gestito automaticamente.

Capacità vettoriale

dimensione_type capacità () const noexcept

Il numero totale di elementi che il vettore può trattenere senza richiedere la riallocazione viene restituito dalla funzione membro della capacità. Un segmento di codice per questo è il seguente:

vettore VTR (4);
int num = vtr.capacità();
cout << num << '\n';

L'output è 4.

Riserva (N)

Lo spazio di memoria non è sempre disponibile liberamente. Lo spazio extra può essere riservato in anticipo. Considera il seguente segmento di codice:

vettore VTR (4);
VTR.Riserva (6);
cout << vtr.capacity() << '\n';

L'output è 6. Quindi, lo spazio extra riservato è 6 - 4 = 2 elementi. La funzione restituisce vuoto.

dimensione () const noexcept

Questo restituisce il numero di elementi nel vettore. Il seguente codice illustra questa funzione:

vettore VTR (4);
float sz = vtr.misurare();
cout << sz << '\n';

L'output è 4.

rimpicciolirsi per starci dentro()

Dopo aver dato una capacità aggiuntiva a un vettore con la funzione Riserva (), il vettore può essere dimensionato per adattarsi alla dimensione originale. Il seguente codice illustra questo:

vettore VTR (4);
VTR.Riserva (6);
VTR.rimpicciolirsi per starci dentro();
int sz = vtr.misurare();
cout << sz << '\n';

L'output è 4 e non 6. La funzione restituisce vuoto.

RISIZE (SZ), Ridimension (SZ, C)

Questo ridimensiona il vettore. Se la nuova dimensione è più piccola delle vecchie dimensioni, vengono cancellati gli elementi verso la fine. Se la nuova dimensione è più lunga, allora un valore predefinito viene aggiunto verso la fine. Per avere un particolare valore aggiunto, utilizzare la funzione Ridimeni () con due argomenti. Il seguente segmento di codice illustra l'uso di queste due funzioni:

vettore VTR1 1.1, 2.2, 3.3, 4.4;
VTR1.ridimensionare (2);
cout << "New size of vtr1: " << vtr1.size() << '\n';
vettore VTR2 1.1, 2.2;
VTR2.ridimensionare (4, 8.8);
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

L'output è il seguente:

Nuova dimensione di VTR1: 2
VTR2: 1.1 2.2 8.8 8.8

Le funzioni restituiscono vuoto.

vuoto () const noexcept

Questa funzione restituisce 1 per true se non ci sono elementi nel vettore e 0 per false se il vettore è vuoto. Se un vettore ha 4 posizioni per un particolare tipo di dati, come il galleggiante, senza alcun valore di galleggiamento, allora quel vettore non è vuoto. Il seguente codice illustra questo:

vettore VTR;
cout << vtr.empty() << '\n';
vettore VT (4);
cout << vt.empty() << '\n';
vettore V (4,3.5);
cout << v.empty() << '\n';

L'output è il seguente:

1
0
0

Accesso agli elementi vettoriali

Un vettore può essere sottoscritto (indicizzato) come un array. Il conteggio dell'indice inizia da zero.

vectorname [i]

L'operazione "Vectorname [i]" restituisce un riferimento all'elemento all'i^th indice del vettore. Il seguente codice emette 3.3 per il vettore sopra:

vettore VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr [2];
cout << fl << '\n';

vectorname [i] const

L'operazione "vectorname [i] const" viene eseguita al posto di "vectorname [i]" quando il vettore è un vettore costante. Questa operazione viene utilizzata nel seguente codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr [2];
cout << fl << '\n';

L'espressione restituisce un costante riferimento all'i^th elemento del vettore.

Assegnazione di un valore con il pedice

Un valore può essere assegnato a un vettore non costante, come segue:

vettore VTR 1.1, 2.2, 3.3, 4.4;
VTR [2] = 8.8;
cout << vtr[2] << '\n';

L'output è 8.8.

vectorname.a (i)

“Vectorname.a (i) "è come" vectorname [i] ", ma" vectorname.a (i) "è più affidabile. Il seguente codice mostra come utilizzare questo vettore:

vettore VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr.alle 2);
cout << fl << '\n';
a () è una funzione membro vettoriale.

vectorname.a (i) const

“Vectorname.a (i) const "è come" vectorname [i] const ", ma" vectorname.a (i) const ”è più affidabile. “Vectorname.a (i) const "viene eseguito invece di" vectorname.a (i) ”quando il vettore è un vettore costante. Questo vettore viene utilizzato nel seguente codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr.alle 2);
cout << fl << '\n';
In () const è una funzione membro vettoriale.

Assegnare un valore con la funzione At ()

Un valore può essere assegnato a un vettore non costante con la funzione AT (), come segue:

vettore VTR 1.1, 2.2, 3.3, 4.4;
VTR.a (2) = 8.8;
cout << vtr[2] << '\n';

L'output è 8.8.

Problema con il sottoscrizione

Il problema con il sottoscrizione (indicizzazione) è che se l'indice è fuori portata, zero può essere restituito o un errore può essere emesso a tempo di esecuzione.

davanti()

Ciò restituisce un riferimento al primo elemento del vettore senza rimuovere l'elemento. L'output del seguente codice è 1.1.

vettore VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr.davanti();
cout << fl << '\n';

L'elemento non viene rimosso dal vettore.

Front () const

Quando la costruzione vettoriale è preceduta da const, l'espressione "front () const" viene eseguita al posto di "front ()."Questo viene utilizzato nel seguente codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr.davanti();
cout << fl << '\n';

Viene restituito un riferimento costante. L'elemento non viene rimosso dal vettore.

Indietro()

Ciò restituisce un riferimento all'ultimo elemento del vettore senza rimuovere l'elemento. L'output del seguente codice è 4.4.

vettore VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr.Indietro();
cout << fl << '\n';

Back () const

Quando la costruzione vettoriale è preceduta da const, l'espressione "back () const" viene eseguita invece di "schiena ()."Questo viene utilizzato nel seguente codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
float fl = vtr.Indietro();
cout << fl << '\n';

Viene restituito un riferimento costante. L'elemento non viene rimosso dal vettore.

Accesso ai dati vettoriali

data () noexcept; data () const noexcept;

Uno di questi restituisce un puntatore in modo tale che [data (), data () + size ()) sia un intervallo valido.

Questo sarà trattato in modo più dettagliato più avanti nell'articolo.

Restituire iteratori e il vettore

Un iteratore è come un puntatore ma ha più funzionalità di un puntatore.

Inizia () noAxcept

Restituisce un iteratore che indica il primo elemento del vettore, come nel seguente segmento di codice:

vettore VTR 1.1, 2.2, 3.3, 4.4;
vettore:: iterator iter = vtr.inizio();
cout << *iter << '\n';

L'output è 1.1. Si noti che la dichiarazione che riceve l'iteratore è stata dichiarata. L'iteratore è dereferenziato in un'espressione di ritorno per ottenere il valore allo stesso modo in cui un puntatore è dereferencing.

inizio () const noexcept;

Restituisce un iteratore che indica il primo elemento del vettore. Quando la costruzione vettoriale è preceduta da const, l'espressione "inizio () const" viene eseguita invece di "inizio ()."In questa condizione, l'elemento corrispondente nel vettore non può essere modificato. Questo viene utilizzato nel seguente codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
vettore:: const_iterator iter = vtr.inizio();
cout << *iter << '\n';

L'output è 1.1. Si noti che questa volta è stato usato "const_iterator" invece di solo "iteratore" per ricevere l'iteratore restituito.

end () noexcept

Restituisce un iteratore che indica immediatamente oltre l'ultimo elemento del vettore. Considera il seguente segmento di codice:

vettore VTR 1.1, 2.2, 3.3, 4.4;
vettore:: iterator iter = vtr.FINE();
cout << *iter << '\n';

L'output è 0, il che non ha senso, in quanto non esiste un elemento concreto oltre l'ultimo elemento.

end () const noexcept

Restituisce un iteratore che indica immediatamente oltre l'ultimo elemento del vettore. Quando la costruzione vettoriale è preceduta da "const", l'espressione "end () const" viene eseguita al posto di "fine ()."Considera il seguente segmento di codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
vettore:: const_iterator iter = vtr.FINE();
cout << *iter << '\n';

L'output è 0. Si noti che questa volta è stato usato "const_iterator" invece di solo "iteratore" per ricevere l'iteratore restituito.

Iterazione inversa

È possibile avere un iteratore che itera dalla fine non sia prima del primo elemento.

rbegin () noexcept

Restituisce un iteratore che indica l'ultimo elemento del vettore, come nel seguente segmento di codice:

vettore VTR 1.1, 2.2, 3.3, 4.4;
vettore:: revers_iterator riter = vtr.rbegin ();
cout << *rIter << '\n';

L'output è 4.4.

Si noti che è stata dichiarata la dichiarazione che riceve l'iteratore inverso. L'iteratore è dereferenziato in un'espressione di ritorno per ottenere il valore allo stesso modo in cui un puntatore è dereferencing.

rbegin () const noexcept;

Restituisce un iteratore che indica l'ultimo elemento del vettore. Quando la costruzione vettoriale è preceduta da "const", l'espressione "rbegin () const" viene eseguita al posto di "rbegin ()."In questa condizione, l'elemento corrispondente nel vettore non può essere modificato. Questa funzione viene utilizzata nel seguente codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
vettore:: const_reverse_iterator riter = VTR.rbegin ();
cout << *rIter << '\n';

L'output è 4.4.

Si noti che questa volta il const_reverse_iterator è stato utilizzato, anziché solo il reverse_iterator, per ricevere l'iteratore restituito.

Rend () noAxcept

Restituisce un iteratore che punta appena prima del primo elemento del vettore. Considera il seguente segmento di codice:

vettore VTR 1.1, 2.2, 3.3, 4.4;
vettore:: revers_iterator riter = vtr.rend ();
cout << *rIter << '\n';

L'output è 0, il che non è insignificante, in quanto non esiste un elemento concreto appena prima del primo elemento.

Rend () const noexcept

Restituisce un iteratore che punta appena prima del primo elemento del vettore. Quando la costruzione vettoriale è preceduta da "const", l'espressione "rend () const" viene eseguita al posto di "rend ()."Considera il seguente segmento di codice:

const vector VTR 1.1, 2.2, 3.3, 4.4;
vettore:: const_reverse_iterator riter = VTR.rend ();
cout << *rIter << '\n';

L'output è 0.

Si noti che questa volta il const_reverse_iterator è stato utilizzato, anziché solo il reverse_iterator, per ricevere l'iteratore restituito.

Modificatori vettoriali

Un modificatore che modifica il vettore può prendere o restituire un iteratore.

UN.emplace (p, args)

Inserire un oggetto di tipo T costruito con std :: forward (args) ... prima di p.

Per i dettagli - vedi più tardi

inserisci (iteratorposition, valore)

Inserisce una copia del valore nella posizione dell'iteratore del vettore. Restituisce l'iteratore (posizione) nel vettore in cui è stata inserita la copia. Il seguente codice mostra dove è stato inserito il valore:

vettore VTR 10, 20, 30, 40;
vettore:: iterator iter = vtr.inizio();
++iter;
++iter;
VTR.Inserisci (Iter, 25);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3] << '\n';

L'output è: 20 25 30.

Si noti che l'iteratore era avanzato (incrementato) proprio come un puntatore.

È inoltre possibile inserire un elenco di inizializzatori, come illustra il seguente codice:

vettore VTR 10, 20, 30, 40;
vettore:: iterator iter = vtr.inizio();
++iter;
++iter;
VTR.insert (iter, 25, 28);
cout << vtr[1] << " << vtr[2]<< '
' << vtr[3]<< " << vtr[4] << '\n';

L'output è: 20 25 28 30.

Cancella (posizione)

Rimuove un elemento nella posizione puntata dall'iteratore, quindi restituisce la posizione dell'iteratore. Il seguente codice illustra questo:

vettore VTR 10, 20, 30, 40;
vettore:: iterator iter = vtr.inizio();
++iter;
++iter;
VTR.cancella (iter);
cout << vtr[0] << " << vtr[1] << '
' << vtr[2]<< '\n';

L'output è: 10 20 40

push_back (t), push_back (RV)

Utilizzato per aggiungere un singolo elemento alla fine del vettore. Usa push_back (t) come segue:

vettore VTR 1.1, 2.2, 3.3, 4.4;
VTR.push_back (5.5);
float fl = vtr [4];
cout << fl << '\n';

L'output è 5.5.

push_back (rv): - vedi più tardi.

pop_back ()

Rimuove l'ultimo elemento senza restituirlo. La dimensione del vettore è ridotta di 1. Il seguente codice illustra questo:

vettore VTR 1.1, 2.2, 3.3, 4.4;
VTR.pop_back ();
float sz = vtr.misurare();
cout << sz << '\n';

L'output è 3.

UN.scambiare (b)

Due vettori possono essere scambiati, come illustrato nel seguente segmento di codice:

vettore VTR1 1.1, 2.2, 3.3, 4.4;
vettore vtr2 10, 20;
VTR1.swap (vtr2);
cout << "vtr1: "<< vtr1[0] <<" "<< vtr1[1] <<"
"<< vtr1[2] <<" "<< vtr1[3] << '\n';
cout << "vtr2: "<< vtr2[0] <<" "<< vtr2[1] <<"
"<< vtr2[2] <<" "<< vtr2[3] << '\n';

L'output è:

VTR1: 10 20 0 0
VTR2: 1.1 2.2 3.3 4.4

Si noti che la lunghezza di un vettore è aumentata, se necessario. Inoltre, i valori che non avevano sostituzioni sono sostituiti da un valore predefinito.

chiaro()

Rimuove tutti gli elementi dal vettore, come illustra il seguente segmento di codice:

vettore VTR 1.1, 2.2, 3.3, 4.4;
VTR.chiaro();
cout << vtr.size() << '\n';

L'output è 0.

Uguaglianza e operatori relazionali per vettori

L'operatore ==

Restituisce 1 per true se i due vettori hanno le stesse dimensioni e gli elementi corrispondenti sono uguali; Altrimenti, restituisce 0 per false. Per esempio:

vettore U 1, 2, 3;
vettore V 4, 5, 6;
bool bl = u == V;
cout << bl << '\n';

L'output è 0.

IL != Operatore

Restituisce 1 per true se i due vettori non hanno le stesse dimensioni e/o gli elementi corrispondenti non sono uguali; Altrimenti, restituisce 0 per false. Per esempio:

vettore U 1, 2, 3;
vettore V 4, 5, 6;
bool bl = u!= V;
cout << bl << '\n';

L'output è 1.

IL < Operator

Restituisce 1 per true se il primo vettore è il sottoinsieme iniziale del secondo vettore, con gli elementi delle due parti uguali che sono uguali e nello stesso ordine. Se entrambi i vettori hanno le stesse dimensioni e si muovono da sinistra a destra e si incontra un elemento nel primo vettore che è inferiore all'elemento corrispondente nel secondo vettore, allora verrà comunque restituito. Altrimenti, 0 per false viene restituito. Per esempio:

vettore U 3, 1, 1;
vettore V 3, 2, 1;
bool bl = ucout << bl << '\n';

L'output è 1. < does not include the case when the size and order are the same.

L'operatore>

ritorna !(U < V), where U is the first vector and V is the second vector, according to the above definitions.

IL <= Operator

Restituisce u <= V, where U is the first vector and V is the second vector, according to the above definitions.

L'operatore> =

ritorna !(U <= V), where U is the first vector and V is the second vector, according to the above definitions.

Conclusione

Un vettore è un esempio di contenitore di sequenza. Un vettore è una forma "migliore" dell'array ordinario ed è istanziato da una classe. I vettori hanno metodi classificati in: costruzione e assegnazione, capacità, accesso agli elementi, accesso ai dati, iteratori, modificatori e operatori numerici sovraccarichi.

Ci sono altri contenitori di sequenza, chiamati elenco, forward_list e array. Se l'attività comporta inserzioni e eliminazioni frequenti nel mezzo della sequenza, è necessario utilizzare un elenco o forward_list. Se l'attività comporta inserzioni e eliminazioni frequenti all'inizio o alla fine della sequenza, dovrebbe essere usato un deque. E così, i vettori dovrebbero essere usati solo quando questi tipi di operazioni non sono importanti.