Provavelmente a funcionalidade mais útil de todas na escrita de código novo é a complementação automática. Considere, por exemplo, o seguinte pedaço de código:

class Carro {
  // ...
  public:
    std::string cor () const;
};
void xpto()
{
  Carro meu_carro;
  // ...fazer algo com esta variável...
  std::string cor = meu_carro.co

Na última linha, o KDevelop irá recordar que a variável meu_carro é do tipo Carro, como tal, irá oferecer-se para terminar o nome da função-membro co como cor. De fato, tudo o que tem que fazer é continuar a escrever até que a funcionalidade de complementação automática tenha reduzido o número de ocorrências a uma, pressionando então na tecla Enter:

Lembre-se que você poderá clicar sobre a dica para obter mais informações sobre a função, além do seu tipo devolvido e se é pública ou não:

A complementação automática poderá poupar bastante escrita se o seu projeto usar nomes de variáveis e funções compridos; além disso, evita os enganos nos nomes (e os erros de compilação daí resultantes) e torna muito mais simples recordar os nomes exatos das funções; por exemplo, se todos os seus métodos de leitura começarem por get_ (ler_), então a funcionalidade de complementação automática poderá apresentar uma lista com todos os métodos de leitura possíveis, logo que tenha escrito as primeiras quatro letras, recordando-o possivelmente no processo qual a função correta. Lembre-se que, para a complementação automática funcionar, nem a declaração da classe Carro nem da variável meu_carro terão que estar no mesmo arquivo onde está escrevendo o código no momento. O KDevelop simplesmente tem que saber onde estão ligadas estas classes e variáveis, isto é os arquivos aos quais é necessário ter estas ligações feitas terão que fazer parte do projeto onde está trabalhando.

O KDevelop possui um assistente para adicionar novas classes. O procedimento é descrito em Criando uma nova classe. Uma classe C++ simples pode ser criada selecionando o modelo C++ Básico a partir da categoria Classe. No assistente, nós podemos selecionar algumas funções-membro predefinidas, por exemplo um construtor vazio, um construtor de cópia e um destrutor.

Após completar o assistente, os novos arquivos são criados e abertos no editor. O arquivo de inclusão já contém guardas de inclusão e a classe nova tem todas as funções-membro que selecionamos. Os dois próximos passos seriam a documentação da classe e das suas funções-membro e a sua respectiva implementação. Iremos discutir algumas ajudas sobre a documentação das classes e funções depois. Para implementar as funções especiais já adicionadas, basta ir para a página onibus.cpp onde se encontra já o esqueleto das funções:

Para adicionar novas funções-membro, volte ao arquivo onibus.h e adicione o nome de uma função. Por exemplo, adicione o seguinte:

Repare como já foi iniciada a implementação. Contudo, em muitos estilos de código, a função não deveria ser implementada no arquivo de inclusão mas sim no arquivo '.cpp' correspondente. Para isso, coloque o cursor sobre o nome da função e selecione Código → Mover para o código ou pressione Ctrl+Alt+S. Isto remove o código entre chavetas do arquivo de inclusão (e o substitui por um ponto e vírgula para terminar a declaração da função) e move-o para o arquivo de código:

Repare que eu acabei de digitar e desejava inferir que a variável estudantes deveria ser provavelmente uma variável-membro da classe Ônibus, mas esta ainda não foi adicionada. Repare também como o KDevelop a sublinha para realçar que ainda não sabe nada sobre a variável. Contudo, este problema pode ser resolvido: se clicar no nome da variável, irá aparecer a seguinte dica:

(O mesmo pode ser obtido se clicar com o botão direito sobre o mesmo e selecionar Resolver: Declarar como.), podendo selecionar “3 - private unsigned int” (com o mouse, ou pressionando Alt+3) e ver como irá aparecer no arquivo de inclusão:

É importante referir que o KDevelop extrai o tipo da variável a declarar a partir da expressão usada para a inicializar. Por exemplo, se tivéssemos escrito a soma na seguinte forma, ainda que dúbia, ele teria sugerido que a variável fosse declarada como double:

Como ponto final: O método que usa o Código → Mover para o código nem sempre insere a nova função-membro onde se deseja. Por exemplo, você poderá querer marcá-la como inline e colocá-la no fundo do arquivo de inclusão. Se for esse o caso, escreva a declaração e comece a escrever a definição da função da seguinte forma:

O KDevelop oferece automaticamente todas as complementações possíveis do que possa aparecer aqui. Se selecionar um dos dois adicionar_estudantes irá mostrar o seguinte código que já preenche a lista de argumentos completa:

O bom código está bem documentado, tanto ao nível da implementação dos algoritmos dentro das funções, assim como ao nível da interface — isto é, classes, funções (membros e globais) e as variáveis (membros ou globais), com o objetivo de explicar o seu objetivo, os valores possíveis dos argumentos, as pré- e pós-condições, etc. No que diz respeito à documentação da interface, o doxygen tornou-se a norma de fato para formatar os comentários para que possam ser extraídos e apresentados em páginas Web navegáveis.

O KDevelop suporta este estilo de comentários, contendo um atalho para gerar a estrutura de comentários que documentam uma classe ou função-membro. Por exemplo, assumindo que já tenha escrito este código:

class Carro {
  public:
    std::string cor () const;
};

Você desejará agora adicionar a documentação tanto à classe como à função-membro. Para isso, mova o cursor para a primeira linha e selecione Código → Documentar a declaração ou pressione Alt+Shift+D. O KDevelop irá responder com o seguinte:

O cursor já se encontra na área em cinza para você preencher a breve descrição (depois da palavra-chave do 'doxygen' @brief) desta classe. Você poderá então continuar a adicionar a documentação a este comentário, dando uma descrição mais detalhada sobre o que a classe faz:

Enquanto o editor estiver dentro do comentário, o texto do mesmo fica realçado em verde (o realce desaparece assim que sair do comentário). Quando for para o fim de uma linha, pressione Enter para que o KDevelop inicie uma nova linha começando com um asterisco e coloca o cursor com um caractere de indentação.

Agora iremos documentar a função-membro, colocando mais uma vez o cursor sobre a linha da declaração e selecionando a opção Código → Documentar a declaração ou pressionar Alt+Shift+D:

Mais uma vez, o KDevelop irá gerar automaticamente o esqueleto de um comentário, incluindo a documentação da função em si, assim como o tipo devolvido por esta. No caso atual, o nome da função é bastante intuitivo, mas muitas das vezes os argumentos da função poderão não ser e, como tal, deverão ser documentados individualmente. Para ilustrar isto, vejamos uma função ligeiramente mais interessante e o comentário que o KDevelop irá gerar automaticamente:

Aqui, o comentário sugerido já contém todos os campos do Doxygen dos parâmetros individuais, por exemplo.

Algumas vezes, alguém poderá querer renomear uma função, classe ou variável. Por exemplo, imagine que nós já temos o seguinte:

Iremos então concluir que estamos insatisfeitos com o nome remover_estudantes e que se deveria chamar por exemplo soltar_estudantes. Poderíamos fazer uma pesquisa-substituição por esse nome, mas isso tem duas desvantagens:

Ambos os problemas poderão ser resolvidos se mover o cursor para qualquer uma das ocorrências do nome da função e selecionar Código → Renomear a declaração (ou se clicar com o botão direito no nome e selecionar a opção Renomear Onibus::remover_estudantes). Isto irá invocar uma janela onde poderá indicar o novo nome da função e onde poderá ver todos os locais onde ela é usada:

A maioria dos projetos possuem pedaços de código que uma pessoa terá que escrever frequentemente a nível de código-fonte. Os exemplos são: para os criadores de compiladores, um ciclo por todas as instruções; para os criadores de interfaces de usuários, verificar se os dados do usuário são válidos e, caso contrário, mostrar uma mensagem de erro; no projeto do autor dessas linhas, o código seria do estilo

for (nometipo Triangulacao::active_cell_iterator
       celula = triangulacao.begin_active();
     celula != triangulacao.end(); ++celula)
  ... fazer algo com a célula ...

Em vez de escrever este tipo de texto repetidamente (com todos os erros associados que isso possa introduzir), a ferramenta de Trechos do KDevelop poderá ajudá-lo aqui. Para isso, abra a área de ferramentas (veja em Ferramentas e janelas se o botão correspondente não existir já no entorno da sua janela). Depois clique no botão “Adicionar um repositório” (um nome ligeiramente confuso — ele permite-lhe criar uma coleção de trechos com um determinado nome para os arquivos de código de um determinado tipo, por exemplo código em C++) e crie um repositório vazio. Depois, clique em para adicionar um trecho, obtendo uma janela como a seguinte:

Para usar o trecho assim definido, quando estiver editando o código, basta escrever o nome do trecho como o faria com qualquer função ou variável. Este nome ficará disponível na complementação automática — o que significa que não haverá qualquer problema em usar nomes compridos e descritivos para um trecho, como o descrito acima — e quando aceitar a dica de sugestão da complementação automática (por exemplo, pressionando apenas em Enter), a parte já introduzida do nome do trecho será substituída pela expansão completa do trecho e será devidamente indentada:

Lembre-se que, para isto funcionar, a ferramenta de Trechos não precisa de estar aberta ou visível: só irá precisar da ferramenta para definir trechos novos. Uma alternativa, embora menos conveniente, para expandir um trecho é simplesmente clicar nele na área de ferramentas respectiva.