Usando CMake para gerar arquivos de projeto Visual Studio C ++

Estou trabalhando em um projeto de código aberto C ++, para código que compila em Linux e Windows. Eu uso o CMake para construir o código no Linux. Para facilitar a configuração do desenvolvimento e por razões políticas, devo me ater aos arquivos de projeto / editor do Visual Studio no Windows (não posso mudar para Code :: Blocks , por exemplo). Vejo instruções para gerar arquivos do Visual Studio usando CMake, como aqui .

Você já usou o CMake para gerar arquivos do Visual Studio antes? Como tem sido sua experiência? Suponha que eu queira adicionar um novo arquivo ao meu projeto. Qual é o fluxo de trabalho para isso?

CMake é realmente muito bom para isso. A parte principal é que todos no lado do Windows precisam se lembrar de executar o CMake antes de carregar a solução, e todos no lado do Mac precisam se lembrar de executá-lo antes do make.

A parte mais difícil foi como um desenvolvedor Windows, certificando-se de que suas mudanças estruturais estavam no arquivo cmakelist.txt e não nos arquivos da solução ou do projeto, pois essas mudanças provavelmente se perderiam e, mesmo se não fossem perdidas, não seriam transferidas para o lado do Mac que também precisava deles, e os caras do Mac precisariam se lembrar de não modificar o arquivo make pelos mesmos motivos.

Requer apenas um pouco de reflexão e paciência, mas haverá erros no início. Mas se você estiver usando a integração contínua em ambos os lados, isso será eliminado cedo e as pessoas acabarão por adquirir o hábito.

Não tenho certeza se está diretamente relacionado à pergunta, mas estava procurando uma resposta sobre como gerar * .sln a partir de projetos cmake, descobri que se pode usar algo assim:

cmake -G "Visual Studio 10"

O exemplo gera os arquivos necessários do VS 2010 a partir de um arquivo CMakeLists.txt de entrada

Mudamos a cadeia de construção de nosso departamento para o CMake e tivemos alguns obstáculos internos, já que outros departamentos estavam usando nossos arquivos de projeto e estavam acostumados a apenas importá-los para suas soluções. Também tivemos algumas reclamações sobre o CMake não estar totalmente integrado ao gerenciador de projeto / solução do Visual Studio, então os arquivos tiveram que ser adicionados manualmente ao CMakeLists.txt; essa foi uma grande quebra no fluxo de trabalho a que as pessoas estavam acostumadas.

Mas, em geral, foi uma transição bastante suave. Estamos muito felizes, pois não temos mais que lidar com arquivos de projeto.

O fluxo de trabalho concreto para adicionar um novo arquivo a um projeto é muito simples:

1. Crie o arquivo, certifique-se de que está no lugar correto.
2. Adicione o arquivo a CMakeLists.txt.
3. Construir.

O CMake 2.6 é executado automaticamente novamente se algum arquivo CMakeLists.txt for alterado (e (semi-) recarrega automaticamente a solução / projetos).

Lembre-se de que, se estiver fazendo compilações fora do código-fonte, você precisa ter cuidado para não criar o arquivo de origem no diretório de compilação (visto que o Visual Studio só conhece o diretório de compilação).

Como diz Alex, funciona muito bem. A única parte complicada é se lembrar de fazer quaisquer alterações nos arquivos cmake, em vez de no Visual Studio. Portanto, em todas as plataformas, o fluxo de trabalho é semelhante ao de usar makefiles simples e antigos.

Mas é bastante fácil de trabalhar, e não tive problemas com o cmake para gerar arquivos inválidos ou qualquer coisa assim, então não me preocuparia muito.

CMake produz projetos e soluções em Visual Studio de forma integrada. Você pode até produzir projetos / soluções para diferentes versões do Visual Studio sem fazer nenhuma alteração nos arquivos CMake.

Adicionar e remover arquivos fonte é apenas uma questão de modificar o CMakeLists.txtque contém a lista de arquivos fonte e regenerar os projetos / soluções. Existe até uma função globbing para encontrar todas as fontes em um diretório (embora deva ser usada com cuidado).

O link a seguir explica muito bem o comportamento específico do CMake e do Visual Studio.

CMake e Visual Studio

CMake pode gerar um Visual Studio .projs/ realmente bom .slns, mas sempre há o problema com a necessidade de modificar os .cmakearquivos em vez de .proj/ .sln. Como está agora, estamos lidando com isso da seguinte maneira:

1. Todos os arquivos de origem vão para /srce os arquivos visíveis no Visual Studio são apenas "links" para eles definidos em .filter.
2. O programador adiciona / exclui arquivos lembrando-se de trabalhar no /srcdiretório definido , não no diretório do projeto padrão.
3. Ao terminar, ele executa um script que "atualiza" os respectivos .cmakearquivos.
4. Ele verifica se o código pode ser construído no ambiente recriado.
5. Ele confirma o código.

No início estávamos com um pouco de medo de como isso iria acabar, mas o fluxo de trabalho funciona muito bem e com um bom diff visível antes de cada commit, todos podem ver facilmente se suas alterações foram mapeadas corretamente nos .cmakearquivos.

Mais uma coisa importante a saber é a falta de suporte ( afaik ) para "Configurações de solução" no CMake. Do jeito que está, você deve gerar dois diretórios com projetos / soluções - um para cada tipo de construção (depuração, liberação, etc.). Não há suporte direto para recursos mais sofisticados - em outras palavras: alternar entre as configurações não dará a você o que você poderia esperar.

Muitas respostas excelentes aqui, mas podem ser substituídas por este suporte CMake no Visual Studio (5 de outubro de 2016)

Comecei meu próprio projeto, chamado syncProj. Documentação / links para download aqui:

https://docs.google.com/document/d/1C1YrbFUVpTBXajbtrC62aXru2om6dy5rClyknBj5zHU/edit# https://sourceforge.net/projects/syncproj/

Se você está planejando usar o Visual Studio para desenvolvimento e, atualmente, apenas C ++ é compatível.

A principal vantagem em comparação com outros sistemas make é que você pode realmente depurar seu script, já que ele é baseado em C #.

Se você não estiver familiarizado com o syncProj, pode apenas converter sua solução / projeto em script .cs e continuar o desenvolvimento a partir desse ponto.

No cmake, você precisará escrever tudo do zero.