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

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

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

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

A completação automática poder-lhe-á poupar bastante escrita se o seu projecto usar nomes de variáveis e funções compridos; para além disso, evita os enganos nos nomes (e os erros de compilação daí resultantes) e torna muito mais simples recordar os nomes exactos das funções; por exemplo, se todos os seus métodos de leitura começarem por get_ (ler_), então a funcionalidade de completaçã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 correcta. Lembre-se que, para a completação automática funcionar, nem a declaração da classe Carro nem da variável o_meu_carro terão de estar no mesmo ficheiro onde está a escrever o código de momento. O KDevelop simplesmente tem de saber onde estão ligadas estas classes e variáveis, isto é os ficheiros aos quais é necessário ter estas ligações feitas terão de fazer parte do projecto onde está a trabalhar.

O KDevelop tem um assistente para adicionar classes novas. O procedimento está descrito em Criar uma nova classe. Pode criar uma classe simples em C++ com o modelo de C++ Básico, na categoria Classe. No assistente, poderá escolher algumas funções predefinidas, como um construtor vazio, um construtor por cópia e um destrutor.

Depois de terminar o assistente, os ficheiros novos estão criados e abertos no editor. O ficheiro de inclusão já contém guardas de inclusão e a classe nova tem todas as funções-membro que seleccionámos. 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 bus.cpp onde se encontra já o esqueleto das funções:

Para adicionar novas funções-membro, volte ao ficheiro autocarro.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 ficheiro de inclusão mas sim no ficheiro '.cpp' correspondente. Para tal, coloque o cursor sobre o nome da função e seleccione Código → Mover para o código ou carregue em Ctrl+Alt+S. Isto remove o código entre chavetas do ficheiro de inclusão (e substitui-o por um ponto-e-vírgula para terminar a declaração da função) e move-o para o ficheiro de código:

Repare que o autor ainda agora começou a escrever e que desejava inferir que a variável estudantes deveria ser provavelmente uma variável-membro da classe Autocarro, mas esta ainda não foi adicionada. Repare também como o KDevelop a sublinha para clarificar que ainda não sabe nada sobre a variável. Contudo, este problema pode ser resolvido: se carregar no nome da variável, irá aparecer a seguinte dica:

(Conseguirá obter o mesmo se carregar com o botão direito sobre o mesmo e seleccionar Resolver: Declarar Como.), podendo seleccionar “3 - private unsigned int” (com o rato, ou carregando em Alt+3) e ver como é que irá aparecer no ficheiro de inclusão:

Importa referir que o KDevelop extrai o tipo da variável a declarar a partir da expressão usada para o 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 a deseja. Por exemplo, poderá querer marcá-la como inline e colocá-la no fundo do ficheiro 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 completações possíveis do que possa aparecer aqui. Se seleccionar 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 objectivo de explicar o seu objectivo, 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 facto 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;
};

Poderá querer adicionar agora a documentação tanto à classe como à função-membro. Para isso, mova o cursor para a primeira linha e seleccione Código → Documentar a Declaração ou carregue em Alt+Shift+D. O KDevelop irá responder com o seguinte:

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

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

Agora iremos documentar a função-membro, colocando mais uma vez o cursor sobre a linha da declaração e seleccionando a opção Código → Documentar a Declaração ou carregando em 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 actual, o nome da função é bastante intuitivo, mas muitas das vezes os argumentos da função poderão não 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 das vezes, alguém poderá querer mudar o nome de uma função, classe ou variável. Por exemplo, imagine que já tem o seguinte:

Irá então concluir que está insatisfeito com o nome remover_estudantes e que se deveria chamar por exemplo largar_estudantes. Poderia 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 seleccionar Código → Mudar o nome da declaração (ou se carregar com o botão direito no nome e seleccionar a opção Mudar o nome de Autocarro::remover_estudantes). Isto irá invocar uma janela onde poderá indicar o novo nome da função e onde poderá ver todos os locais onde esta é usada:

A maioria dos projectos têm pedaços de código que uma pessoa terá de 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 utilizador, verificar se os dados do utilizador são válidos e, caso contrário, mostrar uma mensagem de erro; no projecto 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 Excertos do KDevelop podê-lo-á ajudar aqui. Para tal, abra a área de ferramenta (veja em Ferramentas e janelas se o botão correspondente não existir já na envolvência da sua janela). Depois carregue no botão “Adicionar um repositório” (um nome ligeiramente confuso — ele permite-lhe criar uma colecção de excertos com um dado nome para os ficheiros de código de um dado tipo, isto é código em C++) e crie um repositório vazio. Depois, carregue em para adicionar um excerto, aparecendo-lhe uma janela como a seguinte:

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

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