10 Modi per personalizzare il codice:: Blocchi - manichini

Codice: I blocchi sono dotati di impostazioni predefinite che sono le più naturali per la maggior parte delle applicazioni C ++; tuttavia, quando inizi a trascorrere sempre più tempo nell'ambiente, potresti scoprire che Codice: I blocchi possono essere un luogo più amichevole con poche modifiche.

Usa il carattere di tabulazione

O in particolare, non usare il carattere di tabulazione. Questa impostazione non fa alcuna differenza se stai lavorando a un progetto in cui tutti useranno sempre Codice:: Blocchi. Il problema con i caratteri di tabulazione, tuttavia, è che i diversi editor tendono a interpretare le schede in modo diverso. Alcuni editor spostano il cursore sul prossimo punto di tabulazione, alcuni editor spostano il cursore su un numero di caratteri e non tutti gli editor concordano sul numero di caratteri da allocare per una scheda. Fortunatamente tutti gli editor interpretano gli spazi allo stesso modo, quindi è molto più sicuro dire al codice: L'editor di blocchi utilizza sempre spazi e non salva mai le schede nei file di origine. Per fare ciò, selezionare Impostazioni → Editor. Ora seleziona Impostazioni generali a sinistra e assicurati che Usa caratteri TAB sia deselezionato.

Evidenziazione della sintassi

L'evidenziazione della sintassi modifica i colori di diversi tipi di strutture, utilizzando un colore per le parole chiave, un colore diverso per i nomi delle variabili, un terzo per le stringhe di caratteri e così via. Questo è molto utile per evitare errori stupidi durante la digitazione. Ad esempio, se scrivi una parola chiave in modo errato, non apparirà nel colore della parola chiave. Per abilitare questa funzione, selezionare Impostazioni → Editor → Evidenziazione sintassi. Normalmente Codice: I blocchi possono indicare la lingua dall'estensione del nome file. Se stai utilizzando un'estensione di file non standard, assicurati di aggiungerla all'elenco selezionando Filemasks. Inoltre, è possibile regolare le opzioni di evidenziazione della sintassi da questa finestra per adattarsi meglio alle proprie esigenze. Questo è particolarmente importante se hai qualche forma di problemi alla vista, specialmente ogni forma di daltonismo.

Formatter code formatter

Questo potrebbe essere vecchio stile, ma un buon programmatore dovrebbe mostrare un piccolo orgoglio nell'aspetto del suo codice. Ciò richiede la creazione e l'adesione costante a uno standard di codifica. Anche più di questo, quando si lavora su una grande squadra, tutti dovrebbero usare lo stesso standard di codifica. Altrimenti, il codice appare disordinato, in quanto i moduli scritti da una persona hanno un aspetto e una sensazione mentre quelli scritti da un compagno di squadra hanno un aspetto diverso - molto poco professionale.

Forzare l'aderenza a uno standard di formattazione della codifica è facile nel Codice: Blocchi. Il suo editor di codice riformatta il codice per adattarlo a qualsiasi standard desiderato.

Il codice:: Blocca formattatore del codice sorgente non regolerà i nomi delle variabili. Ancora peggio, non toccherà la logica del tuo programma. Quindi, se scrivi codice scadente, non incolparlo sul codice: editor di blocchi.

Seleziona Impostazioni → Editor e seleziona Source Formatter dall'elenco che appare per ottenere una finestra simile alla Figura 1. La finestra di anteprima mostra come saranno le tue scelte nella pratica. Questo esempio segue lo standard ANSI, ma puoi scegliere tra molti altri standard comuni, oppure puoi selezionare Personalizzato e quindi fare clic sulle schede Rientro e formattazione per creare il tuo standard.

Figura 1: l'impostazione del formattatore del codice sorgente può aiutarti a applicare uno stile di codifica in modo uniforme.

Una volta selezionato uno standard, l'editor proverà a convincerti a utilizzare lo standard. Ad esempio, se si immette se (true) e si preme Invio, l'editor posizionerà il cursore nella posizione rientrata sotto se . Se si inserisce una parentesi aperta, l'editor esegue il backup, posiziona il tutore in linea con i in se , passa alla riga successiva, e il rientro finito.

Ancora meglio, una volta terminata la codifica, se selezioni Plug In → Source Code Formatter (AStyle), l'editor passerà attraverso il tuo modulo e riapplicherà lo standard corrente del codice sorgente. Quindi se il tuo compagno di lavoro non era così attento con la sua programmazione come te, non preoccuparti: pochi clic del mouse e tutto è pulito.

Codice abbreviazioni

Questa è una strana opzione. Se si codifica molto (leggi: molto ! ), le abbreviazioni del codice possono far risparmiare tempo, soprattutto se non si è un dattilografo di qualità. Le abbreviazioni dei codici consentono di inserire una parola in codice e quindi premere Ctrl + J, e voilà, il codice: l'editor Blocchi inserirà il modello predefinito corrispondente che verrà quindi compilato.

Ad esempio, se si inserisse > classe nella copia del Codice:: Blocchi e quindi inseriti Ctrl + J, Codice:: i Blocchi ti chiedono prima il nome della tua classe e quindi riempirebbero tutte le cose mostrate in Figura 2. < Figura 2: l'uso dell'abbreviazione del codice sorgente può farti risparmiare un sacco di tempo se ti ricordi di usarlo! Codice:: Blocchi viene fornito con una serie di abbreviazioni già definite, ma è possibile aggiungere tutte le abbreviazioni desiderate scegliendo Impostazioni → Editor e quindi selezionando l'opzione Abbreviazioni sul lato sinistro della finestra.

La cosa buona dell'abbreviazione del codice è che può risparmiare un sacco di digitazione e applica automaticamente lo standard di formattazione del codice sorgente selezionato. Dattilografo molto veloce (o vorrebbe essere un tastierista?) Potrebbe non ottenere molto da questa funzione, ma se non usi tutte e dieci le dita quando digiti o altrimenti stai solo lentamente sulla tastiera, probabilmente vorrai provare a usare questo caratteristica.

Completamento automatico

Codice:: Blocks ha questa interessante funzione chiamata Completamento automatico. Dopo aver digitato un numero minimo di lettere (il valore predefinito è quattro, ma lo cambi), se metti in pausa la digitazione, Codice:: I blocchi cercheranno tutte le cose che iniziano con quelle lettere.In questo modo, Codice: i blocchi possono anticipare ciò che stai cercando di dire.

Ad esempio, nel programma Budget5 incluso nel materiale scaricabile da Dummies. com, se inserisci

Acco

e poi fai una pausa di mezzo secondo (non è molto lungo!) poi si apre una finestra come mostrato in Figura 3 che offre le uniche due cose che Code: Blocks sa di in questo programma che inizia con Acco: la classe Account e il typedef AccountPtr . Dal momento che intendevi Account , puoi semplicemente premere Invio e questo lo riempirà per me. Figura 3: Codice:: Blocchi trova solo due corrispondenze per Acco in questo programma. Il primo è quello che stavo cercando. In questo esempio, stai creando un puntatore a un

Account

chiamato pAcc . Quando si digita pAcc -> e si interrompe, Code:: Blocks apre una finestra che elenca i membri pubblici di Account come mostrato nella Figura 4. Figura 4: Dato un oggetto, Codice:: Blocks troverà i membri pubblici accessibili da quell'oggetto. Questa è una caratteristica interessante quando ci si riferisce alle proprie classi. Più che altro, selezionare dalla lista significa che non si digita il nome della funzione sbagliato o scritto erroneamente.

Questa funzione diventa davvero interessante quando si immette un oggetto definito in una libreria. Ad esempio, se si inserisce

cout., si otterrà un elenco dei membri pubblici disponibili per l'oggetto cout . Questo può essere davvero utile quando non hai documentazione o semplicemente non sai da dove iniziare. Abilita tutti gli avvertimenti Abilitare tutti gli avvisi è un gioco da ragazzi. Gli errori che compaiono al momento della compilazione sono molto più facili da trovare (duh!) E risolti rispetto a quelli che devi andare a caccia di te in fase di esecuzione. Ecco perché la sintassi C ++ è così esigente: vuole essere sicuro di aver codificato esattamente ciò che si intendeva prima che si spenga e creare un eseguibile che faccia qualcosa di completamente diverso.

Ci sono alcune cose, tuttavia, (un bel po 'di cose, in realtà) che il compilatore GNU C ++ correggerà e continuerà senza commenti, se lo si desidera. Ad esempio, non è un errore definire una variabile in una funzione e quindi non usarla mai. O per inserire un ritorno nel mezzo di una funzione in modo che le righe di codice dopo il ritorno non possano mai essere eseguite. Questi non sono errori, ma sembrano molto potenti per un compilatore diffidente.

Il compilatore GNU genererà un avviso se vedrà uno di questi due casi o una qualsiasi dozzina di altri costrutti sospetti nel codice. Dovresti controllare ogni avvertimento per assicurarti di capire di cosa si lamenta il compilatore e perché. Prova a risolvere il problema se riesci a capire ma anche se decidi di non risolverlo.

Gli avvertimenti sveleranno molti errori che stanno per diventare bug nei tuoi programmi.

Creazione di un nuovo target di build

Il codice:: Blocks environment consente di creare più di un target di build. Un obiettivo di build ti consente di creare un eseguibile separato con impostazioni di build univoche.Ad esempio, si vorrebbe sicuramente includere le informazioni sui simboli nell'eseguibile che si utilizza per il debug ma non in quello che si intende spedire ai clienti (vedere sotto per ulteriori informazioni).

È più facile creare un obiettivo di compilazione di debug e un target di build di rilascio quando si crea il progetto - lasciare che la procedura guidata esegua tutto il lavoro per te. Tuttavia, molto spesso accade che dopo settimane di lavoro e di debug di un progetto, si vada a rilasciarlo solo per scoprire che non esiste un obiettivo di build di rilascio. Non preoccuparti, puoi sempre creare un nuovo target di build da solo.

Per creare un nuovo target di costruzione, selezionare Progetto → Proprietà, quindi selezionare la scheda Costruisci target. Vedrai qualcosa che assomiglia alla Figura 5, che mostra il programma Budget5 con un singolo obiettivo di compilazione di Debug.

Figura 5: una delle proprietà del progetto è l'elenco degli obiettivi di compilazione.

Utilizzare i seguenti passaggi per creare un obiettivo di build Release:

Selezionare il target Debug e fare clic su Duplica.

Inserire il nome del nuovo target di costruzione, Release.

Modificare il nome del file di output in binReleaseBudget5. exe e la directory di output degli oggetti su objRelease.
Fare clic su Opzioni di costruzione per impostare le opzioni di generazione desiderate per questo particolare obiettivo e fare clic su OK.
Sicuramente vuoi disattivare le informazioni sui simboli e attivare l'ottimizzazione.
Fare clic su OK per salvare il nuovo target di costruzione.

Per costruire un particolare bersaglio di costruzione, selezionare Costruisci → Seleziona bersaglio, quindi scegli tra i bersagli disponibili. Dirige il codice: Blocca l'utente che desideri creare quando selezioni la build.
Progetto - abilita le ottimizzazioni

Potresti pensare che ogni riga di codice C ++ generi un insieme di istruzioni della macchina senza riguardo alle linee di codice che la circondano, e in modalità non ottimizzata avresti ragione. L'ottimizzatore integrato nel compilatore GNU può generare un programma più efficiente dalla sorgente C ++ esaminando più righe di codice.

Considera il seguente esempio banale e completamente inventato (ma intelligente):

// i ++; MOV EAX, i [BP] INC EAX MOV i [BP], EAX // fn (i) MOV EAX, i [BP] PUSH EAX CHIAMATA FN

Qui la riga

i ++

è stata convertita nel tre righe di codice macchina che seguono: Caricare il valore di i

nel registro EAX. Incrementa il registro EAX. Ripristina il valore incrementale in
i
. La riga successiva converte la chiamata fn (i)

nel seguente. Caricare il valore di i
nel registro EAX. Spingi il valore di EAX in pila. Effettua la chiamata.
Si noti che il passaggio 4 non è effettivamente necessario. Non è necessario caricare il valore di
i

nel registro EAX perché il valore è già presente nei passaggi 1, 2 e 3. Anche un ottimizzatore mediocre noterebbe questo fatto e non genererebbe il secondo MOV EAX, i [BP] . Questo non è un gran risparmio, ma questo esempio è facile da capire, anche se non è un grande miglioramento. Dovresti essere un vero mago del linguaggio assembly per capire la maggior parte delle ottimizzazioni fatte dal compilatore GNU. È possibile abilitare le ottimizzazioni per una particolare build selezionando Progetto → Opzioni di creazione, quindi selezionando la build Release sulla sinistra e selezionando una delle opzioni di ottimizzazione.

Tecnicamente, ci sono diverse opzioni di ottimizzazione perché l'ottimizzatore può impiegare molto tempo. Se hai un progetto molto grande, non ha molto senso spendere un sacco di tempo per ottimizzare un modulo che non verrà eseguito molto spesso. Per progetti di dimensioni medio-piccole, è sufficiente abilitare l'ottimizzazione completa: non si noteranno i pochi secondi necessari per la compilazione.

È possibile abilitare questa opzione per tutte le build selezionando Impostazioni → Compilatore, quindi selezionando la scheda Compilatore e selezionando uno dei casi Optimize; tuttavia, questa non è una buona idea. Non abilitare l'ottimizzazione nella versione Debug del progetto se si prevede di utilizzare il debugger. Le modifiche al codice eseguite dall'ottimizzatore faranno apparire il programma in una passeggiata semi-casuale quando si prova ad attraversarlo.

Progetto - disabilita i simboli del debugger

Le informazioni sui simboli sono incluse nell'eseguibile solo per l'uso del debugger. Questa informazione non dovrebbe essere inclusa nella versione che spedisci agli utenti: Aumenta inutilmente la dimensione dell'eseguibile e, peggio ancora, rilascia informazioni pericolose agli hacker nel caso si cerchi di trovare una vulnerabilità nel tuo programma.

Per disabilitare le informazioni di debug nella destinazione build di rilascio, selezionare Progetto → Opzioni di costruzione, quindi selezionare la destinazione di rilascio a sinistra. Ora assicurati che l'opzione Produci simboli di debug [-g] sia disattivata per il target Release. (Ora è un buon momento per assicurarsi che questa stessa opzione venga cliccata per la destinazione di compilazione di Debug.)

Progetto - impostazione degli argomenti di un programma

Alcuni programmi devono essere eseguiti con argomenti della riga di comando. Codice:: Blocks fornisce il seguente meccanismo per fornire argomenti della riga di comando durante l'esecuzione di tale programma all'interno del codice:: Ambiente blocchi:

Seleziona progetto → Imposta argomenti programmi.

Seleziona il target di costruzione nella finestra superiore.

Inserisci quello che vuoi nella finestra Argomenti del programma.
Selezionare OK per chiudere la finestra.
Quando si inserisce Start o Esegui, Code:: Blocks fornirà questi argomenti al programma.