// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Editando e Navegando em Arquivos de Código-fonte C/C++ - Tutorial do NetBeans IDE
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Editando e Navegando em Arquivos de Código-fonte C/C++ - Tutorial do NetBeans IDE - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Editando e Navegando em Arquivos de Código-fonte C/C++ - Tutorial do NetBeans IDE

_Colaboração de _Ann Rice_ e mantida por _Susan Morgan_
Março de 2014_ [Número da revisão: V8.0]

Este tutorial resumido orienta você em algumas funcionalidades de navegação e edição dos arquivos de código-fonte em um projeto C ou C++ no NetBeans IDE.



image::images/netbeans-stamp-80-74.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.4 e 8.0"]

|===
|-  |<<requirements,Requisitos>> 

|-  |<<project,Criando o Projeto de Amostra>> 

|-  |<<editing,Editando Arquivos de Código-fonte C e C++>> 

|-  |<<navigating,Navegando em Arquivos de Código-fonte C e C++>> 

|-  |<<nextsteps,Próximas Etapas>> 
|===


== Requisitos

*Para seguir este tutorial, são necessários os recursos e o software a seguir.*

|===
|Software ou Recurso |Versão Necessária 

|NetBeans IDE |link:https://netbeans.org/downloads/index.html[+ versão 7.4 ou 8.0 do NetBeans com o plug-in C/C+++] 

|JDK (Java Developer Kit) |link:http://java.sun.com/javase/downloads/index.jsp[+versão 7 ou 8+] 
|===


Consulte as link:../../../community/releases/80/install.html[+Instruções de Instalação do NetBeans IDE 8.0+] e a link:../../../community/releases/80/cpp-setup-instructions.html[+ Configuração do NetBeans IDE para o C/C++/Fortran+]
para obter informações sobre o download e a instalação do software necessário.

*Projetos de Amostra*

Apenas deseja brincar com alguns projetos? No IDE, escolha Arquivo > Projeto Novo e, em seguida, abra a categoria Amostras e a subcategoria C/C++. O IDE fornece vários projetos C e C++ de amostra para ajudá-lo a se familiarizar com o IDE.


== Criando o Projeto de Amostra

O NetBeans IDE com o plug-in C/C++ fornece funcionalidades avançadas de edição para modificar o código-fonte. Para explorar essas funcionalidades, usaremos o projeto  ``Quote`` . Caso você ainda não tenha criado esse projeto, faça o seguinte:

1. Escolha Arquivo > Novo Projeto.
2. No assistente do projeto, expanda a categoria Amostras e selecione a subcategoria C/C++.
3. Selecione o projeto  ``Quote`` . Clique em Próximo e, em seguida, Finalizar.


== Editando Arquivos de Código-fonte C e C++


=== Definindo o Estilo de Formatação

Você pode utilizar a janela Opções para configurar o estilo de formatação default dos seus projetos C e C++.

1. Escolha Ferramentas > Opções.
2. Clique em Editor no painel superior da janela.
3. Clique na guia Formatação.
4. Selecione a linguagem C++ da lista drop-down Linguagem, pois o projeto Quote utiliza C++.
5. Selecione o estilo que deseja definir na lista drop-down Estilo.
image::images/formatting_style.png[]
6. Modifique as propriedades de estilo, conforme desejado.


=== Dobrando Blocos de Código em Arquivos C e C++

Para alguns tipos de arquivos, você pode utilizar a funcionalidade de dobramento de código para contrair blocos de código, de forma que somente a primeira linha do bloco apareça no Editor de Código-fonte.

1. No projeto da aplicação  ``Quote_1`` , abra a pasta Arquivos do código-fonte e clique duas vezes no arquivo  ``cpu.cc``  para abri-lo no Editor de Código.
2. Clique no ícone para contrair (caixa pequena com sinal de menos) na margem esquerda para dobrar o código de um dos métodos.
3. Passe o mouse sobre o símbolo  ``{...}``  à direita do bloco dobrado para exibir o código no bloco. 
image::images/code_folding.png[]


=== Utilizando Realce de Semântica

Se essa opção estiver selecionada, quando você clicar em uma classe, função, variável ou macro, todas as ocorrências dessa classe, função, variável ou macro no arquivo atual são realçadas.

1. Escolha Ferramentas > Opções.
2. Clique em Editor no painel superior da janela.
3. Clique na guia Realce.
4. Certifique-se de que todas as caixas de seleção estejam marcadas.
5. Clique em OK.
6. No arquivo  ``customer.cc``  do projeto  ``Quote_1`` , observe que esses nomes de métodos estão realçados com negrito.
7. Clique em uma ocorrência da classe  ``Cliente`` .
8. Toas as ocorrências da classe  ``Cliente``  no arquivo estão realçadas com um fundo amarelo. A margem da direita também mostra marcações que indicam pontos onde uma ocorrência está localizada no arquivo. As marcações permitem a visualização de quantas ocorrências existem sem rolar o arquivo. É possível clicar nas marcações para saltar às ocorrências que elas representam.
image::images/highlighting1.png[]
9. Para navegar facilmente entre as ocorrências, pressione as teclas Alt+Seta para baixo para ir para a próxima ocorrência e Alt+Seta para cima para ir para a ocorrência anterior.
10. Abra o arquivo  ``customer.h`` , localizado na pasta Cabeçalho e observe que nomes de método estão novamente realçados em negrito.
image::images/highlighting2.png[]


=== Utilizando Autocompletar Código e Documentação

O IDE tem uma funcionalidade dinâmica de autocompletar código C e C++ que permite que você digite um ou mais caracteres e, em seguida, exiba uma lista de possíveis classes, métodos, variáveis, e assim por diante, que podem ser usados para concluir a expressão automaticamente.

O IDE também localiza dinamicamente documentações para as classes, funções, métodos e etc. e exibe a documentação em uma janela pop up.

1. Abra o arquivo  ``quote.cc``  no projeto  ``Quote_1`` 
2. Na primeira linha em branco do  ``quote.cc`` , digite a letra C em maiúsculo e pressione Ctrl-Espaço. A caixa de autocompletar código exibe uma pequena lista que inclui as classes  ``Cpu``  e  ``Cliente`` . Uma janela de documentação também aparece, mas exibe "Nenhuma documentação encontrada" porque a fonte do projeto não inclui documentação para esse código.
3. Expanda a lista de itens pressionando Ctrl-Espaço novamente. 
image::images/code_completion1.png[]
4. Utilize as teclas de seta ou o mouse para realçar uma função de biblioteca padrão como  ``calloc``  e a janela da documentação exibe a página do manual para essa função se a página do manual está acessível para o IDE.
image::images/code-completion-documentation.png[]
5. Selecione a classe  ``Cliente``  e pressione Enter.
6. Complete a nova instância da classe  ``Cliente``  digitando "  ``andrew;`` ". Na próxima linha, digite a letra  ``a``  e pressione Ctrl-Espaço. A caixa de autocompletar código exibe uma lista de opções começando com a letra  ``a`` , tais como argumentos de método, campos de classe e nomes globais, que podem ser acessados no menu de contexto.
image::images/code_completion2.png[]
7. Clique duas vezes na opção  ``andrew``  para aceitá-la e digite um ponto depois dela. Pressione Ctrl + Espaço e você receberá automaticamente uma lista dos métodos e campos públicos da classe  ``Cliente`` .
image::images/code_completion3.png[]
8. Delete o código que você adicionou.


=== Adicionando Documentação de Códigos-fonte

É possível adicionar comentários ao código para gerar automaticamente documentação para as funções, classes e métodos. O IDE reconhece comentários que utilizam sintaxe Doxygen e gera documentação automaticamente. O IDE também pode gerar automaticamente um bloqueio aos comentários para documentar a função abaixo do comentário.

1. No arquivo  ``quote.cc`` , coloque o cursor na linha 75 ou na linha abaixo da linha 
 ``int readNumberOf(const char* item, int mín, int máx) {`` 
2. Digite uma barra e dois asteriscos e pressione Enter. O editor insere um comentário doxygen-formatado para a classe  ``readnumberof`` . 
image::images/doxygen_comment.png[]
3. Adicione algum texto descritivo para cada uma das linhas @param e salve o arquivo. 
image::images/doxygen_comment_edited.png[]
4. Enquanto a classe  ``readNumberOf``  ainda está realçada em amarelo, clique em um dos marcadores de ocorrência na direita para saltar para o local onde a classe é utilizada.
5. Clique na classe  ``readNumberOf``  na linha para qual você saltou e pressione Ctrl-Shift-Espaço para mostrar a documentação recentemente adicionada aos parâmetros.
image::images/doxygen_displayed.png[]
6. Clique em qualquer lugar no arquivo para finalizar a janela de documentação, e clique na classe  ``readNumberOf`` .
7. Escolha Código-fonte > Mostrar Documentação para abrir novamente a janela de documentação da classe.


=== Usando Modelos de Código

O Editor de Código-fonte tem um conjunto de modelos de código personalizáveis para snippets de código C e C++. É possível gerar o snippet de código completo digitando a abreviação e pressionando a tecla Tab. Por exemplo, no arquivo  ``quote.cc``  do projeto  ``Quote`` :

1. Digite  ``uns``  seguido por uma guia e  ``uns``  expande para  ``não assinado`` .
2. Digite  ``iff``  seguido por uma guia e  ``iff``  expande para  ``if(exp) {}`` .
3. Digite  ``ife``  seguido por uma guia e  ``ife``  expande para  ``if(exp) {} else {}`` .
4. Digite  ``fori``  seguido por uma guia e  ``fori``  expande para  ``para (int i = 0; i < size; i++) { Object elem = array[i];`` .

Para ver todos os modelos do código disponíveis, modifique o código modelos, criar seus próprios modelos de código, ou selecione uma chave diferente para expandir a modelos de código:

1. Escolha Ferramentas > Opções.
2. Na caixa de diálogo Opções, selecione Editor e clique na guia Modelos de Código.
3. Selecione o idioma apropriado na lista drop-down de Idiomas.
image::images/code_templates.png[]


=== Usando Conclusão de Par

Quando você edita os arquivos-fonte C e C++, o Editor de Código-fonte efetua a correspondência "inteligente" de pares de caracteres, como colchetes, parênteses e aspas. Quando você digita um desses caracteres, o Editor de Código-fonte insere automaticamente o caractere de fechamento.

1. No projeto  ``Quote_1`` , coloque o cursor na linha 115 do arquivo  ``module.cc``  e pressione Retornar para abrir uma linha nova.
2. Digite  ``enum state {``  e pressione Retornar. O colchete de fechamento e o ponto-e-vírgula são adicionados automaticamente e o cursor é colocado na linha entre os colchetes.
3. Digite  ``inválido=0, com sucesso=1``  na linha entre os colchetes para concluir a enumeração.
4. Na linha após o  ``};``  de fechamento da enumeração, digite  ``if (``  e você deverá ver se um parênteses de fechamento foi adicionado automaticamente e o cursor foi colocado entre os parênteses.
5. Digite  ``v==null``  entre os parênteses. Em seguida, digite  `` {``  e a nova linha depois do parêntese à direita. O colchete de fechamento é adicionado automaticamente.
6. Delete o código que você adicionou.


=== Localizando Texto em Arquivos do Projeto

Você pode usar a caixa de diálogo Localizar nos Projetos para pesquisar projetos para instâncias de texto especificado ou uma expressão regular.

1. Abrir a caixa de diálogo Localizar nos Projetos por meio de um dos seguintes procedimentos:
* Escolha Editar >Localizar nos Projetos.
* Clique com o botão direito do mouse no projeto na janela Projetos e escolha Localizar.
* Pressione Ctrl+Shift+F.
2. Na caixa de diálogo Localizar nos Projetos, selecione a guia de Pesquisa Default ou a guia Grep. A guia Grep usa o utilitário  ``grep`` , que fornece uma pesquisa mais rápida, principalmente para projetos remoto. 
image::images/find_in_projects.png[]
3. Na guia Grep, digite o texto ou expressão regular que você deseja pesquisar, especifique o escopo da pesquisa e o padrão de nome do arquivo e marque a caixa de seleção Abrir em Nova Guia, de forma que você possa salvar várias pesquisas em guias separadas.
4. Clique em Localizar.
A guia Resultados da Pesquisa lista os arquivos em que o texto ou expressão regular é encontrado.

Os botões da margem esquerda permitem que você altere sua view dos resultados da pesquisa.

image::images/find_in_projects2.png[]
5. Clique no botão Expandir/Contrair para contrair a lista de arquivos, de forma que só os nomes de arquivo sejam mostrados. Clique nos outros botões para mostrar os resultados da pesquisa, como uma árvore de diretório ou uma lista de arquivos. Estas opções são úteis quando você executa uma pesquisa em vários projetos.
6. Clique duas vezes em um dos itens da lista e o IDE o conduzirá para o local correspondente no editor de código-fonte.


== Navegando em Arquivos de Código-fonte C e C++

O NetBeans IDE com o plug-in C/C++ fornece funcionalidades avançadas de edição para modificar o código-fonte. Para explorar essas funcionalidades, continue usando o projeto  ``Quote_1`` .


=== Utilizando a Janela Classes

A janela Classes permite exibir todas as classes do projeto ++ e os membros e campos de cada classe.

1. Clique na guia Classes para exibir a janela Classes. Se a guia Classes não for exibida, escolha Janela > Classes
2. Expanda o nó  ``Quote_1``  na janela Classes. São listadas todas as classes do projeto.
3. Expanda a classe  ``Cliente`` . 
image::images/classes_window.png[]
4. Clique duas vezes na variável  ``name``  para abrir o arquivo de cabeçalho  ``customer.h`` .


=== Usando a Janela Navegador

A janela Navegador oferece uma view compacta do arquivo selecionado atualmente e simplifica a navegação entre diferentes partes do arquivo. Se a janela do Navegador não for exibida, escolha a janela Navegador > Navegando >para abri-la.

1. Clique em qualquer parte do arquivo  ``quote.cc``  na janela Editor.
2. Uma view compacta do arquivo é exibida na janela Navegador.
image::images/navigator_window.png[]
3. Para navegar para um elemento do arquivo, clique duas vezes no elemento na janela Navegador e o cursor na janela Editor se move para esse elemento.
4. Clique com o botão direito no Navegador para escolher uma maneira diferente para classificar os elementos, agrupar os itens ou filtrá-los.

Para descobrir o que os ícones no Navegador representam, abra a ajuda on-line do IDE escolhendo Ajuda > Conteúdo de Ajuda e busque por "ícones de navegação" na janela de ajuda.


=== Localizando Classe, Método e Usos de Campo

Você pode utilizar a janela Usos para mostrar todo lugar em que uma classe (estrutura), função, variável, macro ou arquivo é usado no código-fonte do projeto.

1. No arquivo  ``customer.cc`` , clique com o botão direito do mouse na classe  ``Cliente`` , linha 42 e escolha Localizar Usos.
2. Na caixa de diálogo Localizar Usos, clique em Localizar.
3. A janela Usos se abre e exibe todos os usos da classe  ``Cliente``  nos arquivos de código-fonte do projeto.
image::images/usages_window.png[]
4. Clique nos botões de seta na margem esquerda para percorrer as ocorrências e mostrá-las no Editor, ou altere entre view lógica e física. Você também pode filtrar as informações usando uma segunda coluna dos botões na margem esquerda.


=== Usando o Gráfico de Chamada

A janela Gráfico de Chamada exibe duas views das relações de chamadas entre as funções no projeto. Uma view em árvore mostra as funções chamadas de uma função selecionada ou as funções que chamam a função selecionada. Uma view gráfica mostra a relação chamada utilizando setas entre as funções chamadas e de chamada.

1. No arquivo  ``quote.cc`` , clique com o botão direito do mouse na função  ``main``  e escolha Mostrar Gráfico de Chamada.
2. A janela Gráfico de Chamada abre e exibe uma view em árvore e gráfica de todas as funções chamadas da função  ``principal`` .
image::images/call_graph1.png[]

Se não for possível visualizar todas as funções mostradas aqui, clique no terceiro botão no lado esquerdo da janela Gráfico de Chamada para mostrar "quem é chamado para essa função."

3. Expanda o nó  ``endl``  para exibir as funções chamadas por tal função. Observe que o gráfico é atualizado para mostrar as funções chamadas por  ``endl``  também.
4. Clique no segundo botão, chamado Trazer para o Foco no lado esquerdo da janela para focar na função  ``endl``  e, em seguida, clique no quarto botão Quem Chama esta Função para exibir todas as funções que chamam a função  ``endl`` . 
image::images/call_graph2.png[]
5. Expanda alguns nós da árvore para ver mais funções.
image::images/call_graph3.png[]


=== Usando Hiperlinks

A navegação de hiperlink permite que você salte da chamada de uma classe, método, variável ou constante para a sua declaração, e da sua declaração para sua definição. Os hiperlinks também permitem que você salte de um método que é substituído para o método que o substitui e vice-versa.

1. No arquivo  ``cpu.cc``  do projeto  ``Quote_1`` , mova o mouse sobre a linha 37 enquanto o Ctrl estiver pressionado. A função  ``ComputeSupportMetric``  está realçada e uma anotação exibe informações sobre a função.
image::images/hyperlinks1.png[]
2. Clique no hiperlink e o editor saltará para a definição da função.
image::images/hyperlinks2.png[]
3. Mova o mouse sobre a definição quanto o Ctrl estiver pressionado e clique no hiperlink. O editor salta para a declaração da função no arquivo de cabeçalho  ``cpu.h`` .
image::images/hyperlinks3.png[]
4. Clique na seta da esquerda na barra de ferramentas do editor (segundo botão da esquerda) e o editor salta de volta para a definição no  ``cpu.cc`` .
5. Passe o cursor do mouse sobre o círculo verde na margem esquerda e veja a anotação que indica que este método substitui qualquer outro método.
image::images/overide_annotation.png[]
6. Ao clicar no círculo verde para ir para o método substituído, você salta para o arquivo de cabeçalho  ``module.h`` , que mostra um círculo cinza na margem para indicar que o método está substituído.
7. Um clique no círculo cinza e o editor exibe uma lista de métodos que substituíram esse método.
image::images/overridden_by_list.png[]
8. Ao clicar no item  ``Cpu::ComputeSupportMetric`` , você salta de volta para a declaração do método no arquivo de cabeçalho  ``cpu.h`` .


=== Utilizando a Hierarquia de Inclusão

A janela Hierarquia de Inclusão permite que você inspecione todos os arquivos-fonte e de cabeçalho que são direta ou indiretamente incluídos em um arquivo-fonte ou todos os arquivos de cabeçalho que direta ou indiretamente incluem um arquivo de cabeçalho.

1. No projeto  ``Quote_1`` , abra o arquivo  ``module.cc``  no Editor de Código-fonte.
2. Clique com o botão direito do mouse na linha  ``#include "module.h"``  no arquivo e escolha Navegar > Exibir Hierarquia de Inclusões.
3. Como default, a janela Hierarquia exibe uma lista sem formatação de arquivos que incluem diretamente o arquivo de cabeçalho. Clique no botão mais à direita na parte inferior da janela para alterar a view em árvore. Clique no segundo botão da direita para alterar a exibição para todos os arquivos que incluem ou são incluídos. Expanda os nós na view em árvore para ver todos os arquivos de código-fonte que incluem o arquivo de cabeçalho.
image::images/includes_hierarchy.png[]


=== Utilizando a Hierarquia de Tipo

A janela Hierarquia de Tipo permite que você inspecione todos os subtipos ou supertipos de uma classe.

1. No projeto  ``Quote_1`` , abra o arquivo  ``module.h`` .
2. Clique com o botão direito do mouse na declaração da classe  ``Módulo``  e escolha Navegar > Exibir Hierarquia de Tipo.
3. A janela Hierarquia exibe todos os subtipos da classe Módulo.
image::images/type_hierarchy.png[]


=== [[Próximas Etapas]] 

Consulte link:debugging.html[+Depurando Projetos C/C+++] para um tutorial sobre a utilização de algumas das funcionalidades para depurar um projeto C ou C++ no NetBeans IDE.

link:mailto:users@cnd.netbeans.org?subject=Feedback:%20Editing%20and%20Navigating%20C/C++%20Source%20Files%20-%20NetBeans%20IDE%207.3%20Tutorial[+Enviar Feedback neste Tutorial+]
