Den troligtvis mest användbara av alla funktioner i att skriva ny kod är automatisk komplettering. Betrakta exempelvis följande stycke kod:

class Car {
  // ...
  public:
    std::string get_color () const;
};
void foo()
{
  Car my_ride;
  // ...gör något med variabeln...
  std::string color = my_ride.ge

På den sista raden kommer KDevelop ihåg att variabeln my_ride har typen Car, och erbjuder sig att automatiskt komplettera namnet på medlemsfunktionen ge som get_color. I själva verket är allt du behöver göra att fortsätta skriva tills funktionen för automatisk komplettering har reducerat antal träffar till en, och sedan trycka på returtangenten:

Observera att du kan klicka på verktygstipset för att få mer information om funktionen förutom dess returtyp och om den är öppen:

Automatisk komplettering kan spara mycket skrivande om projektet använder långa variabel- och funktionsnamn. Dessutom undviker det felstavning av namn (och resulterande kompileringsfel) och gör det mycket enklare att komma ihåg de exakta funktionsnamnen. Om exempelvis alla hämtningsfunktioner börjar med get_, kan funktionen för automatisk komplettering bara visa dig en lista med möjliga hämtningsfunktioner när du har skrivit in de fyra första bokstäverna, vilket troligtvis påminner dig under processen vilken av funktionerna som är den riktiga. Observera att för att automatisk komplettering ska fungera, behöver varken deklarationerna av klassen Car eller variabeln my_ride vara i samma fil som du för närvarande skriver kod i. KDevelop behöver enbart veta att klasserna och variablerna hör ihop, dvs. filerna där kopplingen görs måste ingå i projektet som du för närvarande arbetar på.

KDevelop har en guide för att lägga till ny klasser. Proceduren beskrivs i Skapa en ny klass. En enkel C++ klass kan skapas genom att välja den grundläggande C++ mallen från kategorin Klass. I guiden kan vi välja några fördefinierade medlemsfunktioner, exempelvis en tom konstruktor, en kopieringskonstruktor och en destruktor.

Efter att ha gjort färdigt guiden, skapas de nya filerna och öppnas i editorn. Deklarationsfilen har redan inkluderingsskydd och den nya klassen har alla medlemsfunktioner som vi valde. De följande två stegen är att dokumentera klassen och dess medlemsfunktioner och implementera dem. Vi beskriver hjälp att dokumentera klasser och funktioner nedan. För att implementera specialfunktionerna som redan lagts till, gå helt enkelt till fliken bus.cpp där skelett för funktionerna redan tillhandahålls:

För att lägga till nya medlemsfunktioner, gå tillbaka till fliken bus.h och lägg till namnet på en funktion. Låt oss exempelvis lägga till det här:

Observera hur jag redan har börjat med implementeringen. Dock ska inte funktionen implementeras i deklarationsfilen med många kodningsstilar, utan istället i den motsvarande .cpp-filen. För att åstadkomma det, placera markören på funktionsnamnet och välj Kod → Flytta till källkod eller tryck på Ctrl+Alt+S. Det tar bort koden mellan klammerparenteser.

Observera hur jag precis har börjat skriva och att jag har som avsikt att variabeln student troligen ska vara en medlemsvariabel i klassen Bus men att jag inte ännu har lagt till den. Observera också hur KDevelop stryker under den för att klargöra att ingenting är känt om variabeln. Men problemet kan lösas: genom att klicka på variabelnamnet ger följande verktygstips:

(Samma sak kan åstadkommas genom att högerklicka på det och välja Lös: Deklarera som.) Låt mig välja ”3 - privat unsigned int” (antingen med musen eller genom att klicka på Alt+3) och sedan se hur det blir i deklarationsfilen:

Det är värt att nämna att KDevelop extraherar typen på variabeln som ska deklareras från uttrycket som används för att initiera den. Om vi exempelvis hade skrivit additionen på följande något tveksamma sätt, skulle det ha föreslagit att deklarera variabeln som typ double:

Som en sista punkt: Metoden som används för Kod → Flytta till källa infogar inte alltid den nya medlemsfunktionen där du vill ha den. Du kanske vill markera den som inline och placera den längst ner i deklarationsfilen. I ett sådant fall, skriv deklarationen och börja sedan skriva funktionsdefinitionen på följande sätt:

KDevelop erbjuder automatiskt alla möjliga kompletteringar som kan finnas här. Att välja en av de två add_students posterna resulterar i följande kod som redan har fyllt i den fullständiga argumentlistan:

Bra kod är väldokumenterad, både på nivån av algoritmimplementation inom funktioner samt gränssnittsnivå, dvs. klasser, (globala och medlems-) funktioner, och (globala eller medlems-) variabler måste dokumenteras för att förklara deras avsikt, möjliga argumentvärden, för- och eftervillkor, etc. När det gäller att dokumentera gränssnittet, har doxygen blivit de facto standard för att formatera kommentarer som sedan kan extraheras och visas på sökbara webbsidor.

KDevelop stöder den här kommentarstilen genom att tillhandahålla en genväg för att generera kommentarramverket som dokumenterar en klass eller medlemsfunktion. Antag exempelvis att du redan har skrivit följande kod:

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

Nu vill du lägga till dokumentation för både klassen och medlemsfunktionen. För att åstadkomma det, flytta markören till första raden och välj Kod → Dokumentdeklaration eller tryck på Alt+Skift+D. KDevelop svarar med följande:

Markören är redan i det gråa området så att du kan fylla i den korta beskrivningen av klassen (efter doxygen-nyckelordet @breif). Därefter kan du fortsätta att lägga till dokumentation i kommentaren som ger en mer detaljerad översikt av vad klassen gör:

När editorn är inne i kommentaren, markeras kommentartexten med grönt (markeringen försvinner när markören flyttas från kommentaren). När du kommer till radens slut, tryck på returtangenten så påbörjar KDevelop automatiskt en ny rad som börjar med en asterisk och placerar markören indenterad ett tecken.

Låt oss nu dokumentera medlemsfunktionen, återigen genom att placera markören på deklarationsraden och välja Kod → Dokumentdeklaration eller trycka på Alt+Skift+D:

Återigen skapar KDevelop automatiskt ett kommentarmall, inklusive dokumentation av själva funktionen, samt dess returtyp. I det aktuella fallet, är själva funktionens namn rätt självförklarligt, men ofta är funktionsargumenten inte det och bör dokumenteras individuellt. För att åskådliggöra det, låt oss betrakta en något mer intressant funktion och kommentarerna som KDevelop automatiskt genererar:

Här innehåller den föreslagna kommentaren redan alla Doxygen-fält för de individuella parametrarna, exempelvis.

Ibland vill man byta namn på en funktion, klass eller variabel. Låt oss exempelvis anta att vi redan har det här:

Därefter inser vi att vi inte är nöjda med namnet remove_students och skulle hellre ha kallat det, låt oss säga, throw_out_students. Vi skulle kunna göra sök-och-ersätt av namnet, men det har två nackdelar:

Båda problemen kan lösas genom att flytta markören till någon av funktionsnamnets förekomster och välja Kod → Byt namn på deklaration (eller högerklicka på namnet och välja Byt namn Bus::remove_students). Det visar en dialogruta där du kan skriva in funktionens nya namn, och där du också kan se alla ställen där funktionen faktiskt används:

De flesta projekt har kodavsnitt som man ofta måste skriva i källkoden. Exempel är: en snurra över alla instruktioner för kompilatorer, kontroll att användarinmatning är giltig och om inte visa ett felmeddelande för användargränssnitt. I upphovsmannens projekt för dessa rader, skulle det vara kod som liknar:

for (typename Triangulation::active_cell_iterator
       cell = triangulation.begin_active();
     cell != triangulation.end(); ++cell)
  ... gör något med cellen ...

Istället för att skriva in den här sortens text om och om igen (med alla tillhörande skrivfel man åstadkommer) kan verktyget Textsnuttar i KDevelop vara till hjälp. För att göra det, öppna verktygsvyn (se Verktyg och vyer om motsvarande knapp inte redan finns vid fönstrets omkrets). Klicka sedan på knappen ”Lägg till arkiv” (en något felaktig beteckning som låter dig skapa en namngiven samling textsnuttar för källkod av en viss sort, t.ex. C++ källkod) och skapa ett tomt arkiv. Klicka sedan på för att lägga till en textsnutt, för att få en dialogruta som den följande:

För att använda en textsnutt som är definierad på så sätt när du redigerar kod, kan du bara skriva in namnet på textsnutten som du skulle göra med vilket annat funktions- eller variabelnamn. Namnet blir tillgängligt för automatisk komplettering, vilket betyder att det inte skadar att använda ett långt och beskrivande namn på en textsnutt såsom den ovan, och när du accepterar förslaget från verktygstipset för automatisk komplettering (exempelvis genom att bara trycka på returtangenten), ersätts den redan inmatade delen av textsnuttens namn med hela den expanderade textsnutten, och indenteras riktigt:

Observera att för att det ska fungera behöver inte verktygsvyn Kodsnuttar vara öppen eller synlig: du behöver bara verktygsvyn för att definiera nya kodsnuttar. Som ett alternativt, mindre bekvämt, sätt att expandera en kodsnutt är att helt enkelt klicka på den i respektive verktygsvy.