10 maneiras de personalizar Code :: Blocks

Code :: Blocks vem com configurações padrão que são o mais natural para a maioria C ++ Aplicativos- no entanto, como você começar a gastar mais e mais tempo no ambiente, você pode achar que Code :: Blocks pode ser um lugar amigável com apenas alguns ajustes .

caráter Use guia

Ou mais especificamente, não use caractere de tabulação. Esta definição não faz qualquer diferença se você está trabalhando em um projeto em que todo mundo vai sempre estar usando o Code :: Blocks. O problema com os caracteres de tabulação, no entanto, é que diferentes editores tendem a interpretar separadores de maneira diferente. Alguns editores de mover o cursor para a próxima parada de tabulação, alguns editores mover o cursor sobre um determinado número de caracteres, e não todos os editores concordam sobre quantos caracteres para alocar para uma guia. Felizmente todos os editores interpretar espaços o mesmo, por isso é muito mais seguro para dizer o código :: editor Blocos sempre usar espaços e nunca salvar guias nos arquivos de origem. Para fazer isso, selecione Configurações-Editor. Agora, selecione Configurações gerais, à esquerda e certifique-se de que Use TAB caráter é desmarcada.

destaque de sintaxe

destaque de sintaxe muda as cores de diferentes tipos de estruturas, usando uma cor para palavras-chave, uma cor diferente para nomes de variáveis, um terceiro para cadeias de caracteres, e assim por diante. Isto é muito útil para evitar erros bobos que você está digitando. Por exemplo, se você digitar incorretamente uma palavra-chave, ele não aparecerá na chave de cores. Para ativar esse recurso, selecione Configurações Editor-Syntax Highlighting. Normalmente Code :: Blocks pode dizer a língua da extensão do nome do arquivo. Se você estiver usando uma extensão de arquivo não-padrão, certifique-se de adicioná-lo à lista selecionando Filemasks. Além disso, você pode ajustar o destaque de sintaxe opções a partir desta janela para melhor atender às suas necessidades. Isto é particularmente importante se você tem algum tipo de problemas de visão, especialmente qualquer forma de daltonismo.

formatador de código fonte

Isso pode ser antiquado, mas um bom programador deve mostrar um pouco de orgulho na aparência do seu código. Isto exige a criação e a adesão firme a um padrão de codificação. Ainda mais do que isso, quando se trabalha em uma grande equipe, todos devem usar o mesmo padrão de codificação. Caso contrário, o código parece confuso, como módulos escritos por uma pessoa ter um olhar e sentir, enquanto aqueles escrito por um companheiro de equipe ter um olhar diferente - muito pouco profissional.

Forçando a adesão a um padrão de formatação de codificação é fácil no Code :: Blocks. Seu editor de código irá reformatar seu código para se adaptar a qualquer padrão desejado.

O Code :: Blocks código fonte formatador não irá ajustar os nomes de variáveis. Pior ainda, não vai tocar a sua lógica do programa. Então, se você escrever código ruim, não culpar o editor Code :: Blocks.

Selecione Configurações-Editor e selecione Source Formatter a partir da lista que aparece para obter uma janela que se parece com a Figura 1. A janela de visualização mostra o que suas escolhas vai olhar como na prática. Este exemplo segue o padrão ANSI, mas você pode escolher entre muitas outras normas comuns, ou você pode selecionar Personalizado e, em seguida, clique nas guias de recuo e formatação para criar seu próprio padrão.

Depois de selecionar um padrão, o editor vai tentar persuadi-lo a usar esse padrão. Por exemplo, se você digitar se for verdade) e pressione a tecla Enter, o editor irá colocar o cursor na posição recuada abaixo da E se. Se você, em seguida, insira uma chave aberta, o editor irá apoiá-lo, coloque a chave em linha com o Eu dentro E se, saltar para a próxima linha, e recuar mais.

Mesmo melhor, uma vez que você terminar de codificação, se você selecionar Plug In-Source Code Formatter (astyle), o editor vai passar por seu módulo e reaplicar o padrão de código fonte de corrente. Então, se o seu companheiro de trabalho não era tão cuidadoso com sua programação como você era, para não se preocupar - alguns cliques do mouse e tudo é limpo.

abreviaturas de código

Esta é uma opção estranha. Se você codificar um lote (leia-se: muito!), Abreviaturas de código pode economizar tempo, especialmente se você não é um bom datilógrafo. abreviaturas de código permite que você digite alguma palavra de código e, em seguida, pressione Ctrl + J, e voila, o editor Code :: Blocks vai entrar no modelo pré-definido correspondente que você preencha.

Por exemplo, se você fosse para entrar classe na uma cópia do Code :: Blocks e depois entrou Ctrl + J, Code :: Blocks em primeiro lugar pedir-lhe o nome de sua classe e, em seguida, ele iria preencher todo o material apresentado na Figura 2.

Code :: Blocks vem com um conjunto de abreviaturas já definidos, mas você pode adicionar todas as abreviaturas que você quer escolhendo Configurações-Editor e selecionando a opção abreviações, no lado esquerdo da janela.

A coisa boa sobre abreviação do código é que ele pode salvar um monte de digitação e aplica automaticamente o padrão de formatação de código-fonte que você selecionar. datilógrafo muito rápido (ou teria que ser keyboarder?) pode não ficar muito fora desse recurso, mas se você não usar todos os dez dedos quando você digita ou de outra forma apenas lento no teclado, você provavelmente vai querer tentar usar este característica.

AutoComplete

Code :: Blocks tem esse recurso legal chamado de conclusão automática. Depois de ter digitado algum número mínimo de letras (o padrão é quatro, mas você mudar isso), se você faz uma pausa em sua digitação, Code :: Blocks vai olhar para todas as coisas que começam com essas letras. Desta forma, Code :: Blocks pode antecipar o que é que você está tentando dizer.

Por exemplo, no programa Budget5 que está incluído com o material para download a partir Dummies.com, se introduzir Acco e, em seguida, fazer uma pausa apenas meio segundo (que não é muito longa!), em seguida, uma janela aparece como mostrado na Figura 3, que oferece as únicas duas coisas que Code :: Blocks conhece neste programa que começar com Acco: a classe Conta e o typedef AccountPtr. Desde que você significou Conta, você pode simplesmente pressionar enter e ele irá preencher isto para mim.

Neste exemplo, você está criando um ponteiro para um Conta chamado PACC. Na próxima vez que digitar pAcc-> e, em seguida, fazer uma pausa, Code :: Blocks abre uma janela listando os membros públicos Conta como mostrado na Figura 4.

Esta é uma característica interessante quando se refere a suas próprias classes. Mais do que tudo, a seleção da lista significa que você não digitar o nome da função errada ou incorreto.

Esta característica torna-se realmente interessante quando você entra em um objeto que é definido em uma biblioteca. Por exemplo, se você digitar cout., você terá uma lista dos membros públicos à disposição da cout objeto. Isto pode ser realmente útil quando você não tem documentação ou você simplesmente não sabe por onde começar.

Permitir que todos os avisos

Permitir que todas as advertências é um acéfalo. Erros que surgem em tempo de compilação são muito mais fáceis de encontrar (duh!) E fixe do que aqueles que você tem que ir caçar para si mesmo em tempo de execução. É por isso que a sintaxe do C ++ é tão exigente - ela quer ter certeza de que você tem codificado exatamente o que você destina-se antes que ele sai e cria um executável que faz algo completamente diferente.

Existem algumas coisas, no entanto, (algumas coisas, na verdade) que o compilador GNU C ++ irá corrigir e continuar sem comentário, se você quer que ele. Por exemplo, não é um erro para definir uma variável em uma função e depois nunca mais usá-lo. Ou para colocar um retorno no meio de uma função de modo a que as linhas de código após o retorno nunca pode ser executada. Estes não são erros, mas eles parecem poderoso estranho para um compilador desconfiados.

O compilador GNU irá gerar um aviso se vê qualquer um destes dois casos, ou qualquer uma das dezenas de outras construções de suspeitos em seu código. Você deve passar por cima de cada aviso para se certificar de que você entenda o que o compilador está reclamando e por quê. Tentar corrigir o problema, se você pode, mas compreendê-lo, mesmo se você optar por não corrigi-lo.

Avisos vai descobrir um monte de erros que estão prestes a se tornar erros em seus programas.

Criando um novo destino de compilação

O ambiente Code :: Blocks permite criar mais do que um destino de compilação. Um destino de compilação permite que você crie um executável separado com configurações de compilação únicos. Por exemplo, você iria querer incluir informações símbolo no executável que você usa para depuração, mas não no que você pretende enviar aos clientes (veja abaixo para mais).

Você pode mais facilmente criar um destino de depuração de construção e um alvo compilação de lançamento quando você cria o projeto - deixar o assistente faz todo o trabalho para você. No entanto, muitas vezes acontece que depois de semanas de trabalhar e depuração de um projeto, você vai para liberá-lo apenas para descobrir que não há nenhuma meta lançamento de compilação. Não se preocupe, você sempre pode criar um novo destino de compilação em seu próprio país.

Para criar um novo destino de compilação, selecione Project-Properties, selecione a guia Targets construir. Você verá algo semelhante à Figura 5, que mostra o programa Budget5 com um único alvo de depuração de compilação.

Utilize os seguintes passos para criar um alvo lançamento de compilação:

1. Selecione o destino de depuração e clique em Duplicar.

2. Digite o nome do novo destino de compilação, Release.

3. Altere o nome do arquivo de saída para bin Release Budget5.exe eo Diretório objetos de saída para obj Release .

4. Clique em Opções de compilação para definir as opções que quer compilação que você deseja para este destino específico e clique em OK.

   Você certamente vai querer transformar informações de símbolos e ligue otimização on.

5. Clique em OK para salvar o novo destino de compilação.

Para construir um destino de compilação particular, selecionar Build-Select Target, e, em seguida, escolher entre os destinos disponíveis. Isso direciona Code :: Blocks, como a que executável que você deseja criar quando você seleciona compilação.

Projeto - permitir otimizações

Você pode pensar que cada linha de código C ++ gera um conjunto de instruções da máquina, sem que se refere às linhas de código em torno dele, e no modo não-otimizado você estaria certo. O otimizador embutido no compilador GNU pode gerar um programa mais eficiente de sua fonte de C ++, olhando através de múltiplas linhas de código.

Considere o seguinte exemplo trivial e completamente formado (mas inteligente):

// I ++ - MOV EAX, i [BP] INC EAXMOV i [BP], EAX // fn (i) MOV EAX, i [BP] empurrar EAXCALL FN

Aqui, a linha i ++ Converteu-se as três linhas de código de máquina que se seguem:

1. Carregar o valor de Eu no registrador EAX.

2. Incrementar o registo EAX.

3. Armazenar o valor incrementado volta para Eu.

   A próxima linha converte a chamada fn (i) para o seguinte.

4. Carregar o valor de Eu no registrador EAX.

5. Empurre o valor de EAX na pilha.

6. Faça a chamada.

Note-se que, na verdade, Passo 4 é desnecessário. Não há nenhuma necessidade de carregar o valor de Eu no registo EAX porque o valor já está lá desde as etapas 1, 2 e 3. Mesmo um otimizador medíocre iria perceber esse fato e não gerar a segunda MOV EAX, i [BP].

Isso não é muito de uma poupança, mas este exemplo é fácil de entender, mesmo que isso não é uma grande melhoria tal. Você precisaria ser um verdadeiro gênio em linguagem assembly para entender a maioria das otimizações que o compilador GNU faz.

Você pode ativar otimizações para uma determinada compilação selecionando Opções Project-Criar, em seguida, selecionando o lançamento construir à esquerda e selecionando uma das opções de otimização.

Tecnicamente, existem várias opções de otimização, porque o otimizador pode ter um monte de tempo. Se você tem um projeto muito grande, não há muito sentido em gastar um monte de tempo para otimizar um módulo que não será executado com muita frequência. Para pequenas e projetos de médio porte, apenas permitir a otimização completa - você não vai notar a extra poucos segundos que leva para compilar.

Você pode habilitar essa opção para todas as compilações, selecionando Configurações-Compiler, em seguida, selecionando a guia Compiler e selecionando um dos casos- Optimize no entanto, esta não é uma boa ideia. Não permitir a otimização na versão de depuração do projeto, se você planeja usar o depurador. As alterações no código que executa otimizador fará com que o programa afiguram-se para saltar ao redor em um passeio semi-aleatórios quando você tenta passar por ele.

Projeto - desativar os símbolos do depurador

informações símbolo está incluído no executável exclusivamente para o uso do depurador. Esta informação não deve ser incluído na versão que você enviar para fora aos usuários: Aumenta o tamanho do executável desnecessariamente e, pior ainda, ele libera informações perigoso para hackers se deve estar a tentar encontrar uma vulnerabilidade no seu programa.

Para desativar as informações de depuração no alvo compilação de lançamento, selecionar as opções de Project-Criar, e em seguida selecione o destino de lançamento do lado esquerdo. Agora certifique-se de que os símbolos Produce depuração [g] opção é clicado off para o destino de liberação. (Agora é um bom momento para se certificar de que essa mesma opção é clicado para o destino de compilação de depuração.)

Projeto - definir os argumentos de um programa

Alguns programas são destinados a ser executado com argumentos de linha de comando. Code :: Blocks fornece o seguinte mecanismo para fornecer argumentos de linha de comando ao executar um programa de dentro do código :: ambiente blocos:

1. Selecione Argumentos Project-Set Programas '.

2. Selecione o destino de compilação na janela superior.

3. Digite o que quiser na janela Argumentos do Programa.

4. Selecione OK para fechar a janela.

Quando você entra em Iniciar ou Executar, Code :: Blocks vai fornecer esses argumentos para o seu programa.