Probablement la més útil de totes les característiques en escriure codi nou és la compleció automàtica. Considerem, p. ex., el següent fragment de codi:

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

En l'última línia, el KDevelop recordarà que la variable my_ride és del tipus Car, i automàticament oferirà completar el nom de la funció de membre ge com get_color. De fet, tot el que haureu de fer és seguir escrivint fins que la funció de compleció automàtica hagi reduït el nombre de coincidències a una, i després prémer la tecla Retorn:

Tingueu en compte que podreu fer clic al consell per a obtenir més informació sobre la funció, a part del seu tipus de retorn i si és pública:

La compleció automàtica us pot estalviar un munt d'escriure si el vostre projecte utilitza noms llargs per a les variables i funcions; a més, evita errors d'ortografia (i els errors del compilador resultants) i fa que sigui molt més fàcil de recordar els noms exactes de les funcions; p. ex., si tots els vostres «get» comencen amb get_, la característica de compleció automàtica només us mostrarà una llista de possibles coincidències quan hàgiu escrit les primeres quatre lletres, és probable que durant el procés us recordi la funció correcta. Tingueu en compte que perquè funcioni la compleció automàtica, ni la declaració de la classe Car ni de la variable my_ride necessiten estar en el mateix fitxer on actualment esteu escrivint codi. El KDevelop simplement ha de saber que aquestes classes i variables estan connectades, és a dir, els fitxers en els quals es realitzen aquestes connexions han de formar part del projecte on esteu treballant.

El KDevelop inclou un assistent per a afegir classes noves. El procediment es descriu en Crear una classe nova. Una classe de C++ simple es pot crear escollint la plantilla de C++ bàsic des de la categoria Classe. En l'assistent, podem triar algunes funcions de membre predefinides, p. ex., un constructor buit, un constructor de còpia i un destructor.

Després de completar l'assistent, els fitxers nous seran creats i s'obriran a l'editor. El fitxer de capçalera ja conté guàrdies «include» i la classe nova conté totes les funcions de membre que hem seleccionat. Els dos passos següents serien documentar la classe, les seves funcions de membre i implementar-les. Més endavant parlarem sobre documentar les classes i les funcions. Per a implementar les funcions especials que ja hem afegit, simplement aneu a la pestanya bus.cpp on ja es proporciona l'esquelet de les funcions:

Per a afegir funcions noves de membres, torneu a la pestanya bus.h i afegiu-hi el nom d'una funció. Per exemple, afegirem això:

Tingueu en compte com ja he començat amb la implementació. No obstant això, en molts estils de codificació, la funció no s'ha d'implementar al fitxer de capçalera, sinó més aviat al fitxer .cpp corresponent. Per a això, situeu el cursor sobre el nom de la funció i seleccioneu Codi → Moure a l'origen o premeu Ctrl+Alt+S. Això eliminarà el codi entre claus del fitxer de capçalera (i el substituirà per un punt i coma si és necessari per a posar fi a la declaració de la funció) i es mourà al fitxer d'origen:

Tingueu en compte com només he començat a escriure i que vull implementar que la variable students probablement serà una variable de membre de la classe Bus, però que encara no l'he afegit. Tingueu en compte també com el KDevelop la subratlla per a deixar clar que no sap res sobre la variable. Però aquest problema es pot resoldre: Fent clic al nom de la variable s'obté el següent consell:

(El mateix es pot aconseguir fent clic dret sobre seu i seleccionant Resoldre: Declara com a). Permetem seleccionar «3 - unsigned int privat» (sigui amb el ratolí o prement Alt+3) i veiem com es mostra al fitxer de capçalera:

Val la pena assenyalar que el KDevelop extreu el tipus de la variable a declarar de l'expressió emprada per a inicialitzar-la. Per exemple, si haguéssim escrit l'addició de la següent manera bastant dubtosa, hauria suggerit declarar la variable com a tipus double:

Com a punt final: El mètode que utilitza Codi → Mou a l'origen no sempre insereix la funció nova de membre on probablement voleu. Per exemple, és possible que vulgueu que sigui marcada com a inline i posar-la a la part inferior del fitxer de capçalera. En un cas com aquest, escriviu la declaració i comenceu a escriure la definició de la funció de la següent manera:

El KDevelop oferirà automàticament totes les possibles complecions del que podria anar aquí. En seleccionar una de les dues entrades add_students s'obtindrà el següent codi que ja omple la llista d'arguments:

El bon codi està ben documentat, tant en l'àmbit de la implementació dels algoritmes dins de les funcions com en l'àmbit de la interfície -és a dir, les classes, les funcions (de membre i globals) i les variables (de membre i globals)- s'han de documentar per a explicar les seves intencions, possibles valors dels arguments, condicions prèvies i posteriors, etc. Pel que fa a la documentació de la interfície, el doxygen s'ha convertit en l'estàndard de facto per a donar format als comentaris que després es podran extreure i visualitzar en pàgines de cerca.

El KDevelop implementa aquest estil de comentaris proporcionant una drecera per a generar el marc de treball dels comentaris que documenten una funció de classe o funció de membre. Per exemple, suposeu que ja heu escrit el codi:

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

Ara voleu afegir documentació tant a la classe i a la funció de membre. Per a això, situeu el cursor a la primera línia i seleccioneu Codi → Documenta la declaració o premeu Alt+Maj+D. El KDevelop respondrà amb el següent:

El cursor ja es troba a l'àrea en gris perquè ompliu la descripció curta (després de la paraula clau @brief de «doxygen») d'aquesta classe. A continuació, podeu continuar afegint documentació a aquest comentari, la qual donarà un resum més detallat del que fa la classe:

Mentre l'editor resti dins del comentari, el text del comentari serà ressaltat en verd (el ressaltat desapareixerà una vegada moveu el cursor fora del comentari). En arribar al final d'una línia, premeu Retorn i el KDevelop iniciarà automàticament una línia nova que començarà amb un asterisc i posarà al cursor un caràcter de sagnat.

Ara documentarem la funció de membre, un cop més, posant el cursor a la línia de la declaració i seleccionant Codi → Documenta la declaració o prement Alt+Maj+D:

Una vegada més, el KDevelop generarà automàticament l'esquelet d'un comentari, inclosa la documentació per a la funció «itself», així com el seu tipus de retorn. En el cas actual, el nom de la funció és força autoexplicatiu, però moltes vegades els arguments de la funció poden no ser i han de ser documentats de manera individual. Per a il·lustrar-ho, considerem una funció una mica més interessant i el comentari que generarà automàticament el KDevelop:

Aquí, p. ex., el comentari suggerit ja conté tots els camps Doxygen per als paràmetres individuals.

A vegades, un vol canviar el nom d'una funció, classe o variable. Per exemple, diguem que ja tenim això:

Llavors ens adonem que estem descontents amb el nom remove_students i seria millor anomenar-la throw_out_students. Podríem fer una cerca de substitució pel nom, però això té dos inconvenients:

Ambdós problemes es poden resoldre movent el cursor sobre qualsevol de les ocurrències del nom de la funció i seleccionant Codi → Reanomena la declaració (o fent clic dret sobre el nom i seleccionant Canvia Bus::remove_students). Això mostrarà un diàleg on podreu introduir el nom nou de la funció i on també podreu veure tots els llocs on s'utilitza en realitat la funció:

La majoria dels projectes tenen peces de codi que s'ha d'escriure sovint al codi font. Els exemples són: pels escriptors del compilador, un bucle sobre totes les instruccions; pels escriptors de la interfície d'usuari, comprovar que l'entrada de l'usuari és vàlida i si no ho és, obrir un quadre d'error; en el projecte de l'autor d'aquestes línies, això seria codi del tipus

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

En lloc d'escriure aquest tipus de text una vegada darrere l'altra (amb tots els errors tipogràfics repetitius que s'introdueixin), l'eina Retalls del KDevelop us hi pot ajudar. Per a això, obriu la vista d'eina (vegeu Eines i vistes, si el botó corresponent no es troba ja en el perímetre de la vostra finestra). Després feu clic al botó «Afegeix un repositori» (un terme poc apropiat -el qual permet crear una col·lecció amb nom de retalls de codi font d'un tipus en particular, p. ex., codi font en C++-) i crear un repositori buit. A continuació, feu clic a la icona per a afegir un retall de codi, per a obtenir un diàleg com el següent:

Per a emprar un retall ja definit, quan esteu editant codi, simplement escriviu el nom del retall com ho faríeu amb qualsevol altra nom de funció o de variable. Aquest nom restarà disponible per a compleció automàtica -el que significa que no hi ha cap problema en l'ús d'un nom llarg i descriptiu per a un fragment de codi com l'anterior- i quan accepteu el suggeriment per a la compleció automàtica (p. ex., només prement la tecla Retorn), la part ja introduïda del nom del retall serà substituïda per l'expansió completa del retall i serà sagnat adequadament:

Tingueu en compte que perquè això funcioni, la vista d'eina Retalls no s'haurà d'obrir o estar visible: només es necessita sempre la vista d'eina per a definir retalls nous. Una manera alternativa, encara que menys còmoda, per a expandir un retall és simplement fer clic en la vista d'eina respectiva.