10 Maneiras de personalizar Código:: Blocos - dummies

Código:: blocos vem com configurações padrão que são as mais naturais para a maioria das aplicações C ++; No entanto, à medida que você começa a passar mais e mais tempo no ambiente, você pode encontrar esse Código:: Os blocos podem ser um lugar mais amigável com apenas alguns ajustes.

Use o caractere da guia

Ou mais especificamente, não use o caractere da guia. Esta configuração não faz diferença se você estiver trabalhando em um projeto no qual todos estarão sempre usando o Código:: Blocos. O problema com caracteres de tabulação, no entanto, é que diferentes editores tendem a interpretar separadores de forma diferente. Alguns editores movem o cursor para a próxima parada da guia, alguns editores movem o cursor sobre um certo número de caracteres, e nem todos os editores concordam quantos caracteres devem ser alocados para uma guia. Felizmente, todos os editores interpretam os espaços do mesmo, por isso é muito mais seguro dizer ao Código:: editor de blocos para 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 o uso do caractere TAB esteja desmarcado.

Destaque de sintaxe

O realce de sintaxe altera as cores de diferentes tipos de estruturas, usando uma cor para palavras-chave, uma cor diferente para nomes de variáveis, uma terceira para cadeias de caracteres e assim por diante. Isso é muito útil para evitar erros tolos enquanto você está digitando. Por exemplo, se você escrever incorretamente uma palavra-chave, ela não aparecerá na cor da palavra-chave. Para ativar esse recurso, selecione Configurações → Editor → Destaque de sintaxe. Normalmente Código:: Os blocos podem indicar o idioma a partir da extensão do nome do arquivo. Se você estiver usando uma extensão de arquivo não padrão, certifique-se de adicioná-la à lista, selecionando as máscaras de arquivo. Além disso, você pode ajustar as opções de destaque de sintaxe desta janela para melhor atender às suas necessidades. Isto é particularmente importante se você tiver alguma forma de problemas de visão, especialmente qualquer forma de cegueira de cor.

Formatador de código-fonte

Isso pode ser antigo, mas um bom programador deve mostrar um pouco de orgulho na aparência do seu código. Isso requer a criação e a adesão constante a um padrão de codificação. Ainda mais do que isso, ao trabalhar em uma grande equipe, todos deveriam usar o mesmo padrão de codificação. Caso contrário, o código parece bagunçado, pois os módulos escritos por uma pessoa têm um aspecto e uma sensação enquanto os escritos por um colega de equipe têm um aspecto diferente - muito pouco profissional.

Forçar a aderência a um padrão de formatação de codificação é fácil em Código:: Blocos. Seu editor de código reformatará seu código para se adequar a qualquer padrão desejado.

O Código:: O formatador de código-fonte dos blocos não ajustará os nomes das variáveis. Pior ainda, não irá tocar a lógica do seu programa. Então, se você escrever código falso, não culpe o código:: editor de blocos.

Selecione Configurações → Editor e, em seguida, selecione Source Formatter da lista que parece obter uma janela que se parece com a Figura 1. A janela de visualização mostra o que suas escolhas se parecerão na prática. Este exemplo segue o padrão ANSI, mas você pode escolher entre muitos outros padrões comuns, ou você pode selecionar Personalizado e depois clicar nas guias Indentação e formatação para criar seu próprio padrão.

Figura 1: Configurar o formatador de código-fonte pode ajudá-lo a aplicar um estilo de codificação uniformemente.

Depois de selecionar um padrão, o editor tentará encorajar você a usar esse padrão. Por exemplo, se você inserir se (verdadeiro) e, em seguida, pressione Enter, o editor colocará o cursor no local recuado abaixo do se . Se você entrar em uma abraçadeira aberta, o editor irá apoiá-lo, coloque o suporte em linha com o i em se , pular para a próxima linha, e recuar.

Ainda melhor, uma vez que você terminou a codificação, se você selecionar Plug In → Source Code Formatter (AStyle), o editor passará por seu módulo e reaplicará o padrão de código-fonte atual. Então, se o seu companheiro de trabalho não fosse tão cuidadoso com sua programação quanto você, não se preocupe - alguns cliques no mouse e tudo está limpo.

abreviaturas de código

Esta é uma opção estranha. Se você codificar muito (leia: muito ! ), as abreviaturas de código podem economizar tempo, especialmente se você não é uma máquina de escrever muito boa. As abreviaturas de código permitem que você digite alguma palavra de código e, em seguida, pressione Ctrl + J e voila, o editor Código:: O editor de blocos irá inserir o modelo predefinido correspondente que você preencherá.

Por exemplo, se você inserisse > classe na cópia de Código:: Blocos e, em seguida, inseriu Ctrl + J, Código:: Blocks primeiro lhe pediu o nome da sua classe e então preencheria todas as coisas mostradas na Figura 2. < Figura 2: Usar a abreviatura do código-fonte pode poupar muito tempo se você se lembrar de usá-lo! Código:: Blocos vem com um conjunto de abreviaturas já definido, mas você pode adicionar todas as abreviaturas que deseja, escolhendo Configurações → Editor e, em seguida, selecionando a opção Abreviações no lado esquerdo da janela.

A coisa boa sobre a abreviatura de código é que ele pode economizar muita digitação e aplica automaticamente o padrão de formatação do código-fonte que você selecionou. Máquina de dactilografia muito rápida (ou seria o teclista?) Pode não tirar muito deste recurso, mas se você não usar todos os dez dedos quando você digita ou, de qualquer forma, é lento no teclado, você provavelmente deseja tentar usar isso característica.

Autocompletar

Código:: Blocks tem esse recurso legal chamado Autocompletar. Depois de digitar um número mínimo de letras (o padrão é quatro, mas você altera isso), se você pausar na sua digitação, Código:: Blocks procurará todas as coisas que começam com essas letras.Desta forma, Código:: Blocks podem antecipar o que é que você está tentando dizer.

Por exemplo, no programa Budget5 que está incluído no material para download da Dummies. com, se você entrar

Acco

e depois pausar apenas meio segundo (isso não é muito longo!), então uma janela aparece como mostrado na Figura 3 que oferece as duas únicas coisas que Code:: Blocks sabe sobre este programa que começa com o Acco: a classe Conta e o typedef AccountPtr . Como você quis dizer Conta , , você pode clicar em Enter e isso irá preencher isso para mim. Figura 3: Código:: Blocos encontra apenas duas correspondências para o Acco neste programa. O primeiro é o que eu estava procurando. Neste exemplo, você está criando um ponteiro para uma

Conta chamada pAcc . Quando o próximo tipo em pAcc -> e depois pausa, Código:: Blocks abre uma janela listando os membros públicos de Conta , como mostrado na Figura 4. Figura 4: Dado um objeto, Código:: Os blocos encontrarão os membros públicos acessíveis a partir desse objeto. Esta é uma característica interessante quando se refere às suas próprias aulas. Mais do que tudo, selecionar a partir da lista significa que você não digita o nome da função errado ou com erros ortográficos.

Esse recurso realmente se torna interessante quando você insere um objeto definido em uma biblioteca. Por exemplo, se você inserir

cout., você receberá uma lista dos membros públicos disponíveis para o objeto cout . Isso pode ser realmente útil quando você não possui documentação ou simplesmente não sabe por onde começar. Ativar todos os avisos Ativar todos os avisos é um acéfalo. Erros que aparecem no tempo de compilação são muito mais fáceis de encontrar (duh!) E corrigem do que aqueles que você precisa ir caçar sozinho no tempo de execução. É por isso que a sintaxe C ++ é tão exigente - quer certificar-se de que você codificou exatamente o que você pretendia antes de sair e cria um executável que faz algo completamente diferente.

Há algumas coisas, no entanto, (algumas coisas, na verdade) que o compilador GNU C ++ irá corrigir e continuar sem comentários, se você quiser. Por exemplo, não é um erro definir uma variável em uma função e, em seguida, nunca usá-la. Ou para colocar um retorno no meio de uma função para que as linhas de código após o retorno nunca possam ser executadas. Estes não são erros, mas eles parecem muito estranhos para um compilador desconfiado.

O compilador GNU irá gerar um aviso se ele vir qualquer um desses dois casos ou qualquer uma das dezenas de outras construções suspeitas em seu código. Você deve examinar todas as advertências para se certificar de que você entende o que o compilador está reclamando e por quê. Tente consertar o problema se você puder, mas entende isso mesmo se você optar por não consertá-lo.

Avisos vão descobrir muitos erros que estão prestes a se tornarem insetos em seus programas.

Criando um novo objetivo de compilação

O código:: O ambiente de blocos permite que você crie mais de um alvo de compilação. Um alvo de compilação permite que você crie um executável separado com configurações de compilação exclusivas.Por exemplo, você definitivamente gostaria de incluir informações de símbolos no executável que você usa para depurar, mas não no que você pretende enviar aos clientes (veja abaixo para mais).

Você pode criar mais facilmente um objetivo de compilação Debug e um objetivo de compilação Release ao criar o projeto - deixe o assistente fazer todo o trabalho para você. No entanto, muitas vezes acontece que depois de semanas de trabalho e depuração de um projeto, você vai liberá-lo apenas para descobrir que não há um objetivo de construção da versão. Não se preocupe, você sempre pode criar um novo objetivo de compilação por conta própria.

Para criar um novo objetivo de compilação, selecione Projeto → Propriedades, selecione a guia Criar alvos. Você verá algo que se parece com a Figura 5, que mostra o programa Budget5 com um único objetivo de compilação do Debug.

Figura 5: uma das propriedades do projeto é a lista de metas de compilação.

Use as seguintes etapas para criar um objetivo de compilação de versão:

Selecione o alvo de depuração e clique em Duplicar.

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

1. Altere o Nome do Arquivo de Saída para binReleaseBudget5. exe e o diretório de saída de objetos para objRelease.

2. Clique em Construir opções para definir quaisquer opções de construção que você deseja para este destino específico e clique em OK.

3. Você definitivamente deseja desativar as informações do símbolo e ativar a otimização.

4. Clique em OK para salvar o novo objetivo de compilação.

   Para criar um determinado objetivo de compilação, selecione Criar → Selecionar destino e, em seguida, escolha entre os alvos disponíveis. Isso direciona o código:: bloqueia o executável que deseja criar quando você seleciona a compilação.

5. Projeto - habilite otimizações

Você pode pensar que cada linha do código C ++ gera um conjunto de instruções da máquina sem considerar as linhas de código ao seu redor e, em modo não otimizado, você estaria certo. O otimizador incorporado no compilador GNU pode gerar um programa mais eficiente da sua fonte C ++, olhando através de várias linhas de código.

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

// i ++; MOV EAX, i [BP] INC EAX MOV i [BP], EAX // fn (i) MOV EAX, i [BP] PUSH EAX CALL FN

Aqui a linha

i ++

foi convertida no três linhas de código de máquina que se seguem: Carregue o valor de i

1. no registro EAX. Incremente o registro EAX. Armazena o valor incrementado novamente em

2. i

3. . A próxima linha converte a chamada fn (i)

   para o seguinte. Carregue o valor de i

4. no registro EAX. Empurre o valor de EAX para a pilha. Faça a chamada.

5. Observe que o Passo 4 é realmente desnecessário. Não é necessário carregar o valor de

6. i

no registro EAX porque o valor já existe nos Passos 1, 2 e 3. Mesmo um otimizador medíocre notaria esse fato e não geraria o segundo MOV EAX, i [BP] . Esta não é uma grande poupança, mas este exemplo é fácil de entender, mesmo que não seja uma grande melhoria. Você precisaria ser um whiz real na linguagem de montagem para entender a maioria das otimizações que o compilador GNU faz. Você pode habilitar otimizações para uma compilação específica, selecionando Projeto → Opções de compilação e, em seguida, selecionando a compilação de versão à esquerda e selecionando uma das opções de otimização.

Tecnicamente, existem várias opções de otimização porque o otimizador pode demorar muito tempo. Se você tem um projeto muito grande, não há muito interesse em gastar muito tempo otimizando um módulo que não será executado com muita frequência. Para projetos de pequeno a médio porte, apenas ative otimização total - você não notará alguns segundos extras para compilar.

Você pode habilitar esta opção para todas as compilações selecionando Configurações → Compilador, depois selecionando a guia Compilador e selecionando um dos casos Optimizar; No entanto, esta não é uma boa ideia. Não habilite otimização na versão Debug do projeto se você planeja usar o depurador. As mudanças no código que o otimizador executa farão com que o programa pareça saltar em uma caminhada semi-aleatória quando você tenta passar por isso.

Projeto - desative os símbolos do depurador

As informações de símbolo estão incluídas no executável exclusivamente para o uso do depurador. Esta informação não deve ser incluída na versão que você envia para os usuários: aumenta o tamanho do executável desnecessariamente e, pior ainda, ele libera informações perigosas para hackers se alguém estiver tentando encontrar uma vulnerabilidade em seu programa.

Para desabilitar informações de depuração no objetivo de versão, selecione Projetar → Construir opções e, em seguida, selecione o destino de liberação à esquerda. Agora, certifique-se de que a opção Produce Debugging Symbols [-g] seja clicada para o destino Release. (Agora é um bom momento para garantir que esta mesma opção seja clicada no alvo de compilação Debug.)

Projeto - configurando argumentos de um programa

Alguns programas devem ser executados com argumentos de linha de comando. Código:: Blocks fornece o seguinte mecanismo para fornecer argumentos de linha de comando ao executar tal programa dentro do Código:: Ambiente de Blocos:

Selecionar Projeto → Definir Argumentos de Programas.

Selecione o alvo de compilação na janela superior.

1. Digite o que quiser na janela Argumentos do programa.

2. Selecione OK para fechar a janela.

3. Quando você insere Iniciar ou Executar, Código:: Os blocos fornecerão esses argumentos ao seu programa.