Probabilmente la caratteristica più utile di tutte nello scrivere nuovo codice è l'auto-completamento. Considera, per esempio, il seguente pezzo di codice:

class Car {
  // ...
  public:
    std::string get_color () const;
};
void foo()
{
  Car my_ride;
  // ...do something with this variable...
  std::string color = my_ride.ge

Nell'ultima riga, KDevelop ricorderà che la variabile my_ride è di tipo Car, e automaticamente proporrà di completare il nome della funzione membro ge come get_color. In realtà, tutto quello che devi fare è continuare a scrivere finché la funzione di auto-completamento ha ridotto le corrispondenze ad una, e poi premere il tasto Invio:

Nota che puoi fare clic sul suggerimento per avere più informazioni sulla funzione a parte il suo tipo di ritorno e se è pubblica:

L'auto-completamento può salvarti dal digitare molti caratteri se il tuo progetto usa nomi lunghi per variabili e funzioni; inoltre, evita errori di ortografia (e i risultanti errori di compilazione) e rende più semplici da ricordare i nomi esatti delle funzioni; per esempio, se tutti i vostri getter iniziano con get_, allora la funzione di auto-completamento sarà capace solo di presentarti un elenco di getter possibili quando hai digitato le prime quattro lettere, probabilmente ricordandoti nel processo quale delle funzioni è quella giusta. Nota che affinché l'auto-completamento funzioni, né la dichiarazione della classe Car né quella della variabile my_ride devono essere nello stesso file in cui si stà scrivendo il codice. KDevelop deve semplicemente sapere che queste classi e variabili sono connesse, cioè i file nei quali queste connessioni sono fatte devono essere parte del progetto sul quale stai attualmente lavorando.

KDevelop ha un assistente per aggiungere nuove classi. La procedura è descritta in Creare una nuova classe. Si può creare una semplice classe in C++ scegliendo il modello Base C++ dalla categoria Classe. Nell'assistente, si possono scegliere alcune funzioni membro predefinite, per esempio un costruttore vuoto, un costruttore di copie e un distruttore.

Dopo che l'assistente ha completato, i nuovi file vengono creati e aperti nell'editor. Il file di intestazione include già le include guard e le nuove classi hanno tutte le funzioni membro scelte. I successivi due passi sarebbero per documentare la classe e le sue funzioni membro e per la loro implementazione. Si discuterà degli aiuti per la documentazione delle classi e delle funzioni qui sotto. Per implementare le funzioni speciali già aggiunte, andare semplicemente nella scheda bus.cpp dove sono già forniti gli scheletri delle funzioni:

Per aggiungere nuove funzioni membro, ritornare nella scheda bus.h e aggiungere il nome di una funzione. Per esempio, aggiungiamo questa:

Nota come ho iniziato l'implementazione. Comunque, in molti stili di codifica, la funzione non dovrebbe essere implementata nel file di intestazione ma piuttosto nel corrispondente file .cpp. A tal fine, posizionare il cursore sul nome della funzione e selezionare Codice → Sposta il sorgente o premere Ctrl+Alt+S. Questo rimuoverà il codice tra le parentesi graffe dal file di instestazione (e lo sostituirà con un punto e virgola allo scopo di terminare la dichiarazione della funzione) e lo sposterà nel codice sorgente:

Nota che quello che volevo sottointendere è che la variabile students dovrebbe essere probabilmente una variabile membro della classe Bus ma che non ho ancora aggiunto. Nota pure come KDevelop la sottolinea per rendere chiaro che non sa niente della variabile. Ma questo problema può essere risolto: facendo clic sul nome della variabile si ottiene il seguente suggerimento:

(Lo stesso risultato può essere raggiunto facendo clic con il tasto destro su di esso e selezionando Risolvere: Dichiara come.) Ora consideriamo «3 - private unsigned int» (o con il mouse, o premendo Alt+3) e vediamo come viene fuori nel file di intestazione:

Vale la pena notare che KDevelop estrae il tipo della variabile che deve essere dichiarata dall'espressione usata per inizializzarla. Per esempio, se avessimo scritto la somma seguente in un modo piuttosto dubbio, avrebbe suggerito di dichiarare la variabile di tipo double:

Per concludere: il metodo che consiste nell'usare Codice → Sposta il sorgente non sempre inserisce la nuova funzione membro dove potresti volere. Per esempio, potresti volerla marcare come inline e metterla in fondo al file di intestazione. In un caso come questo, scrivi la dichiarazione e inizia a scrivere la definizione della funzione in questo modo:

KDevelop automaticamente offre tutti i possibili completamenti del caso. La selezione di una delle due voci add_students produce il codice seguente che riempie già l'elenco completo degli argomenti:

Il buon codice è ben documentato, sia a livello dell'implementazione degli algoritmi delle funzioni che a livello dell'interfaccia — cioè, le classi, le funzioni (membro e locali) e le variabili devono essere documentate per spiegare a cosa servono, i possibili valori degli argomenti, pre e post condizioni, ecc.. Per quanto riguarda l'interfaccia della documentazione, doxygen è diventato lo standard de facto per la formattazione dei commenti che poi possono essere estratti e visualizzati da pagine web ricercabili.

KDevelop supporta questo stile di commenti fornendo una scorciatoia per generare l'infrastruttura dei commenti che documenta una classe o una funzione membro. Per esempio, immagina di aver già scritto questo codice:

class Car {
  public:
    std::string get_color () const;
};

Ora vuoi aggiungere la documentazione sia alla classe che alla funzione membro. A tal fine, sposta il cursore sulla prima riga e seleziona Codice → Documenta dichiarazione o premi Alt+Shift+D. KDevelop risponderà in questo modo:

Il cursore si trova già nell'area in grigio in modo che tu possa scrivere una breve descrizione (dopo la parola chiave di doxygen @brief) di questa classe. Poi puoi continuare ad aggiungere documentazione a questo commento in modo da avere una panoramica più dettagliata di quello che fa la classe:

Mentre l'editor si trova all'interno del commento, il testo del commento è evidenziato in verde (l'evidenziazione scompare quando sposti il cursore al di fuori del commento). Quando raggiungi la fine di una riga, premi Invio e KDevelop inizierà automaticamente una nuova riga che inizia con un asterisco e posizionerà il cursore di un carattere rientrato.

Ora documentiamo la funzione membro, metti di nuovo il cursore sulla riga della dichiarazione e seleziona Codice → Documenta dichiarazione o premi Alt+Shift+D:

Di nuovo, KDevelop genererà automaticamente lo scheletro di un commento, insieme alla documentazione della stessa funzione, in aggiunta al suo tipo di ritorno. In questo caso, il nome della funzione si spiega da sola, ma spesso gli argomenti della funzione potrebbero non essere documentati individualmente anche se dovrebbero. Per illustrare quanto appena detto, consideriamo una funzione un po' più interessante e il commento che KDevelop genera automaticamente:

Qui, il commento proposto contiene già tutti i campi per i parametri individuali di Doxygen, per esempio.

A volte, si vuole rinominare una funzione, una classe o una variabile. Per esempio, diciamo di avere già questo:

Poi ci rendiamo conto di non essere contenti del nome remove_students e preferiremo chiamarlo, ad esempio, throw_out_students. Potremmo fare cerca e sostituisci il nome, ma questo ha due inconvenienti:

Antrambi questi problemi possono essere risolti spostando il cursore su una delle occorrenze del nome della funzione e selezionando Codice → Rinomina dichiarazione (o facendo clic con il tasto destro sul nome e selezionando Rinomina Bus::remove_students). Questo fa apparire una finestra di dialogo in cui è possibile inserire il nuovo nome della funzione e dove si possono anche vedere tutti i posti in cui la funzione è effettivamente usata:

La maggior parte dei progetti hanno parti di codice che frequentemente devono essere scritte nel codice sorgente. Esempi sono: chi scrive compilatori, un ciclo su tutte le istruzioni; chi realizza interfacce utente, controllare che l'input dell'utente sia valido e se non aprire una finestra di errore; nel progetto dell'autore di queste righe, sarebbe codice del tipo

for (typename Triangulation::active_cell_iterator
       cell = triangulation.begin_active();
     cell != triangulation.end(); ++cell)
  ... do something with the cell ...

Piuttosto che scrivere continuamente del testo simile (con tutti gli errori di battitura connessi che si introducono), qui può essere d'aiuto lo strumento Frammenti di KDevelop. A tale fine, aprire la vista strumento (vedi Strumenti e viste se il tasto corrispondente non è già nella finestra). Poi fare clic sul tasto «Aggiungi un deposito» (un nome improprio — ti consente di creare una raccolta di frammenti di codice sorgente di un tipo particolare con un nome, ad es. Sorgenti C++) e creare un deposito vuoto. Poi fare clic su per aggiungere un frammento, ottenendo una finestra di dialogo come la seguente:

Per usare un frammento definito in questo modo, quando stai editando il codice, è sufficente scrivere il nome del frammento nello stesso modo in cui avresti scritto il nome di qualsiasi altra funzione o variabile. Questo nome diventerà disponibile all'auto-completamento — ciò significa che non c'è niente di male nell'uso di nomi lunghi e descrittivi per i frammenti come quello qui sopra — e quando accetti il suggerimento dell'auto-completamento (per esempio premento Invio), la parte del nome del frammento già inserito sarà rimpiazzata dal nome completo del frammento e sarà adeguatamente identata:

Nota che affinché questo funzioni, deve essere aperta e visibile la vista strumento Frammenti: hai bisogno unicamente e solamente della vista strumento per definire dei nuovi frammenti. Un modo alternativo, anche se meno conveniente, di espandere un frammento consiste nel fare semplicemente clic sullo stesso nella relativa vista strumento.