Introdução

Ao programar em C e C ++ você costuma dividir seus protótipos de função e funções reais em um .h/ .hppe .c/ .cpparquivo. Infelizmente, é muito entediante transferir os protótipos de função de um arquivo para outro e requer a abertura de ambos os arquivos ao mesmo tempo (ou uma boa memória), além de muitas digitações desnecessárias, especialmente quando são feitas alterações nos argumentos ou nomes de membros. feito.

Exemplo

foo.hpp:

int someFunction(int someArgument);

class someClass
{
     public:
     someClass();
     ~someClass();

     int anotherFunction(int anotherArgument);
};

foo.cpp:

#include "foo.hpp"

int someFunction(int someArgument)
{
    // Code goes here
}

someClass::someClass()
{
    // Code goes here
}

someClass::~someClass()
{
    // Code goes here   
}

int someClass::anotherFunction(int anotherArgument)
{
    // Code goes here
}

Questão

Existe uma maneira de criar e atualizar automaticamente as funções foo.cppusando as definições e protótipos foo.hpp?

Uau, este foi divertido!

:g/.*\n^{/yank A<cr>:bn<cr>pkdd:%s/$/;/<cr>:g/::/d B<cr>A<cr><cr>class <cr>{<cr>};<esc>"BP:%s/[^ ]\+:://<cr>j%jyt(kk$p=ipjA<cr>public:<esc>

Você pode ir em frente e mapear isso para uma única tecla pressionada no seu .vimrc:

nnoremap <C-b> :g/.*\n^{/yank A<cr>:bn<cr>pkdd:%s/$/;/<cr>:g/::/d B<cr>A<cr><cr>class <cr>{<cr>};<esc>"BP:%s/[^ ]\+:://<cr>j%jyt(kk$p=ipjA<cr>public:<esc>

Observe que isso pressupõe que o construtor seja o primeiro método de classe a aparecer. (Eu poderia consertar isso, mas prefiro mantê-lo simples. Por favor, mencione em um comentário se você precisar desse conserto.)

Isso também pressupõe que o buffer do arquivo de cabeçalho esteja vazio e localizado diretamente após o buffer do arquivo de origem.

Explicação passo a passo:

:g/.*\n^{/yank A<cr>            Yank all the function definitions (power of g!)
:bn<cr>                         Move to the header file buffer
pkdd                            Put in the function definitions
:%s/$/;/<cr>                    Add semicolons
:g/::/d B<cr>                   Grab the class methods and put them in register B
A<cr><cr>class <cr>{<cr>};<esc> Self-explanatory, add class skeleton
"BP                             Put the class methods in the class
:%s/[^ ]\+:://<cr>              Remove someClass::
j%jyt(kk$p                      Add the actual class name
=ip                             Fix indentation
jA<cr>public:<esc>              Add the `public:' modifier

O :GOTOIMPLcomando do lh-cpp é capaz de pular para uma definição de função a partir de sua declaração ou fornecer uma definição vazia padrão, caso nenhuma foi encontrada.

Alguns recursos que eu posso pensar:

• O comando já entende comentários, especificações de exceção, palavras-chave que não podem ser copiados (mas possivelmente copiados nos comentários) ( virtual, static...).
• O escopo atual da função é decodificado (namespaces :: classes :: ...) e relatado corretamente (ou seja, não será um prefixo ns::se estiver dentro namespace ns{ou dentro de um using namespace ns;contexto.

Contudo:

• Modelos ainda não são compreendidos.
• O corpo da função deve ser construído manualmente, um após o outro - ou seja, ainda não tomei tempo para executar: GOTOIMPL em todas as declarações de funções que ctags poderiam me indicar.