I membri della classe possono essere utilizzati con parola chiave Statico. In questo contesto, il suo valore è simile a quello che ha in C. Quando un membro della classe viene dichiarato come statico, quindi il compilatore è un'indicazione che dovrebbe esserci una sola copia di questo membro, non importa quanto oggetti di Questa classe è stata creata. Membro statico è utilizzato in congiuntamente tutti gli oggetti di questa classe. Tutti i dati statici vengono inizializzati da zeri quando si crea il primo oggetto e l'altra inizializzazione non viene fornita.
Durante la dichiarazione di un membro statico dei dati di classe, questo membro non è determinato. Invece, è necessario garantire la definizione globale al di fuori della classe. Ciò viene effettuato dalla nuova dichiarazione della variabile statica e l'operatore dello scopo di visibilità viene utilizzato per identificare la classe a cui appartiene la variabile. Questo è necessario affinché la variabile statica sia evidenziata la memoria.
Ad esempio, considera prossimo programma:
#Includere.
Contatore di classe (
Contare statico int;
Pubblico:
void sethcount (int i) (conte \u003d i;);
Void showcount () (cout<< count << " "; }
};
Int Counter :: Conte; // Contazione della definizione
Int principale () (
Contro A, B;
A.ShowCount (); // Visualizza 0.
B.ShowCount (); // Visualizza 0.
A.SetCount (10); // installazione di conteggio statico a 10
A.ShowCount (); // Visualizza 10.
B.ShowCount (); // visualizza anche 10
Ritorno 0;
}
Innanzitutto, noteremo che la variabile statica di tutto il tipo di conteggio è dichiarata in due luoghi: nella controcorrente e quindi - come variabile globale. Borland C ++ inizializza il conteggio zero. Ecco perché la prima chiamata di showcount () visualizza lo zero di conseguenza. L'oggetto A viene quindi impostato per contare uguale a 10. Dopodiché, sia l'oggetto A e B vengono visualizzati utilizzando la funzione showcount () e lo stesso valore 10. Poiché c'è solo una copia del conteggio degli oggetti condivisi utilizzati A e B, Quindi lo schermo viene visualizzato in entrambi i casi il valore 10.
Puoi anche avere funzioni di membri statiche. Le funzioni dei membri statiche non possono fare direttamente riferimento a dati non nazionati o funzioni non statiche dichiarate nella loro classe. La ragione di questa è l'assenza di questo puntatore per loro, quindi non c'è modo di scoprire con ciò che funziona i dati non standard. Ad esempio, se ci sono due oggetti di classe contenenti la funzione statica F () e se f () sta tentando di accedere al var variabile non statistico, definito da questa classe, quindi come posso determinare quale copia del var dovrebbe essere Usato? Il compilatore non può risolvere un tale problema. Questo è il motivo per cui le funzioni statiche possono essere applicate solo ad altre funzioni statiche o dati statici. Inoltre, le funzioni statiche non possono essere virtuali o dichiarate con const modificatori vanno volatili. La funzione statica può essere chiamata utilizzando l'oggetto classe o utilizzando il nome della classe e l'operatore dell'ambito dell'ambito. Tuttavia, non è necessario dimenticare che anche quando si chiama una funzione statica utilizzando un oggetto, non viene trasmesso al puntatore.
Il prossimo programma breve illustra uno dei tanti modi per utilizzare le funzioni statiche. La situazione è sufficientemente comune quando è necessario fornire accesso a una risorsa limitata, ad esempio, ad esempio un file condiviso nella rete. Poiché questo programma illustra, l'uso di dati e funzioni statici utilizza il metodo con cui l'oggetto può controllare lo stato della risorsa e accedervi, se possibile.
#Includere.
Accesso alla classe (
Statico enum access_t ACS;
// ...
Pubblico:
{
Restituire ACS;
}
// ...
};
Int main ()
{
Accesso OBJ1, OBJ2;
Accesso :: set_access (bloccato); // chiama usando il nome della classe
// ... il codice
se (obj2.get_access () \u003d\u003d sbloccato) (// chiama con un oggetto
Cout.<< "Access resource.\n";
}
Altrimenti cout.<< "Locked out.\n";
// ...
Ritorno 0;
}
Quando si avvia questo programma, "bloccato" appare sullo schermo. Silentiamo che la funzione Set_Access () è causata dal nome della classe e dal gestore dell'ambito. La funzione Get_Access () è causata all'oggetto e all'operatore "Point". Quando si chiama una funzione statica, ognuno di questi moduli può essere utilizzato e entrambi forniscono lo stesso effetto. Vale la pena sperimentare un po 'con questo programma per assicurarsi che la sua comprensione del suo lavoro sia corretta.
Come notato, le funzioni statiche hanno accesso diretto solo ad altre funzioni statiche o dati statici all'interno della stessa classe. Per verificare questo, proviamo a compilare la seguente versione del programma:
// Questo programma contiene un errore e non si compilerà
#Includere.
Enum access_t (condiviso, in_use, bloccato, sbloccato);
// Classe controlla una risorsa rara
Accesso alla classe (
Statico enum access_t ACS;
int i; // non statico
// ...
Pubblico:
Voide statica Set_access (Enum Access_t A) (ACS \u003d A;)
Statico enum access_t get_access ()
{
I \u003d 100; // non si compilerà
Restituire ACS;
}
// ...
};
Enum Access_t Access :: ACS; // Definizione di ACS
Int main ()
{
Accesso OBJ1, OBJ2;
Accesso :: set_access (bloccato); // chiama usando il nome della classe
// ... il codice
// può obj2 contattare una risorsa
se (obj2.get_access () \u003d\u003d sbloccato) (// chiama con un oggetto
Accesso :: set_access (in_use); // chiama usando il nome della classe
Cout.<< "Access resource.\n";
}
Altrimenti cout.<< "Locked out.\n";
// ...
}
Questo programma non sarà compilato, poiché la funzione Get_Access () sta tentando di accedere alla variabile non statica.
All'inizio, non si sente necessario nell'uso immediato dei membri statici, ma poiché l'esperienza di esperienza di programmazione si è accumulata su C ++, diventano uno strumento molto conveniente in determinate situazioni, poiché possono evitare di utilizzare le variabili globali.
Possiamo accedervi direttamente attraverso il nome della classe e l'operatore di autorizzazione dell'area di visibilità. Ma cosa succede se le variabili statiche sono chiuse? Considera il seguente codice:
In questo caso, non possiamo accedere direttamente a nulla :: S_Value da Main (), poiché questo membro è privato. Di solito, l'accesso ai membri della classe chiusa viene effettuato attraverso metodi pubblici. Sebbene potessimo creare un metodo ordinario per accedere a S_Value, ma allora dovremmo creare un oggetto di questa classe per utilizzare il metodo! C'è un'opzione migliore: possiamo fare un metodo statico.
Come variabili statiche, metodi statici Non essere legato a nessun oggetto di classe singola. Ecco un esempio sopra, ma già con un metodo statico:
classe qualsiasi cosa (privata: statico int s_value; pubblico: statico int getvaluet () (ritorno s_value;) // metodo statico); Int NULLA :: S_VALUE \u003d 3; // Definizione del membro della variabile della variabile statica int principale () (std :: cout<< Anything::getValue() << "\n"; }
Poiché i metodi statici non sono legati a un oggetto specifico, possono essere chiamati direttamente attraverso il nome della classe e l'operatore di autorizzazione dell'area di visibilità, nonché attraverso gli oggetti di classe (ma non è raccomandato).
I metodi statici non hanno un puntatore * questo
I metodi statici hanno due caratteristiche interessanti. Innanzitutto, dal momento che i metodi statici non sono legati all'oggetto, non hanno! Ha senso qui, poiché * questo puntatore indica sempre un oggetto con cui funziona il metodo. I metodi statici potrebbero non funzionare attraverso l'oggetto, quindi il * questo indice non è necessario.
In secondo luogo, i metodi statici possono contattare direttamente altri membri statici (variabili o funzioni), ma non possono essere instabili. Ciò è dovuto al fatto che i membri non statici appartengono all'oggetto di classe e ai metodi statici - No!
Un altro esempio
I metodi statici possono essere determinati al di fuori del corpo della classe. Funziona allo stesso modo di metodi convenzionali. Per esempio:
#Includere.
#Includere. classe Idgenerator. privato: statico int s_nextid; // Annuncio di un membro della variabile statica pubblico: statico int getnextid (); // annuncio metodo statico // Comincia a generare ID da 1 int Idgenerator :: s_nextid \u003d 1; int idgenerator :: getnextid () (return s_nextid ++;) int main () per (int Count \u003d 0; conteggio< 4 ; ++ count ) std :: cout.<< "The next ID is: " << IDGenerator :: getNextID () << "\n" ; ritorno 0; |
Il risultato del programma è più alto:
Il prossimo ID è: 1
Il prossimo ID è: 2
Il prossimo ID è: 3
Il prossimo ID è: 4
Nota, poiché tutte le variabili e le funzioni di questa classe sono statiche, allora non abbiamo bisogno di creare un oggetto di questa classe per lavorare con esso! Un membro variabile statico viene utilizzato per memorizzare il valore del successivo identificatore, che dovrebbe essere assegnato ad esso e il metodo statico - per restituire l'identificativo e aumentalo.
Avvertimento delle classi con tutti i membri statici
Fai attenzione quando scrive le classi con tutti i membri statici. Sebbene tali "classi puramente statiche" possano essere utili, ma hanno anche i loro inconvenienti.
Innanzitutto, poiché tutti i membri statici vengono creati solo una volta, allora diverse copie della "classe puramente statica" non possono essere (senza clonare la classe e la sua ulteriore ridenominazione). Ad esempio, se abbiamo bisogno di due oggetti indipendenti della classe Idgenerator, sarà impossibile attraverso una classe "purea statica".
C ++ non supporta costruttori statici
Se è possibile inizializzare la solita variabile membro, quindi, in base alla logica delle cose, è necessario essere in grado di inizializzare le variabili dei membri statiche attraverso un costruttore statico. E, anche se alcune lingue moderne supportano davvero i designer statici per questo scopo, C ++, purtroppo, non è uno di questi.
Se la variabile statica può essere inizializzata direttamente, il progettista non è necessario: è possibile definire un membro della variabile statica, anche se è privato. Lo facciamo nell'esempio sopra con s_nextid. Ecco un altro esempio:
classe qualcosa (pubblico: statico std :: vector
classe di classe. pubblico: statico std :: vector< char > s_mychars; std :: vector.< char > Qualcosa :: s_mychars \u003d ("o", "a", "u", "i", "e"); // Determina l'elemento variabile statico |
Se è necessario eseguire il codice (ad esempio, ciclo) per inizializzare la variabile statica, cioè diversi modi per farlo. Il seguente modo è il migliore di loro:
#Includere.
#Includere. #Includere. classe di classe. privato: statico std :: vector< char > s_mychars; pubblico: classe _nested. // Determina la classe investita denominata _nestata pubblico: Nidificato () // Designer _Nestato Inizializza il nostro membro della variabile statica s_mychars. Push_back (O "); s_mychars. Push_back ("A"); s_mychars. Push_back ("u"); s_mychars. Push_back ("I"); s_mychars. Push_back ("e"); |
Ultimo aggiornamento: 08.10.2017
Oltre alle variabili e ai metodi relativi direttamente all'oggetto, C ++ consente di determinare variabili e metodi direttamente correlati alla classe o altrimenti i membri statici della classe. Variabili e metodi statici sono generalmente tra l'intera classe. Per determinarli, la parola chiave è statica.
Ad esempio, una banca può avere molti contributi diversi, ma tutti i contributi avranno alcuni tassi di interesse comuni. Quindi, per descrivere un conto bancario, definiamo e utilizziamo la seguente classe:
#Includere.
La classe account definisce una variabile di tasso statica e due funzioni statiche per controllare questa variabile. Durante la determinazione delle funzioni statiche, vale la pena considerare che all'interno di loro possiamo utilizzare solo variabili statiche della classe, come la variabile del tasso. Le variabili ultime utilizzano nelle funzioni statiche.
Inoltre, nelle funzioni statiche, questo indicatore non può essere utilizzato, che in linea di principio, e così ovvio, poiché ciò indica l'oggetto corrente e le funzioni statiche sono tra la classe.
È anche importante che se la classe contiene variabili statiche, devono essere definite ulteriormente al di fuori della classe:
Account INT :: Vota \u003d 8;
Assegna il valore iniziale della variabile è facoltativo.
Vale anche la pena notare che dal momento che i membri statici sono generalmente tra l'intera classe, allora il nome della classe viene utilizzato per fare appello ai membri statici, dopo di che l'operatore va ::. O possiamo anche contattare i membri pubblici attraverso variabili di questa classe:
Account :: Getrate () Account1.GetRate ()
Programma per ufficio console:
Valuta: 5 Tariffa: 5 Reddito: 21000 Vota: 5 Reddito: 52500
Anche spesso nelle lezioni utilizzano costanti statiche. Ad esempio, faremo una costante tariffa variabile nella classe account:
#Includere.
A differenza delle variabili statiche, le costanti statiche non devono essere definite ulteriormente al di fuori della classe.
Parola chiave statica.
A volte è tenuto a determinare tale membro della classe, che verrà utilizzato indipendentemente da tutti gli altri oggetti di questa classe. Di norma, l'accesso a un membro della classe è organizzato dall'oggetto di questa classe, ma allo stesso tempo è possibile creare un membro della classe per auto-utilizzo senza riferimento a un'istanza specifica dell'oggetto. Al fine di creare un membro del genere, è sufficiente specificare all'inizio del suo annuncio parola chiave statica..
Se un membro della classe viene dichiarato come statico, diventa disponibile prima di creare oggetti oggetto e senza riferimento a nessun oggetto. Con l'aiuto della parola chiave statica, sia le variabili che i metodi possono essere dichiarati. L'esempio più caratteristico di un membro del tipo statico è il metodo principale (), dichiarato tale perché dovrebbe essere chiamato il sistema operativo all'inizio del programma che viene eseguito.
Per utilizzare il tipo statico A Membro al di fuori della classe, è sufficiente specificare il nome di questa classe con il punto dell'operatore. Ma non è necessario creare un oggetto per questo. In effetti, un membro del tipo statico è disponibile non in riferimento all'oggetto, ma dal nome della sua classe.
Le variabili dichiarate come statiche sono essenzialmente globali. Quando gli oggetti vengono dichiarati nella loro classe, la copia della statica del tipo variabile non viene creata. Invece, tutte le istanze della classe utilizzano rapidamente la stessa statica di tipo variabile. Tale variabile è inizializzata prima del suo utilizzo nella classe.
Esempio di utilizzo della parola chiave statica:
Usando il sistema; usando sistema.Collections.genic; Usando il sistema.linq; Usando il sistema.Text; Namespace consoleapplication1 (classe mycircle (// 2 metodi che restituiscono l'area e la lunghezza del cerchio del doppio SQRCircle Public Static Double SQRCircle (RADIUS * Raggio) (raggio * raggio;) Doppio LongCircello statico (INT RADIUS) (ritorno 2 * Math.pi * Radius ;))) Programma di classe (int r \u003d 10; // Metodi di chiamata da un'altra classe // senza creare un'istanza dell'oggetto di questa console di classe.Writeline ("raggio quadrato del cerchio (0) \u003d (1: ##)", R, mycircle.sqrCircle (R)); console.Writeline ("Lunghezza del cerchio è uguale a (0: #. ##)", mycircle.longcircle (r)); console.readline ();)))
Un numero di restrizioni è sovrapposto all'applicazione dei metodi di tipo statico:
Nel metodo statico, non dovrebbe esserci alcun riferimento a questo, poiché questo metodo non viene eseguito relativo a nessun oggetto
Nel metodo del tipo statico, sono consentiti solo altri metodi statici, ma non un metodo di istanza dalla stessa classe. Il fatto è che i metodi dell'istanza funzionano con oggetti specifici e il metodo di tipo Statico non è richiesto per l'oggetto. Di conseguenza, questo metodo non ha oggetti che poteva operare
Restrizioni simili sono sovrapposte ai dati statici. Per il metodo statico, solo altri dati statici specificati nella sua classe risultano direttamente disponibili. In particolare, non è possibile utilizzare la copia variabile della sua classe, dal momento che non ha oggetti con cui potrebbe funzionare
Costruttori statici
Il designer può anche essere dichiarato come statico. Un costruttore statico è solitamente utilizzato per inizializzare i componenti utilizzati per l'intera classe e non a un'istanza separata dell'oggetto di questa classe. Pertanto, i membri della classe sono inizializzati da un designer statico prima di creare oggetti di questa classe:
Usando il sistema; usando sistema.Collections.genic; Usando il sistema.linq; Usando il sistema.Text; Namespace ConsoleApplication1 (Public Int A; Public Int B; // Costruttore statico Myclass statico () (A \u003d 10;) // Designer convenzionale MyClass pubblico () (B \u003d 12;)) Programma di classe (Statico Void Main (String ARGS) (Console.Writeline ("Accesso a un'istanza di classe A:" + myclass.a); myclass obj \u003d nuovo myclass (); console.writeline ("Accesso a un'istanza di classe B:" + obj.b); console .Linea di lettura ();)))
Si noti che il progettista statico viene chiamato automaticamente quando la classe viene caricata per la prima volta, e prima del progettista di istanza. Da ciò è possibile effettuare una conclusione più generale: il costruttore statico deve essere eseguito in qualsiasi istanza. Inoltre, i costruttori statici non hanno modificatori di accesso - usano l'accesso predefinito e quindi non possono essere chiamati dal programma.
Classi statiche
La classe può essere annunciata come statica. La classe statica ha due proprietà principali. Primo, oggetti di classe statica da creare È impossibile. E in secondo luogo, la classe statica deve contenere solo membri statici. La classe statica viene creata secondo la dichiarazione di classe classificata, modificata utilizzando la parola chiave statica.
nome della classe di classe statica (// ...
Le classi statiche si applicano principalmente in due casi. Innanzitutto, la classe statica è richiesta durante la creazione metodo di espansione. I metodi di espansione sono principalmente correlati alla lingua LINQ. E in secondo luogo, la classe statica viene utilizzata per memorizzare l'aggregato di metodi statici collegati l'uno con l'altro.
Lezione 25. Funzioni statiche e elementi di dati
Fino ad ora, ogni oggetto che crei ha avuto il proprio set di elementi di dati. A seconda dello scopo della tua applicazione, potrebbero esserci situazioni in cui gli oggetti della stessa classe devono condividere uno o più articoli di dati. Ad esempio, supponiamo di scrivere un programma di pagamento che traccia del tempo di lavoro per 1000 dipendenti. Per determinare la frequenza fiscale, il programma dovrebbe conoscere le condizioni in cui ogni dipendente funziona. Lascia che utilizzi una classe variabile stato_of_work.Tuttavia, se tutti i dipendenti funzionano nelle stesse condizioni, il tuo programma potrebbe condividere questo elemento dati per tutti gli oggetti di tipo dipendente.Pertanto, il tuo programma riduce la quantità di memoria richiesta, lanciando 999 copie delle stesse informazioni. Per condividere l'elemento della classe, è necessario dichiarare questo articolo come statico (statico).Questa lezione considera i passaggi che è necessario eseguire per condividere un elemento di classe da diversi oggetti. Alla fine di questa lezione, padroneggia i seguenti concetti principali:
C ++ consente di avere oggetti dello stesso tipo che ha condiviso uno o più elementi della classe.
Se il programma assegna il valore all'elemento condiviso, tutti gli oggetti di questa classe ricevono immediatamente l'accesso a questo nuovo valore.
Per creare un elemento condiviso dei dati di classe, è necessario prevedere il nome della parola chiave dell'elemento di classe statico.
Dopo che il programma ha annunciato un elemento di classe come staticodovrebbe dichiarare una variabile globale (al di fuori della definizione della classe) che corrisponde a questo elemento condiviso della classe.
I tuoi programmi possono usare la parola chiave staticoper effettuare il metodo di classe chiamato mentre il programma potrebbe non aver ancora annunciato alcun oggetto di questa classe.
Condivisione dell'elemento dei dati
Di solito, quando si creano oggetti di una classe specifica, ogni oggetto riceve il proprio set di voci di dati. Tuttavia, ci sono tali situazioni in cui gli oggetti della stessa classe devono condividere uno o più elementi di dati. (Statico E.canampa dei dati). In tali casi, dichiarare elementi di dati come comune il.e privatoe quindi finire il tipo di parola chiave staticocome mostrato di seguito:
privato: statico int condiviso_value;
Dopo la dichiarazione di classe, è necessario dichiarare un articolo come variabile globale al di fuori della classe, come mostrato di seguito:
int class_name :: shared_Value;
Il seguente programma SHARE_IT.CPP definisce la classe serie di libricondivisione elemento. page_count,quale è lo stesso per tutte le classi di oggetti (Libri) (serie). Se il programma cambia il valore di questo articolo, la modifica si manifesta immediatamente in tutti gli oggetti della classe:
#Includere.
#Includere.
classe book_series.
(Pubblico: Book_Series (Char *, Char *, Float); void show_book (Void); Void Set_pages (INT); Privato: statico Int PAGE_COUNT; Titolo Char; Autore Char;);
int book_series :: Page__count;
void book_series :: set_pages (int pages)
(Pagina_count \u003d pagine;)
book_series :: book_series (titolo char *, char * autore, prezzo del galleggiante)
(Strcpy (book_series :: Titolo, titolo); strcpy (book_series :: Autore, autore); book_series :: Prezzo \u003d Prezzo;)
void book_series :: show_book (vuoto)
(Cout.<< "Заголовок: " << title << endl; cout << "Автор: " << author << endl; cout << "Цена: " << price << endl; cout << "Страницы: " << page_count << endl; }
(Programmazione book_series ("Programmazione di apprendimento su C ++", "Jamsa", 22.95); Book_series Word ("Impara a lavorare con Word for Windows", "Wyatt", 19.95); word.set_pages (256); programmazione.show_book (); Word.show_book (); cout<< endl << "Изменение page_count " << endl; programming.set_pages(512); programming.show_book(); word.show_book(); }
Come puoi vedere, la classe dichiara page_count.come statico int.Immediatamente per la definizione di classe, il programma annuncia un elemento page_count.come variabile globale. Quando il programma cambia l'elemento page_count,la modifica si manifesta immediatamente in tutti gli oggetti di classe serie di libri.
Condivisione di elementi di classe
A seconda del programma, le situazioni sono possibili quando è necessario condividere determinati dati da più istanze dell'oggetto. Per fare ciò, dichiarare un tale oggetto come statico. Quindi, dichiara questo elemento al di fuori della classe come variabile globale. Qualsiasi modifica che il tuo programma fa con questo elemento verrà immediatamente riflesso negli oggetti di questa classe.
Uso di elementi con attributipubblico statico IF. gli oggetti non esistono
Come hai appena imparato quando si dichiara un elemento di classe come statico.questo elemento è condiviso da tutti gli oggetti di questa classe. Tuttavia, le situazioni sono possibili quando il programma non ha ancora creato un oggetto, ma ha bisogno di utilizzare un elemento. Per utilizzare l'elemento, il tuo programma dovrebbe dichiararlo come pubblicoe statico.Ad esempio, il seguente programma US_MBR.CPP utilizza un oggetto page_count.dalla classe serie di librianche se questi oggetti di classe non esistono:
#Includere.
#Includere.
classe book_series.
(Pubblico: Statico Int Page_count; Privato: titolo di Char; Autore del char; prezzo del galleggiante;);
int book_series :: Page_count;
void principale (Void) (book_series :: Page_count \u003d 256; cout<< "Текущее значение page_count равно " << book_series::page_count << endl; }
In questo caso, dal momento che la classe definisce l'elemento della classe page_count.come pubblicoil programma può fare riferimento a questo elemento della classe, anche se oggetti di classe serie di libri.non esiste.
Usando elementi delle caratteristiche statiche
Programma precedente Uso illustrato staticoelementi di dati. Allo stesso modo, C ++ ti consente di determinare staticoelementi di funzione (metodi). Se crei. staticometodo, il programma può causare un metodo tale, anche se gli oggetti non sono stati creati. Ad esempio, se la classe contiene un metodo che può essere utilizzato per i dati al di fuori della classe, è possibile effettuare questo metodo statico.Sotto è la classe menù,che utilizza la sequenza ESC ANSI per la pulizia dello schermo del display. Se il tuo sistema ha un driver ANSI.SYS, è possibile utilizzare il metodo schermo pulito.per pulire lo schermo. Poiché questo metodo è dichiarato come statico,il programma può usarlo, anche se oggetti oggetto menù.non esiste. Il seguente programma CLR_SCR.CPP utilizza il metodo schermo pulito.per pulire lo schermo del display:
#Includere.
(Pubblico: Vuoto statico CLEAR_SCREEN (Void); // Deve esserci altri metodi privati: int number_of_menu_options;);
menu void :: clear_screen (vuoto)
(Cout.<< "\033" << "}
