Gli esempi che abbiamo considerato finora hanno dimostrato input/output formattato di informazioni su file. Si consiglia di utilizzare l'input/output di file formattato di numeri solo quando sono piccoli e di numero ridotto, e anche quando è necessario fornire la possibilità di visualizzare i file utilizzando strumenti non software. Altrimenti, ovviamente, è molto più efficiente utilizzare l'I / O binario, in cui i numeri sono memorizzati allo stesso modo dell'OP del computer e non sotto forma di stringhe di caratteri. Lascia che ti ricordi che un valore intero (int) o reale (float) occupa 4 byte in memoria, un valore doppio - 8 byte e un valore char - 1 byte. Ad esempio, il numero 12345 in un file di testo (formattato) è 5 byte e in un file binario è 4 byte.

File binari, cioè. i file in cui le informazioni sono memorizzate nella forma interna di presentazione sono utilizzati per un successivo utilizzo da parte di software, non possono essere visualizzati da software non. Il vantaggio dei file binari è che, in primo luogo, durante la lettura/scrittura, non si perde tempo per convertire i dati dalla rappresentazione simbolica a quella interna e viceversa, e in secondo luogo, non si perde la precisione dei numeri reali. Come nel caso di input/output formattato, e nel caso di input/output binario, per una "corretta" elaborazione delle informazioni da un file, è necessario sapere quali tipi di dati, come e in quale sequenza vengono scritti su un file binario, soprattutto perché la visualizzazione di un file binario utilizzando un editor di testo non farà nulla.

Considera un esempio che dimostra la scrittura di elementi interi di un array dinamico in un file binario e la loro lettura da questo file.

#includere

#includere

#includere

usando lo spazio dei nomi std;

cout<< "Vvedite kol-vo elementov celochisl. massiva: "; cin >> N;

int * mas = nuovo int [N];

per (i = 0; i

cout<< " Vvedite " << i << "-i element: "; cin >> ma [i];

cout<< "\nIdet zapis dannyh v fail..." << endl;

ofstream fout ("c: \\ os \\ bin.dat", ios :: binary);// creare fuori. flusso binario

if (! fout) (cout<< "\n Oshibka otkrytiya faila!"; getch(); return 1; }

fout.write (reinterpret_cast (mas), N * sizeof (int));// scrivi array su file

fout.close ();// chiudi il flusso

cout<< "Dannye uspeshno zapisany!" << endl;

per (i = 0; i

ifstream fin ("c: \\ os \\ bin.dat", ios :: binary); // crea uno stream per leggere il file

if (! fin) (cout<< "\n Oshibka otkrytiya faila!"; getch(); return 1; }

cout<< "Fail sodergit:" << endl;

fin.read (reinterpret_cast (mas), N * sizeof (int));// legge l'array dal file

per (i = 0; i

getch (); restituisce 0;

Particolare attenzione in questo programma dovrebbe essere prestata all'uso di write() (metodo della classe ofstream) e read() (metodo della classe ifstream). Queste funzioni pensano ai dati in termini di byte e sono progettate per trasferire un numero specificato di byte dal buffer di dati a un file e viceversa. I parametri di queste funzioni sono l'indirizzo del buffer e la sua lunghezza in byte.

La funzione write() è progettata per scrivere su un file il numero di byte specificato nel secondo parametro da quello specificato nel primo parametro indirizzi buffer di dati e la funzione read() serve per leggere i dati da un file. Va notato qui che queste funzioni operano solo su un buffer di dati di tipo char. A tal proposito, in questo programma abbiamo utilizzato l'operatore reinterpret_cast<> che converte il nostro buffer di dati di tipo int (mas) in un buffer di tipo char.

Si ricorda che digitare colata utilizzando l'operatore reinterpret_cast è necessario solo nei casi in cui il primo parametro delle funzioni scrivere () e leggere () non è un array di caratteri (dopotutto, un carattere di tipo char occupa solo 1 byte). Inoltre, se è necessario scrivere o leggere non un array, ma variabili separate, è necessario utilizzare un meccanismo di riferimento (riferimento all'indirizzo del buffer di dati), ad esempio:

ofstream fout (nome file, ios :: app | ios :: binario);

fout.write (reinterpret_cast (& cb), sizeof (float));

Ora è necessario discutere il secondo parametro delle funzioni considerate. In questo programma, come secondo parametro, abbiamo utilizzato l'espressione N * sizeof (int), con la quale abbiamo calcolato il numero di byte. Ad esempio, se abbiamo 5 elementi di array interi, il numero di byte sarà 20. La funzione sizeof() restituisce il numero di byte allocati per il tipo di dati specificato come parametro. Ad esempio sizeof ( int) restituirà 4.

Quindi, il programma mostrato in questo esempio consente di scrivere dati in formato binario nel file bin.dat e leggerli da questo file binario. Inoltre, dopo la lettura, questi dati vengono convertiti nel tipo int, acquisiscono la struttura di un array e con esso è possibile eseguire qualsiasi operazione.

Ora, immagina di dover scrivere un programma che ti permetta di leggere i dati dal file bin.dat, e sappiamo solo che questo file contiene elementi di un array di interi in forma binaria. Il numero di elementi registrati ( n ) noi non sappiamo... Quando creiamo un programma, non abbiamo il diritto di utilizzare un array costante, ad es. allocare memoria per esso nella fase di creazione del programma. Ciò porterà a un risultato errato. Poiché un valore di N troppo piccolo porterà al fatto che non tutti gli elementi dell'array vengono contati, e un valore di N troppo grande porterà a riempire celle extra con valori casuali.

Consideriamo un esempio di un programma che consente di leggere elementi di un array di interi da un file binario allocando dinamicamente la memoria e, per dimostrare il realismo dei dati letti, calcolarne la somma.

#includere

#includere

#includere

usando lo spazio dei nomi std;

int N, i, somma = 0, dfb; // dfb - lunghezza del file in byte

ifstream fin ("c: \\ os \\ bin.dat", ios :: binario);

if (! fin) (cout<< "Oshibka otkrytiya faila!"; getch(); return 1; }

fin.seekg (0, ios :: end);// imposta la posizione di lettura alla fine del file (dalla fine di 0 byte)

dfb = fin.tellg ();// ottiene il valore della posizione di fine file (in byte)

N = dfb / 4;// sapendo che un numero intero occupa 4 byte, calcola il numero di numeri

int * arr = nuovo int [N];// crea un array dinamico

fin.seekg (0, ios :: beg);// prima di leggere i dati, spostiamo la posizione corrente all'inizio del file

fin.read (reinterpret_cast (arr), dfb);

cout<< "Iz faila schitano " << N << " elementov:" << endl;

per (i = 0; i

per (i = 0; i

cout<< "\n Ih summa = " << sum;

getch (); restituisce 0;

Consideriamo in dettaglio questo programma, in cui abbiamo utilizzato attivamente le funzioni seekg() e tellg(), che sono metodi della classe ifstream. Va notato qui che a qualsiasi file quando viene aperto, viene associata la cosiddetta posizione corrente di lettura o scrittura... Quando un file viene aperto per la lettura, questa posizione è impostata per impostazione predefinita all'inizio del file. Ma molto spesso è necessario controllare manualmente la posizione per poter leggere e scrivere, partendo da una posizione arbitraria nel file. Le funzioni seek () e tellg () consentono di impostare e controllare il puntatore di lettura corrente e le funzioni seep () e tellp () fanno lo stesso per il puntatore di scrittura.

Il metodo seekg (1_option, 2_parameter) sposta la posizione di lettura corrente dal file del numero di byte specificato in 1_option rispetto alla posizione specificata in 2_option. 2_parameter può assumere uno dei tre valori:

ios :: beg - dall'inizio del file;

ios :: cur - dalla posizione corrente;

ios :: end - dalla fine del file.

Qui beg, cur e end sono costanti definite nella classe ios, ei simboli :: denotano un'operazione di accesso a questa classe. Ad esempio, l'operatore fin.seekg (-10, ios :: end); consente di impostare la posizione di lettura corrente dal file 10 byte prima della fine del file.

Torniamo ora alla descrizione del programma. In base al fatto che non conosciamo il numero di numeri scritti nel file, dobbiamo prima scoprire il numero di numeri. Per fare ciò, usando fin.seekg (0, ios :: end); ci spostiamo alla fine del file e utilizziamo la funzione tellg() per restituire la lunghezza del file in byte alla variabile dfb. La funzione tellg() restituisce la posizione corrente del puntatore in byte. Poiché conosciamo la lunghezza di un intero in byte (4 byte), è facile calcolare il numero di numeri scritti nel file, conoscendo la lunghezza del file in byte ( N = dfb / 4;). Dopo aver scoperto il numero di numeri, creiamo un array dinamico e ci spostiamo all'inizio del file per iniziare a leggere i dati utilizzando la funzione read(). Dopo che il numero indicato di byte di dati (dfb) è stato trasferito nel buffer di dati (arr), i dati letti in questo modo acquisiscono una struttura ad array e diventano pienamente adatti a qualsiasi tipo di operazione e trasformazione.

Nell'esempio sopra, l'opzione "più lunga" è "b": richiede 23 byte (21 byte per una stringa e 2 byte per un numero intero). Per le opzioni "n" e "m" sono necessari rispettivamente 4 e 5 byte (vedi tabella).

nome, articolo dell'editore parte variante

File binari

I file binari memorizzano le informazioni nella forma in cui sono rappresentate nella memoria del computer e quindi sono scomodi per gli esseri umani. Esaminando un file del genere, è impossibile capire cosa c'è scritto in esso; non può essere creato o corretto manualmente - in alcuni editor di testo - ecc. Tuttavia, tutti questi inconvenienti sono compensati dalla velocità di lavoro con i dati.

Inoltre, i file di testo sono strutture ad accesso sequenziale e quelli binari sono strutture ad accesso diretto. Ciò significa che in qualsiasi momento puoi fare riferimento a chiunque, non solo all'elemento corrente del file binario.

File digitati

Le variabili dei tipi di dati strutturati (diversi dalle stringhe) non possono essere lette da un file di testo. Ad esempio, se è necessario inserire dati da un file di testo per riempire il record del giocattolo con informazioni sui giocattoli disponibili per la vendita (nome del prodotto, prezzo del prodotto e fascia di età per la quale è destinato il giocattolo):

età: set di 0..18; (definito dai limiti nel file)

quindi devi scrivere il seguente codice:

c: carattere; i, j, min, max: intero;

a: serie di giocattoli;

iniziare ad assegnare (f, input); resettare (f);

per i: = da 1 a 100 do se non eof (f)

poi con un [i] do

inizio readln (f, nome, prezzo, min, max); età: =;

for j: = da min a max do age: = age + [j];

Come puoi vedere, tale lettura elemento per elemento è molto scomoda e laboriosa.

Una via d'uscita da questa situazione è offerta file digitati- i loro elementi possono essere di qualsiasi tipo di dati di base o strutturati. L'unica limitazione è che tutti gli elementi devono essere dello stesso tipo. Questo apparente inconveniente è

condizione indispensabile per organizzare l'accesso diretto agli elementi di un file binario: come nel caso degli array, se si conosce esattamente la lunghezza di ogni componente della struttura, allora l'indirizzo di ogni componente può essere calcolato utilizzando una formula molto semplice:

<начало_структуры> + <номер_компонента>*<длина_компонента>

Descrizione dei file digitati

Nella sezione var, variabili di file con cui lavorare file digitati sono descritti come segue:

varia<файловая_перем>: file di<тип_элементов_файла>;

Nessuna variabile di file può essere costante.

Scopo di un file digitato

Da questo momento fino alla fine della sezione, sotto la parola "file" intendiamo " file di tipo binario"(ovviamente, salvo diversa indicazione).

Squadra assegnare (f, "<имя_файла>"); serve a stabilire una connessione tra la variabile del file fe il nome del file di cui questa variabile sarà responsabile.

Linea "<имя_файла>"può contenere il percorso completo del file. Se il percorso non è specificato, il file viene considerato situato nella stessa directory del modulo eseguibile del programma.

Apertura e chiusura di un file digitato

A seconda delle azioni che il tuo programma farà con il file che viene aperto, può essere aperto in due modi:

resettare (f); - aprire un file per leggere informazioni da esso e allo stesso tempo scriverci (se tale file non esiste, un tentativo di aprirlo causerà un errore). Lo stesso comando viene utilizzato per restituire un puntatore all'inizio del file;

riscrivi (f); - aprire un file per scrivere informazioni in esso; se tale file non esiste, verrà creato; se esiste già un file con lo stesso nome, tutte le informazioni precedentemente contenute in esso scompariranno.

stanno chiudendo file digitati chiusura della procedura (f), comune a tutti i tipi di file.

Lettura da un file digitato

La lettura da un file aperto per la lettura viene eseguita utilizzando il comando read(). Il nome della variabile del file è indicato prima tra parentesi, seguito dall'elenco di input1):

Da un file è possibile immettere solo variabili della dichiarazione del tipo corrispondente, ma anche questo tipo di dati può essere strutturato. Diciamo, se torniamo all'esempio dato all'inizio di p. " File digitati", diventerà ovvio che l'uso di file digitato invece del testo, ridurrà significativamente il testo del programma:

tipo giocattolo = nome record: stringa; prezzo: reale;

età: set di 0..18; (dato dai confini)

var f: file del giocattolo;

a: serie di giocattoli; inizio

assegnare (f, input);

per i: = da 1 a 100 do

se non eof (f) allora leggi (f, a [i]); chiudere (f);

Cerca in un file digitato

La familiare funzione eof (f: file): booleana segnala la fine del file raggiunta. Tutte le altre funzioni di "ricerca finale" (eoln(), seekeof(), andseekeoln()) comuni ai file di testo non possono essere applicate ai file digitati.

Ma ci sono subroutine speciali che ti permettono di lavorare con file digitati come per le strutture ad accesso diretto:

1. La funzione filepos (f: file): longint riporterà la posizione corrente del puntatore nel file f. Se punta alla fine di un file contenente N elementi, questa funzione restituirà il risultato N. Questo è facilmente spiegabile: gli elementi del file sono numerati a partire da zero, quindi l'ultimo elemento è numerato N-1. E il numero N appartiene, quindi, a un elemento "inesistente" - un segno della fine del file.

2. La dimensione del file (f: file): la funzione longint calcolerà la lunghezza del file f.

3. La procedura di ricerca (f: file, n: longint) sposterà il puntatore nel file f all'inizio del record n. Se risulta che n è maggiore della lunghezza effettiva del file, il puntatore verrà spostato oltre la fine reale del file.

4. La procedura troncare (f: file) tronca la "coda" del file f: tutti gli elementi dal corrente alla fine del file verranno rimossi da esso. In effetti, solo la funzione "fine del file" verrà riscritta nel punto in cui puntava il puntatore e i valori fisicamente "tagliati" rimarranno negli stessi punti: diventeranno semplicemente "senza proprietario".

Scrivere su un file digitato

È possibile salvare le variabili in un file aperto per la scrittura utilizzando il comando write(). Come nel caso della lettura, viene specificata prima la variabile del file, seguita dalla lista di output:

scrivere (f, a, b, c); - scrivere nel file f (precedentemente aperto per la scrittura dai comandi rerite (f) o reset (f)) variabili a, b, c.

Uscita in file digitato sono ammesse solo variabili corrispondenti alla descrizione del tipo di dati. Le costanti senza nome e non tipizzate non possono essere restituite a

file digitato.

File digitati sono considerate come strutture di accesso sia diretto che sequenziale. Ciò significa che è possibile scrivere non solo alla fine del file, ma anche a qualsiasi altro elemento di esso. Il valore scritto sovrascriverà il valore precedente in questo elemento (il vecchio valore verrà "sovrascritto").

Ad esempio, se è necessario sostituire il quinto elemento del file con il valore memorizzato nella variabile a, è necessario scrivere il seguente estratto del programma:

cercare (f, 5); (il puntatore sarà posizionato all'inizio del 5° elemento)

scrivere (f, a); (il puntatore sarà posizionato all'inizio del 6° elemento)

Un file binario è qualsiasi file sul tuo computer. Tutte le informazioni su un computer e sui relativi supporti sono registrate in bit (da cui il nome). Tuttavia, per confronto, un file di testo può essere letto nei lettori corrispondenti all'estensione (quelli più semplici - anche nel Blocco note), ma il file eseguibile no. E sebbene in effetti un file txt sia lo stesso file binario, quando parlano del problema dell'apertura del contenuto dei file binari, intendono file eseguibili, oltre a dati compressi.

Avrai bisogno

• - Programma di modifica esadecimale.

Istruzioni

Scarica il programma Hex Edit sul disco rigido, un editor di file che ne rappresenta il contenuto in formato binario. Aprire il programma facendo doppio clic sul file di avvio. Questo software ti consente di leggere i binari in tempo reale, modificare il contenuto, aggiungere le tue voci e molto altro. Per funzionare correttamente in questo ambiente, è necessario conoscere un po' i concetti generali dei binari.

La finestra del programma non è molto diversa dal solito editor: il menu familiare e il pannello con i pulsanti, il corpo del file modificato, i segnalibri e la barra di stato. Aprire il file binario tramite il menu File o facendo clic sull'icona corrispondente sul pannello. Il file binario apparirà davanti a te come stringhe con numeri e lettere. Non confondere questi caratteri con i dati stampabili nei file di testo. Possono anche essere modificati eliminando i simboli, ma questo eliminerà le celle con i dati, parti del file.

Apportare modifiche al contenuto del file. L'applicazione può mostrare parti importanti del file per una ricerca più semplice e ha anche una configurazione flessibile della visualizzazione grafica del codice binario. Cambia la visualizzazione del contenuto in modalità ASCII + IBM / OEM per vedere il codice del programma del file. Se si inseriscono le righe sbagliate nel file, potrebbe non funzionare correttamente, causando gravi conseguenze per il sistema operativo del personal computer.

Salva le modifiche. Se non hai esperienza nella modifica dei file in questo modo, preparati al fatto che il file non si apre e si rifiuta di funzionare dopo aver apportato le modifiche. Molto probabilmente sbaglierai alcune copie prima di portare a termine il lavoro. Cerca di non salvare tutte le modifiche al file originale in modo che il suo contenuto rimanga invariato.

Probabilmente ti sei imbattuto nei termini "testo" e "binario" prima di leggere alcuni articoli sui file. E hanno deciso che tutto questo è troppo difficile per te, non lo capirai mai, quindi non lo hanno approfondito, rinunciandoci.

Cercheremo di spiegare tutto nel linguaggio più semplice possibile, perché tali informazioni sono utili per ogni utente, anche il più inesperto, perché sono direttamente legate alle basi della sicurezza informatica.

Un po' di teoria

Il file di testo contiene caratteri ASCII (l'abbreviazione sta per American Standard Code for Information Interchange, qualcosa come "Standard americano per la codifica per lo scambio di informazioni").

Infatti, ASCII è una tabella in cui ad ogni lettera, numero, segno di punteggiatura e ai diversi "cani" con "fiocchi di neve" (nel senso di @ e *) è assegnato un byte. Cioè, otto zeri e uno (bit). Inoltre, ovviamente, controlla i caratteri come le interruzioni di riga.

Un programma per aprire file con caratteri ASCII converte i byte in lettere, numeri e altri caratteri stampabili sul display. Certo, il software deve capire quella parte della tabella che corrisponde alla lingua russa, ma questa è già una questione di codifica.

In un file binario, gli zero e gli uno sono disposti in una sequenza che non è necessaria per visualizzare i testi (sebbene ce ne siano alcuni, ad esempio * doc). E per cosa, chiedi. La risposta è semplice: per tutto il resto. Programmi, film, musica, immagini: ogni formato ha i propri principi strutturali per l'organizzazione dei dati.

La stessa parola "binario" significa "bicomponente", "doppio". In effetti, solo due componenti sono chiaramente definiti: zero e uno, bit, "mattoni" che compongono il file. Il significato di tutto il resto può manifestarsi solo durante il lancio (apertura, riproduzione).

La parte inferiore del mondo digitale

Puoi guardare all'interno di un file binario usando un programma speciale: un editor HEX. (Dalla parola esadecimale, che denota un sistema numerico esadecimale.) Tale software mostra i byte sotto forma di loro designazioni HEX, che si trovano di fatto anche sotto forma di tabella (matrice).

Ad esempio, i byte di un'immagine JPEG, un'immagine normale o una fotografia, nella finestra dell'editor verranno visualizzati come FF D8 FF 00 04 3A 29 e così via.

Lo specialista capirà che la sequenza di byte FF D8 all'inizio indica che abbiamo a che fare con JPEG. E per i non specialisti, tutto questo non è così interessante.

Puoi anche aprire un file di testo in un editor HEX per vedere quali byte corrispondono a lettere specifiche (caratteri ASCII). Ma solo per curiosità, non ha ancora senso.

Ma i file binari a volte vengono visualizzati in forma esadecimale per scopi piuttosto significativi e specifici. Ad esempio, gli specialisti nei laboratori antivirus cercano così il codice dannoso aggiunto a quello principale. A proposito, passiamo ai problemi di sicurezza.

Cosa può nuocere?

Il file di testo non può contenere altro che caratteri ASCII. Tuttavia, i programmi non sono solo binari, ma sono costituiti anche dai simboli di cui sopra. Questo significa script, ovviamente.

In altre parole, il file * txt in linea di principio non è infetto e non rappresenta una minaccia. E se c'è uno script all'interno di un file di testo, allora può fare molti danni.

Ad esempio, il file * bat contiene il codice di vari comandi e viene lanciato facendo doppio clic, come un normale programma. Questi comandi sono scritti in caratteri ASCII, ma il sistema operativo è in grado di interpretarli, trasformandoli in zeri e uno tipici dei programmi.

Ma, ovviamente, non fai clic su file bat sconosciuti, giusto? Va bene.

Pubblicazioni precedenti:

Ultima modifica: 06-11-2012 14:45:16

Etichette dei materiali:,

record), quindi il desiderio di ridurre in qualche modo lo spazio di memoria inutilizzato ma occupato è abbastanza comprensibile.

Soprattutto per questi casi, ci sono record con parte variante.

Descrizione di un record con una parte variante

Nella sezione var registrare con parte variante descrivere come segue:

varia<имя_записи>: disco<поле1>: <тип1>; [<поле2>: <тип2>;] [...] Astuccio<поле_переключатель>: <тип>di<варианты1>: (<поле3>: <тип3>; <поле4>: <тип4>; ...); <варианты2>: (<поле5>: <тип5>; <поле6>: <тип6>; ...); [...] fine;

Parte non variante la notazione (prima della parola chiave case) obbedisce alle stesse regole della notazione normale. In generale, la parte non variante può essere del tutto assente.

parte variante inizia con il caso di parola riservata, dopo di che viene indicato il campo del record, che fungerà ulteriormente da interruttore. Come con una normale istruzione case, lo switch deve appartenere a uno dei tipi enumerati dati (vedi Lezione 3). L'elenco di scelte può essere una costante, un intervallo o l'unione di più costanti o intervalli. L'insieme dei campi che devono essere inclusi nella struttura del record, se è stata eseguita l'opzione corrispondente, è racchiuso tra parentesi.

Esempio... Per descrivere i contenuti della biblioteca sono necessarie le seguenti informazioni:

Le colonne "Titolo" e "Editore" sono comuni a tutte e tre le opzioni e il resto dei campi dipende dal tipo di edizione cartacea. Per implementare questa struttura, useremo entrata con parte variante:

tipo biblio = nome record, editore: stringa; case item: char of "b": (autore: stringa; anno: 0..2004); "n": (dati: data); "m": (anno: 1700..2004; mese: 1..12; numero: intero); fine;

A seconda del valore del campo articolo, il record conterrà 4, 5 o 6 campi.

Il meccanismo per utilizzare un record con una parte variante

Il numero di byte allocati dal compilatore per registrare con parte variante, è determinato dalla sua versione "più lunga". Insiemi più brevi di campi di altre varianti occupano solo una frazione della memoria allocata.

Nell'esempio sopra, l'opzione "più lunga" è "b": richiede 23 byte (21 byte per una stringa e 2 byte per un numero intero). Per le opzioni "n" e "m" sono necessari rispettivamente 4 e 5 byte (vedi tabella).

nome, editore	elemento	parte variante
...	"B"	autore																				anno
...	"n"	dati
...	"m"	anno	mese	numero
...	"B"	autore																				anno

File binari

I file binari memorizzano le informazioni nella forma in cui sono rappresentate nella memoria del computer e quindi sono scomodi per gli esseri umani. Esaminando un file del genere, è impossibile capire cosa c'è scritto in esso; non può essere creato o corretto manualmente - in alcuni editor di testo - ecc. Tuttavia, tutti questi inconvenienti sono compensati dalla velocità di lavoro con i dati.

Inoltre, i file di testo appartengono a strutture accesso sequenziale e binario - diretto. Ciò significa che in qualsiasi momento puoi fare riferimento a chiunque, non solo all'elemento corrente.