<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Configurando o NetBeans IDE para C/C++/Fortran - NetBeans IDE 6.9</title>
<meta name="DESCRIPTION" content="Configuring the NetBeans IDE for C/C++/Fortran - NetBeans IDE 6.9">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">

</head>
<body>
<a name="top"></a>

<h1>Configurando o NetBeans IDE para C/C++/Fortran</h1>
<!-- START INTRO ---------------------------------------------------------------------------------------* -->
<div class="articledate" style="margin-left: 0px;font-style:italic;">


Junho de 2010</em> [N&uacute;mero de revis&atilde;o: V6.9-1]</div>
<p>Este documento fornece informa&ccedil;&otilde;es sobre o download, a instala&ccedil;&atilde;o e a configura&ccedil;&atilde;o do suporte a C/C++ no IDE NetBeans. Antes de come&ccedil;ar a desenvolver em C/C++, o NetBeans IDE requer o m&oacute;dulo de plug-in do C/C++, os compiladores C/C++ de terceiros, os utilit&aacute;rios <code>make</code> e os depuradores.
</p>

<!-- END INTRO -->
<h3>Conte&uacute;do</h3>
<img src="../../../images_www/articles/69/netbeans-stamp.gif" class="stamp"
alt="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 6.9 "
title="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 6.9">
    <ul class="toc">
        <li><a href="#downloading" title="Ativando o C/C++/Fortran no IDE"> Ativando o C/C++/Fortran no IDE</a></li>
        <li><a href="#compilers" title="Instalando e configurando compiladores e ferramentas">Instalando e configurando compiladores e ferramentas</a></li>
        <li><a href="#verifying" title="Verificando a instala&ccedil;&atilde;o">Verificando a instala&ccedil;&atilde;o</a></li>
      <li><a href="#ts" title="Ferramentas de solu&ccedil;&atilde;o de problemas">Ferramentas de solu&ccedil;&atilde;o de problemas</a></li>

    </ul>


 <p><b>Para seguir este tutorial, voc&ecirc; precisa dos seguintes recursos e softwares.</b></p>

    <table>
        <tbody>

            <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o necess&aacute;ria</th>
            </tr>
           <tr>
<td class="tbltd1">NetBeans IDE</td>
<td class="tbltd1"><a
href="https://netbeans.org/downloads/index.html"> vers&atilde;o 6.9 com NetBeans com o plug-in C/C++</a></td>
</tr>
<tr>
<td class="tbltd1">Java Developer Kit (JDK)</td>
<td class="tbltd1"><a href="http://java.sun.com/javase/downloads/index.jsp">vers&atilde;o 6</a></td>
</tr>
        </tbody>
</table>



<br>
<!-- DOWNLOADING ---------------------------------------------------------->
<h2><a name="downloading">Ativando o C/C++/Fortran no IDE</a></h2>
<p>
O NetBeans IDE &eacute; um ambiente de desenvolvimento integrado modular e din&acirc;mico, o que significa que pode ser alterado atrav&eacute;s da adi&ccedil;&atilde;o e remo&ccedil;&atilde;o de m&oacute;dulos do programa. &Eacute; poss&iacute;vel acrescentar funcionalidades com a instala&ccedil;&atilde;o de m&oacute;dulos de plug-in ou remover funcionalidades ao desinstalar os m&oacute;dulos de plug-in. Consulte a ajuda on-line do NetBeans IDE para obter mais informa&ccedil;&otilde;es sobre os plug-ins.</p>
<p>
Se quiser trabalhar com os programas C, C++ ou Fortran no NetBeans IDE, a instala&ccedil;&atilde;o do NetBeans deve incluir o plug-in do C/C++.</p>
<p class="tips">Embora o plug-in seja denominado C/C++, tamb&eacute;m inclui o suporte para programa&ccedil;&atilde;o em Fortran.</p>

<h3>Se ainda n&atilde;o tiver o NetBeans IDE 6.9 instalado</h3>
<p>Se ainda n&atilde;o tiver o NetBeans IDE instalado, fa&ccedil;a o download do pacote <b>C/C++</b> ou do pacote <b>All</b> na <a href="http://download.netbeans.org/">p&aacute;gina de download do NetBeans IDE 6.9</a>. Se n&atilde;o for usar outras linguagens como Java e Ruby, voc&ecirc; deveria fazer o download do pacote C/C++.</p>

<h3>Se voc&ecirc; tem o NetBeans IDE 6.9, mas n&atilde;o sabe se tem o plug-in do C/C++</h3>
<p>Se j&aacute; tiver o NetBeans IDE, certifique-se de que seu NetBeans IDE inclui o plug-in do C/C++ selecionando Arquivo &gt; Novo projeto. Se o C/C++ estiver listado como uma das Categorias, voc&ecirc; tem o m&oacute;dulo de plug-in do C/C++. Voc&ecirc; deve ir para a se&ccedil;&atilde;o <a href="#compilers">Instalando e configurando compiladores e ferramentas</a>.
</p>

<h3>Se tem o NetBeans IDE 6.9 sem o plug-in do C/C++</h3>
<p>Se o seu NetBeans IDE n&atilde;o mostrar a categoria de projeto C/C++ ao selecionar Arquivo &gt; Novo projeto, complete as etapas a seguir para adicionar o m&oacute;dulo de plug-in do C/C++ ao IDE.</p>
<ol>
    <li>Se sua rede usa um proxy, selecione Ferramentas &gt; Geral no IDE, selecione Configura&ccedil;&otilde;es manuais do proxy, digite o Proxy HTTP e a porta do proxy e clique em OK.</li>
    <li>Escolha Ferramentas &gt; Plug-ins.</li>

    <li>Na caixa de di&aacute;logo Plug-ins, clique na guia Plug-ins dispon&iacute;veis e v&aacute; at&eacute; a categoria C/C++.
    </li>
    <li>Selecione a caixa de sele&ccedil;&atilde;o C/C++ e clique em Instalar para iniciar o Instalador do NetBeans IDE.</li>
    <li>No NetBeans IDE Installer, clique em Avan&ccedil;ar.</li>
    <li>Leia o contrato de licen&ccedil;a, selecione a caixa de sele&ccedil;&atilde;o para aceitar os termos do contrato e clique em Pr&oacute;ximo.</li>
    <li>Clique em Instalar.</li>
    <li>Ap&oacute;s a conclus&atilde;o da instala&ccedil;&atilde;o, selecione Reiniciar o IDE agora ou Reiniciar o IDE mais tarde e clique em Concluir.</li>
</ol>

 
       
        
<!-- COMPILER SETUP ------------------------------------------------------->
<h2><a name="compilers">Instalando e configurando compiladores e ferramentas</a></h2>
<p>O m&oacute;dulo NetBeans C/C++ requer um compilador C, um compilador C++, um utilit&aacute;rio <tt>make</tt> e um depurador <tt>gdb. </tt> Consulte as instru&ccedil;&otilde;es seguintes da plataforma do seu sistema de desenvolvimento.
</p>
<table class="b-none" cellpadding="0" cellspacing="0" class="vatop">
<tr>
      <td>-&nbsp;</td>
      <td><a href="#compilers_windows" title="Plataforma Windows">Windows</a></td>
   </tr>
   <tr>
      <td>-&nbsp;</td>
      <td><a href="#compilers_solaris" title="Plataforma Solaris">Solaris OS</a></td>
   </tr>
   <tr>
      <td>-&nbsp;</td>
      <td><a href="#compilers_opensolaris" title="Plataforma OpenSolaris">OpenSolaris OS</a></td>
   </tr>
   <tr>
      <td>-&nbsp;</td>
      <td><a href="#compilers_linux" title="Plataforma Linux">Linux</a>
      </td>
   </tr>
    <tr>
      <td>-&nbsp;</td>
      <td><a href="#compilers_mac" title="Macintosh OS X">Macintosh OS X</a>
      </td>
   </tr>
   
</table>



<!-- COMPILER SETUP: WINDOWS ---------------------------------------------->
<!--<blockquote>-->
<h3><a name="compilers_windows"></a>Windows</h3>
<p>O m&oacute;dulo NetBeans C/C++ foi testado com os compiladores Cygwin e MinGW. Se voc&ecirc; instala o Cygwin e o MinGW, tenha cuidado ao manter suas localiza&ccedil;&otilde;es de instala&ccedil;&atilde;o separadas e n&atilde;o misture as ferramentas do Cygwin e do MinGW em uma cole&ccedil;&atilde;o de ferramentas no IDE.</p>
<p class="notes">Se voc&ecirc; deseja utilizar o Qt com o Windows, &eacute; preciso utilizar o MinGW, que est&aacute; inclu&iacute;do com o Qt SDK. Voc&ecirc; n&atilde;o deve instalar o MinGW separadamente.</p>

<table>
<tr>
      <td >-&nbsp;</td>
      <td><a href="#cygwin" title="Ferramentas e compiladores Cygwin">Ferramentas e compiladores Cygwin</a></td>
   </tr>
   <tr>
      <td>-&nbsp;</td>
      <td><a href="#mingw" title="Ferramentas e compiladores MinGW">Ferramentas e compiladores MinGW</a></td>
   </tr>
</table>

<h4><a name="cygwin"></a>Ferramentas e compiladores Cygwin</h4>

<p>O m&oacute;dulo NetBeans C/C++ foi testado com os seguintes compiladores e ferramentas do <a href="http://cygwin.com" target="_blank">Cygwin.com</a></p>

<table>
  <tbody>

           <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o testada</th>
                <th class="tblheader" scope="col">Descri&ccedil;&atilde;o</th>
            </tr>
            <tr>
                <td class="tbltd1"><tt>cygwin1.dll</tt></td>
                <td class="tbltd1">1.7.2</td>
                <td class="tbltd1">Ambiente Cygwin semelhante a Linux para Windows</td>

            </tr>
        
        <tr>
            <td class="tbltd1"><tt>gcc</tt></td>
            <td class="tbltd1">3.4.4</td>
            <td class="tbltd1">Compilador C Cygwin</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>g++</tt></td>
            <td class="tbltd1">3.4.4</td>
            <td class="tbltd1">Compilador C++ Cygwin</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gdb</tt></td>
            <td class="tbltd1">6.8</td>
            <td class="tbltd1">Depurador GNU Cygwin</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>make</tt></td>
            <td class="tbltd1">3.81</td>
            <td class="tbltd1">Utilit&aacute;rio make Cygwin</td>

        </tr>
    </tbody>
</table>
<br>
<p>Se voc&ecirc; j&aacute; tiver os compiladores gcc e g++ Cygwin, o GNU <tt>make</tt> e o depurador <tt>gdb</tt> instalados no sistema Windows e o caminho estiver configurado corretamente para encontr&aacute;-los, certifique-se de que voc&ecirc; tenha as vers&otilde;es corretas.
</p>

<p><b>Para verificar as vers&otilde;es dos compiladores e das ferramentas Cygwin:</b>
<ol>
<li>
<p>Verifique a vers&atilde;o do ambiente Cygwin digitando os seguintes comandos em um prompt de comando do Windows:
<pre class="examplecode">
 C:\&gt; cygcheck -c cygwin
</pre>
</li>
<li>Verifique as vers&otilde;es dos compiladores gcc e g++ Cygwin, <tt>make</tt>, e <tt>gdb</tt> digitando os seguintes comandos em um prompt de comando do Windows:
<pre class="examplecode">
C:\&gt; gcc --version
C:\&gt; g++ --version
C:\&gt; make --version
C:\&gt; gdb --version
</pre>
</li>
</ol>
<p>
 Se voc&ecirc; tiver as vers&otilde;es corretas, n&atilde;o ser&atilde;o necess&aacute;rias configura&ccedil;&otilde;es adicionais. Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas est&atilde;o instaladas corretamente no NetBeans IDE.</p>

<p><b>Para instalar os compiladores gcc e g++, <tt>make</tt> e o depurador <tt>gdb</tt> de <a href="http://cygwin.com" target="blank">cygwin.com</a>:</b></p>
<ol>
    <li>Consulte o <a href="http://http://cygwin.com/cygwin-ug-net/index.html" target="_blank">Guia do Usu&aacute;rio do Cygwin</a> para obter informa&ccedil;&otilde;es completas sobre como instalar e utilizar o Cygwin.</li>
<li>Baixe o programa <tt>setup.exe</tt> do Cygwin ao clicar no &iacute;cone Instalar agora o Cygwin Now na parte superior direita da p&aacute;gina, ou ao clicar neste link <a href="http://www.cygwin.com/setup.exe"> <tt>setup.exe</tt></a> direto.
	</li>

	 <li>
	Execute o programa <tt>setup.exe. </tt> Aceite os padr&otilde;es at&eacute; chegar na p&aacute;gina Selecionar conex&atilde;o de Internet. Nessa p&aacute;gina, selecione a op&ccedil;&atilde;o que melhor se aplica a seu caso. Clique em Pr&oacute;ximo.
   </li>
    <li>
	Na p&aacute;gina Selecionar local de download, escolha um local de download que esteja relativamente pr&oacute;ximo a voc&ecirc;. Clique em Avan&ccedil;ar.
    </li>
    <li>
	Na p&aacute;gina Selecionar pacotes, selecione os pacotes para download. Clique no sinal + pr&oacute;ximo a Devel para expandir a categoria de ferramentas de desenvolvimento. Redimensione a janela a fim de poder visualizar mais de uma janela ao mesmo tempo.
    </li>
    <li>
	Selecione o pacote que deseja baixar clicando no r&oacute;tulo Ignorar ao lado deste, que revela o n&uacute;mero da vers&atilde;o do pacote para download. No m&iacute;nimo, selecione
        <ul><li>gcc-core: C compiler
            </li>
            <li>gcc-g++: C++ compiler
            </li>
            <li>gdb: O depurado do GNU
            </li>
            <li>make: a vers&atilde;o do GNU do utilit&aacute;rio 'make'
            </li>
        </ul>
	Os pacotes requeridos pelos pacotes que voc&ecirc; selecionar tamb&eacute;m s&atilde;o automaticamente selecionados.
	</li>
    <li>Clique em Pr&oacute;ximo para se conectar ao site de download e fazer o download dos pacotes que selecionou. Clique em Terminar quando a instala&ccedil;&atilde;o estiver conclu&iacute;da.</li>
    <li>
        Agora, adicione o diret&oacute;rio do compilador Cygwin ao caminho para permitir que o NetBeans IDE encontre o conjunto de ferramentas:
       <br><br>
        <ol type="a">
        <li>abra o painel de controle:<br>
            - No Windows XP selecione Iniciar &gt; Configura&ccedil;&otilde;es &gt; Painel de controle) e clique duas vezes em Sistema. <br>
            - No Windows 7, digite <b>var</b> na caixa de pesquisa do menu Iniciar para encontrar rapidamente um linl para Editar as vari&aacute;veis de ambiente do sistema.</li>
        <li>Selecione a guia Avan&ccedil;ado e clique em Vari&aacute;veis do ambiente.</li>
        <li>No painel Vari&aacute;veis do sistema da caixa de di&aacute;logo Vari&aacute;veis do ambiente, selecione a vari&aacute;vel <tt>Path</tt> e clique em Editar.</li>
        <li>Adicione o caminho para o diret&oacute;rio <tt><i>cygwin-directory</i>\bin</tt> &agrave; vari&aacute;vel <tt>Path</tt> e clique em OK. Por padr&atilde;o, <tt><i>cygwin-directory</i></tt> &eacute; <tt>C:\cygwin</tt>. Os nomes do diret&oacute;rio devem ser separados por ponto-e-v&iacute;rgula. O caminho editado deve ser semelhante a <tt>%SystemRoot%\system32;%SystemRoot%;C:\Program Files\QuickTime\QTSystem;C:\cygwin\bin</tt></li>
        <li>Clique em OK na caixa de di&aacute;logo Vari&aacute;veis do ambiente e na caixa de di&aacute;logo Propriedades do sistema.
        </li>
        <li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>
        </ol>
	
    </li>
    </ol>

    <!-- MinGW installation -->

        <h4><a name="mingw"></a>Ferramentas e compiladores MinGW</h4>
        <p>O NetBeans IDE 6.9 foi testado com o Minimalist GNU para Windows (MinGW) e com o ambiente Minimal System (MSYS) semelhante a Unix. As vers&otilde;es testadas e as instru&ccedil;&otilde;es de instala&ccedil;&atilde;o s&atilde;o exibidas abaixo.</p>

        <p class="notes margin-around">Se voc&ecirc; deseja utilizar o Qt com o Windows, &eacute; preciso utilizar a vers&atilde;o do MinGW
            <br>que est&aacute; inclu&iacute;da no QtSDK em vez de instalar o MinGW separadamente.</p>
 
        <table>
  <tbody>

           <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o testada</th>
                <th class="tblheader" scope="col">Descri&ccedil;&atilde;o</th>
            </tr>


        <tr>
            <td class="tbltd1"><tt>gcc</tt></td>
            <td class="tbltd1">3.4.5</td>
            <td class="tbltd1">Compilador C MinGW</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>g++</tt></td>
            <td class="tbltd1">3.4.5</td>
            <td class="tbltd1">Compilador C++ MinGW</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gdb</tt></td>
            <td class="tbltd1">6.8</td>
            <td class="tbltd1">Depurador GNU MinGW</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>make</tt></td>
            <td class="tbltd1">3.79.1</td>
            <td class="tbltd1">Utilit&aacute;rio <tt>make</tt> MSYS<br>
                Observe que o make MinGW n&atilde;o &eacute; suportado</td>

        </tr>
    </tbody>
</table>
<br>
<p><b>Para instalar os compiladores GNU, <tt>make</tt> e o depurador <tt>gdb</tt> de <a href="http://mingw.org" target="_blank">mingw.com</a>:</b></p>
<ol>
    <li>Efetue o logon no Windows utilizando uma conta com privil&eacute;gios de &quot;administrador do computador&quot;.
    </li>
    <li>Fa&ccedil;a o download do arquivo de instala&ccedil;&atilde;o autoextra&iacute;vel de <a href="http://mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_Suite" target="_blank">Como instalar o MinGW (GCC) Compiler Suite</a> em mingw.org ou por conveni&ecirc;ncia voc&ecirc; pode fazer o download <a href="http://sourceforge.net/project/downloading.php?group_id=2435&filename=MinGW-5.1.4.exe&a=57946486">direto do link MinGW-5.1.4.exe</a>.
        </li>
        <li>Execute o instalador MinGW-5.1.4.exe em Windows.</li>
        <li>No instalador MinGW, aceite os padr&otilde;es at&eacute; chegar na p&aacute;gina Selecionar componentes.</li>
        <li>Na p&aacute;gina Selecionar componentes, selecione o compilador g++. O compilador gcc est&aacute; automaticamente inclu&iacute;do na instala&ccedil;&atilde;o, portanto n&atilde;o &eacute; um componente selecion&aacute;vel.
        <li>N&atilde;o selecione o make MinGW, dado que &eacute; necess&aacute;rio o make do MSYS, que pode ser baixado separadamente. Clique em Avan&ccedil;ar.</li>
        <li>Utilize o <tt>C:\MinGW</tt> padr&atilde;o como pasta de destino, se poss&iacute;vel, para diminuir qualquer potencial dificuldade no uso de compiladores provenientes de outro local.</li>
        <li>Clique em Instalar para instalar as ferramentas MinGW e, em seguida, clique em Pr&oacute;ximo e em Terminar.</li>
        <li>Adicione o diret&oacute;rio <tt>C:\MinGW\bin</tt> ao caminho, conforme descrito em <a href="http://www.mingw.org/wiki/HOWTO_Install_the_MinGW_GCC_Compiler_suite#toc7" target="_blank">Configura&ccedil;&otilde;es do ambiente</a> no wiki do MinGW.</li>
        <li>Consulte as instru&ccedil;&otilde;es de instala&ccedil;&atilde;o do MSYS no <a href="http://www.mingw.org/wiki/MSYS" target="_blank">wiki do MinGW MSYS</a>. &Eacute; necess&aacute;rio instalar apenas os arquivos MSYS 1.0. &Eacute; necess&aacute;rio instalar o DTK ou os arquivos principais mencionados na p&aacute;gina wiki.</li>
<li>Para sua conveni&ecirc;ncia, &eacute; poss&iacute;vel fazer o download <a href="http://downloads.sourceforge.net/mingw/MSYS-1.0.10.exe">direto do link MSYS-1.0.10.exe</a> </li>
<li>Certifique-se de estar utilizando uma conta do Windows com privil&eacute;gios de &quot;administrador do computador&quot; ao instalar o MSYS. Caso o MSYS tenha sido instalado com uma conta de usu&aacute;rio limitado, o NetBeans IDE pode apresentar problemas se voc&ecirc; tentar compilar ou executar projetos mais tarde.</li>
<li>Execute o instalador do MSYS-1.0.10.exe e aceite os padr&otilde;es.</li>
<li>Para instalar o depurador gdb, fa&ccedil;a o download <a href="http://sourceforge.net/project/downloading.php?group_id=2435&filename=gdb-6.8-mingw-3.tar.bz2&a=66334146">direto do link gdb-6.8-mingw-3.tar.bz2</a>. &Eacute; necess&aacute;rio um utilit&aacute;rio zip do Windows como gzip, 7-zip ou WinZip para extrair o arquivo gdb.</li>

    <li>Descompacte o gdb-6.8-mingw-3.tar.bz2 no diret&oacute;rio <tt>C:\MinGW</tt> de forma que o gdb execut&aacute;vel seja instalado no diret&oacute;rio <tt>C:\MinGW\bin</tt>.</li>
<li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>

    </ol>

<br>

<!-- COMPILER SETUP: SOLARIS OS -------------------------------->
<h3><a name="compilers_solaris"></a>Solaris OS</h3>
<p>
    No sistema operacional Solaris, &eacute; poss&iacute;vel utilizar as ferramentas do GNU ou as ferramentas do Sun Studio. Como padr&atilde;o, as ferramentas do GNU est&atilde;o inclu&iacute;das no sistema operacional Solaris 10 no diret&oacute;rio /usr/sfw/bin. O software Sun Studio &eacute; um conjunto de ferramentas para desenvolvedores que podem ser baixadas gratuitamente. Os compiladores do Sun Studio est&atilde;o otimizados para o hardware Sun e facilitam a cria&ccedil;&atilde;o de bin&aacute;rios Solaris ajustados ao desempenho.</p>
    <p style="tips">Se estiver utilizando o OpenSolaris, consulte <a href="#compilers_opensolaris">OpenSolaris OS</a>.
   </p>
    <p>
O NetBeans IDE 6.9 foi testado com os seguintes compiladores e ferramentas.</p>

<table>
  <tbody>

           <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o testada</th>
                <th class="tblheader" scope="col">Descri&ccedil;&atilde;o</th>
            </tr>
            <tr>
                <td class="tbltd1"><tt>cc</tt></td>
                <td class="tbltd1">5.9 e 5.10</td>
                <td class="tbltd1">Compilador do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

            </tr>
            <tr>
                <td class="tbltd1"><tt>CC</tt></td>
                <td class="tbltd1">5.9 e 5.10</td>
                <td class="tbltd1">Compilador C++ do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

            </tr>

        <tr>
            <td class="tbltd1"><tt>gcc</tt></td>
            <td class="tbltd1">3.4.3</td>
            <td class="tbltd1">Compilador C GNU</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>g++</tt></td>
            <td class="tbltd1">3.4.3</td>
            <td class="tbltd1">Compilador C++ GNU</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gdb</tt></td>
            <td class="tbltd1">6.6 e 6.8</td>
            <td class="tbltd1">Depurador GNU</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gmake</tt></td>
            <td class="tbltd1">3.81</td>
            <td class="tbltd1">GNU make</td>

        </tr>
         <tr>
            <td class="tbltd1"><tt>make</tt></td>
            <td class="tbltd1">3.81</td>
            <td class="tbltd1">make Solaris</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>dmake</tt></td>
            <td class="tbltd1">7.8 e 7.9</td>
            <td class="tbltd1">Utilit&aacute;rio make distribu&iacute;do do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

        </tr>
    </tbody>
</table>
<h4>Compiladores do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</h4>
<p>Se desejar utilizar os compiladores do Sun Studio 12 Atualiza&ccedil;&atilde;o 1 no sistema operacional Solaris 10:</p>
<ul>
<li>se voc&ecirc; tem o software Sun Studio 12 Atualiza&ccedil;&atilde;o 1 instalado, certifique-se de que o <tt>/<i>diret&oacute;rio de instala&ccedil;&atilde;o</i>/SUNWspro/bin</tt> esteja no caminho antes de iniciar o NetBeans IDE. O local padr&atilde;o no sistema operacional Solaris 10 &eacute; <tt>/opt/SUNWspro/bin</tt></li>
<li>
Se n&atilde;o tiver o software Sun Studio 12 Atualiza&ccedil;&atilde;o 1 instalado, voc&ecirc; pode baix&aacute;-lo gratuitamente em <a href="http://www.oracle.com/technetwork/server-storage/solarisstudio/downloads/studio12-update1-136165.html" target="_blank"><tt>http://www.oracle.com/technetwork/server-storage/solarisstudio/downloads/studio12-update1-136165.html</tt></a>.
</li>
</ul>
</p>

<p><b>Para baixar e instalar os compiladores do Sun Studio 12 Atualiza&ccedil;&atilde;o 1:</b></p>
<ol>

<li>Crie um diret&oacute;rio para o arquivo baixado. Voc&ecirc; deve ter permiss&atilde;o de grava&ccedil;&atilde;o para este diret&oacute;rio.</li>
<li>
Baixe o arquivo para sua plataforma no diret&oacute;rio de download.
</li>
<li>V&aacute; ao diret&oacute;rio de download e descompacte o arquivo descarregado.
<pre>
bzcat <i>filename</i> | tar xvf -
</pre>
</li>
<!-- 
<li>
Become superuser (root). Run the installer in the download directory by typing:
<pre>
./installer
</pre>
</li>
<br>
<li>Click Next on the Welcome page, and accept the Software License Agreement
and click Next.
</li>
<li>On the Select Components page of the installer, select Custom Install for
Sun Studio Software. Select Default Install for Solaris Patches. Select No Install for
Documentation, Source Distribution, and Sun Performance Library.
</li>
<li>On the Select Install Directory page, if you want to install the compilers
in the default installation directory <tt>/opt</tt>, click Next. If you want to
install the compilers in a different directory, type the path in the text field
and click Next.</li>
<li>On the Select Subcomponents page, select Compilers C and
Compilers C++, and click Next.
</li>
<li>On the Ready to Install page, verify that the disk space shown is available
on your system, and that the C compiler, C++ compiler, and Solaris patches are
listed. Then click Install Now.
</li>
<li>When installation is complete, proceed through the Installation Summary
page, the Registration page, and the After Installation page, and click Exit to
exit the installer.
</li>
-->
<li>Siga as instru&ccedil;&otilde;es no <a
href="http://www.oracle.com/technetwork/indexes/documentation/index.html" target="_blank">cap&iacute;tulo 2 do Guia <i>de Instala&ccedil;&atilde;o do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</i></a> para instalar os compiladores C, C++ e os patches Solaris necess&aacute;rios.</li>
<li>Edite seu <tt>PATH</tt> para adicionar o caminho ao software Sun Studio Atualiza&ccedil;&atilde;o 1 antes de iniciar o NetBeans IDE.</li>
<li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>
</ol>


<h4>Compiladores GNU e GNU <tt>make</tt></h4>
<p>
Se desejar utilizar os compiladores GNU e GNU <tt>make</tt>:
<ul>
<li>Se voc&ecirc; tem uma instala&ccedil;&atilde;o padr&atilde;o do Solaris 10 OS, os compiladores e o <tt>gmake</tt> est&atilde;o instalados em <tt>/usr/sfw/bin</tt>. Certifique-se de que este local esteja no <tt>PATH</tt> antes de iniciar o IDE NetBeans.</li>
<li>Se os compiladores e o <tt>gmake</tt> n&atilde;o estiverem instalados em seu sistema, &eacute; poss&iacute;vel baix&aacute;-los em <a
href="http://www.sunfreeware.com" target="_blank"><tt>http://www.sunfreeware.com</tt></a>.</li>
</ul> 

<p><b>Para fazer o download e instalar os compiladores GNU e o utilit&aacute;rio make</b></p>
<ol>
<li>Fa&ccedil;a o download de <tt>gcc</tt> e <tt>make</tt>.</li>
<li>Se os arquivos zip de download n&atilde;o forem extra&iacute;dos automaticamente durante o download, descompacte-os com o <tt>gunzip</tt>.
</li>
<li>Instale os pacotes com o comando <tt>pkgadd</tt>.</li>
<li>Certifique-se de incluir os diret&oacute;rios do compilador GNU e GNU make no caminho antes de iniciar o IDE NetBeans.
</li>
 <li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>
</ol>


<h4><tt>gdb</tt> Depurador</h4>
<p>Tanto com o uso dos compiladores <tt>make</tt> Sun Studio e Solaris quanto dos compiladores GNU e <tt>make</tt> GNU, o depurador <tt>gbd</tt> &eacute; necess&aacute;rio para depurar os aplicativos no NetBeans IDE. &Eacute; poss&iacute;vel fazer o download do <tt>gdb</tt> em <a href="http://www.sunfreeware.com" target="_blank">http://www.sunfreeware.com</a>.

<p><b>Para fazer o download e instalar o <tt>gdb</tt>:</b></p>
<ol>
<li>Fa&ccedil;a o download do <tt>gdb</tt> 6.6 ou 6.8.</li>
<li>Se o arquivo zip de download n&atilde;o for extra&iacute;do automaticamente durante o download, descompacte-o com o <tt>gunzip</tt>.
</li>
<li>Instale o pacote com o comando <tt>pkgadd</tt>.</li>
<li>Certifique-se de incluir o caminho para <tt>gdb</tt> no <tt>PATH</tt> antes de iniciar o IDE NetBeans.</li>
<li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>
</ol>
          
<br>

<!-- COMPILER SETUP: OPENSOLARIS OS ----------------------->
<h3><a name="compilers_opensolaris"></a>OpenSolaris OS</h3>

<p>
    No sistema operacional OpenSolaris, &eacute; poss&iacute;vel usar as ferramentas do GNU ou as ferramentas do Sun Studio. Ambos os conjuntos de ferramentas pode ser facilmente baixados com o comando pkg ou o utilit&aacute;rio Gerenciador de pacotes da &aacute;rea de trabalho do OpenSolaris.</p>
    <p>
O NetBeans IDE 6.9 foi testado com os seguintes compiladores e ferramentas.</p>

<table>
  <tbody>

           <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o testada</th>
                <th class="tblheader" scope="col">Descri&ccedil;&atilde;o</th>
            </tr>
            <tr>
                <td class="tbltd1"><tt>cc</tt></td>
                <td class="tbltd1">5.9 e 5.10</td>
                <td class="tbltd1">Compilador do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

            </tr>
            <tr>
                <td class="tbltd1"><tt>CC</tt></td>
                <td class="tbltd1">5.9 e 5.10</td>
                <td class="tbltd1">Compilador C++ do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

            </tr>

        <tr>
            <td class="tbltd1"><tt>gcc</tt></td>
            <td class="tbltd1">3.4.3</td>
            <td class="tbltd1">Compilador C GNU
            <br>Consulte as <a href="https://netbeans.org/community/releases/69/relnotes_pt_BR.html#known_issues-cnd">notas da vers&atilde;o do NetBeans IDE 6.9</a> para obter informa&ccedil;&otilde;es sobre o NetBeans e o gcc no sistema operacional OpenSolaris.</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>g++</tt></td>
            <td class="tbltd1">3.4.3</td>
            <td class="tbltd1">Compilador C++ GNU. <br>Consulte as <a href="https://netbeans.org/community/releases/69/relnotes_pt_BR.html#known_issues-cnd">notas da vers&atilde;o do NetBeans IDE 6.9</a> para obter informa&ccedil;&otilde;es sobre o NetBeans e o gcc no sistema operacional OpenSolaris.</td>
</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gdb</tt></td>
            <td class="tbltd1">6.6</td>
            <td class="tbltd1">Depurador GNU (observe que o gdb 6.3 est&aacute; no reposit&oacute;rio do OpenSolaris<br>
                e n&atilde;o &eacute; suportado pelo NetBeans IDE 6.9). <br>O gdb 6.6 foi compilado no OpenSolaris para teste. <br>Consulte as <a href="https://netbeans.org/community/releases/69/relnotes_pt_BR.html#known_issues-cnd">notas da vers&atilde;o do NetBeans IDE 6.9</a> para obter informa&ccedil;&otilde;es sobre o NetBeans e o gdb no sistema operacional OpenSolaris.</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gmake</tt></td>
            <td class="tbltd1">3.81</td>
            <td class="tbltd1">GNU make</td>

        </tr>
         <tr>
            <td class="tbltd1"><tt>make</tt></td>
            <td class="tbltd1">-</td>
            <td class="tbltd1">make Solaris</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>dmake</tt></td>
            <td class="tbltd1">7.8 e 7.9</td>
            <td class="tbltd1">Utilit&aacute;rio make distribu&iacute;do do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

        </tr>
    </tbody>
</table>
<br><br>
<p><b>Para baixar e instalar o software Sun Studio 12 e o depurador gdb:</b></p>
<ol><li>Digite o seguinte em uma janela de terminal do OpenSolaris:
<pre>$ pfexec pkg install sunstudio12u1 gdb</pre>
<li>Edite seu <tt>PATH</tt> para incluir o caminho aos compiladores Sun Studio 12 Atualiza&ccedil;&atilde;o 1 antes de iniciar o NetBeans IDE. O caminho &eacute; <tt>/opt/sunstudio12u1/bin</tt>.</li>
</ol>

<p><b>Para fazer o download e instalar os compiladores gcc GNU e o depurador gbd</b></p>
<ol><li>Digite o seguinte comando em uma janela de terminal do OpenSolaris:<br>
<pre>$ pfexec pkg install SUNWgcc SUNWgccruntime gdb</pre>

</li>

<li>Os links para os compiladores est&atilde;o instalados em /usr/bin, que provavelmente j&aacute; est&aacute; em seu caminho. Se /usr/bin n&atilde;o estiver no seu caminho, edite o <tt>PATH</tt> para adicion&aacute;-lo antes de iniciar NetBeans IDE.  </li>
 <li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>
</ol>


<!--<p>Consulte a p&aacute;gina wiki do OpenSolaris<a href="http://wikis.sun.com/pages/viewpage.action?pageId=108496910" target="_blank"> Instalando as ferramentas de desenvolvimento Fortran e C++</a> para obter mais informa&ccedil;&otilde;es.
</p>-->


<!-- COMPILER SETUP: LINUX OS -------------------------------->
<h3><a name="compilers_linux"></a>Linux</h3>
<p>
    Nas plataformas Linux, &eacute; poss&iacute;vel usar as ferramentas do GNU ou as ferramentas do Sun Studio.
<p>
O NetBeans IDE foi testado com os seguintes compiladores e ferramentas:</p>


<table>
  <tbody>

           <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o testada</th>
                <th class="tblheader" scope="col">Descri&ccedil;&atilde;o</th>
            </tr>
            <tr>
                <td class="tbltd1"><tt>cc</tt></td>
                <td class="tbltd1">5.9 e 5.10</td>
                <td class="tbltd1">Compilador do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

            </tr>
            <tr>
                <td class="tbltd1"><tt>CC</tt></td>
                <td class="tbltd1">5.9 e 5.10</td>
                <td class="tbltd1">Compilador C++ do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</td>

            </tr>

        <tr>
            <td class="tbltd1"><tt>gcc</tt></td>
            <td class="tbltd1">4.1.2, 4.2.3 e 4.3.3</td>
            <td class="tbltd1">Compilador C GNU em Red Hat 5 e Ubuntu 8.04</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>g++</tt></td>
            <td class="tbltd1">4.1.2, 4.2.3 e 4.3.3</td>
            <td class="tbltd1">Compiladores C++ GNU em Red Hat 5 e Ubuntu 8.04</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gdb</tt></td>
            <td class="tbltd1">6.6 e 6.8</td>
            <td class="tbltd1">Depurador GNU em Red Hat 5 e Ubuntu 8.04</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gmake</tt></td>
            <td class="tbltd1">3.81</td>
            <td class="tbltd1">GNU make em Red Hat 5 e Ubuntu 8.04</td>

        </tr>
       
    </tbody>
</table>
<br><br>
    
    <h4>Compiladores do Sun Studio 12 Atualiza&ccedil;&atilde;o 1 no Linux</h4>
<p>Se voc&ecirc; desejar utilizar os compiladores do Sun Studio 12 Atualiza&ccedil;&atilde;o 1 no sistema operacional Linux:</p>
<ul>
<li>Se voc&ecirc; tem o software Sun Studio 12 Atualiza&ccedil;&atilde;o 1 instalado, certifique-se de que o <tt>/<i>diret&oacute;rio de instala&ccedil;&atilde;o</i>/sunstudio12u1/bin</tt> esteja no caminho antes de iniciar o NetBeans IDE. O local padr&atilde;o &eacute; <tt>/opt/sun/sunstudio12u1/bin</tt> ao instalar com pacotes Linux.</li>
<li>
Se n&atilde;o tiver o software Sun Studio 12 Atualiza&ccedil;&atilde;o 1 instalado, voc&ecirc; pode baix&aacute;-lo em developers.sun.com conforme descrito abaixo.
</li>
</ul>

<p><b>Para baixar e instalar os compiladores do Sun Studio 12 Atualiza&ccedil;&atilde;o 1:</b></p>
<ol>

<li>Crie um diret&oacute;rio no qual voc&ecirc; possa fazer o download e descompacte o arquivo de armazenamento compactado do Sun Studio. Voc&ecirc; deve ter permiss&atilde;o de grava&ccedil;&atilde;o para este diret&oacute;rio.
<li>Se o seu navegador estiver configurado para fazer a instala&ccedil;&atilde;o em um local espec&iacute;fico como na &aacute;rea de trabalho ou em um diret&oacute;rio de downloads sem solicitar permiss&atilde;o, configure as prefer&ecirc;ncias do navegador para que o download seja feito no diret&oacute;rio que voc&ecirc; criou. No Firefox, o diret&oacute;rio de download &eacute; configurado em Editar &gt; Prefer&ecirc;ncias &gt; Principal.</li>

<li>V&aacute; a <a href="http://developers.sun.com/sunstudio/downloads/" target="_blank"> <tt>http://developers.sun.com/sunstudio/downloads/</tt></a> e fa&ccedil;a o download do arquivo para a sua plataforma no diret&oacute;rio de download que voc&ecirc; criou. Se estiver utilizando o Ubuntu, escolha a instala&ccedil;&atilde;o do arquivo tar porque os pacotes s&atilde;o para SUSE e Red Hat. Observe tamb&eacute;m que o Ubuntu n&atilde;o &eacute; uma plataforma oficialmente suportada para o Sun Studio IDE, mas os compiladores foram testados para serem utilizados no NetBeans IDE e n&atilde;o apresentaram problemas.
</li>
<li>Depois que o download for conclu&iacute;do, abra um terminal, v&aacute; ao diret&oacute;rio de download, descompacte e extraia o arquivo baixado.
<pre>
bzcat <i>filename</i> | tar xvf -
</pre>
</li>
<li>
Se voc&ecirc; tiver baixado os pacotes SUSE ou RPM, siga as instru&ccedil;&otilde;es no <a
href="http://docs.sun.com/app/docs/doc/820-7601/6nirmq79" target="_blank">cap&iacute;tulo 2 do <i>Guia de Instala&ccedil;&atilde;o R&aacute;pida do Sun Studio 12 Atualiza&ccedil;&atilde;o 1</i></a> para realizar a instala&ccedil;&atilde;o.</li>


<li>Edite seu <tt>PATH</tt> a fim de adicionar o caminho ao software Sun Studio antes de iniciar o NetBeans IDE.</li>
 <li>Consulte <a href="#verifying">Verificando a instala&ccedil;&atilde;o</a> para comprovar se as ferramentas foram instaladas corretamente no NetBeans IDE.</li>
</ol>
<p><b>Para fazer o download e instalar o depurador GNU no Red Hat 5, digite:</b></p>
<pre>yum install gdb</pre>

<p><b>Para fazer o download e instalar o depurador GNU em Ubuntu, digite:</b></p>
<pre>apt-get install gdb</pre>


<!-- COMPILER SETUP: MAC OS X ---------------------------------->
<h3><a name="compilers_mac"></a>Macintosh OS X</h3>

<p>
O NetBeans IDE foi testado com os seguintes compiladores e ferramentas: 

<table>
  <tbody>

           <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o testada</th>
                <th class="tblheader" scope="col">Descri&ccedil;&atilde;o</th>
            </tr>


        <tr>
            <td class="tbltd1"><tt>gcc</tt></td>
            <td class="tbltd1">4.0.1</td>
            <td class="tbltd1">Compilador C GNU em Mac OS X 10.5</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>g++</tt></td>
            <td class="tbltd1">4.0.1</td>
            <td class="tbltd1">Compilador C ++ GNU em Mac OS X 10.5</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>gdb</tt></td>
            <td class="tbltd1">6.3.5</td>
            <td class="tbltd1">Depurador GNU em Mac OS X 10.5</td>

        </tr>
        <tr>
            <td class="tbltd1"><tt>make</tt></td>
            <td class="tbltd1">3.81</td>
            <td class="tbltd1">GNU make em Mac OS X 10.5</td>

        </tr>

    </tbody>
</table>

<br>
<p>Instale os pacotes a seguir fornecidos com o Macintosh OS X:
<ul>
<li>Xcode</li>
<li>X11</li>
</ul>
<p>Estes pacotes podem ser baixados no canal <a href="http://developer.apple.com/mac" target="_blank">Apple Developer Connection</a> atrav&eacute;s da ades&atilde;o gratuita ao ADC.</p>


<br><!-- VERIFYING THE INSTALLATION ------------------------------------------>
<h2><a name="verifying">Verificando a instala&ccedil;&atilde;o</a></h2>
<p>Para verificar se a instala&ccedil;&atilde;o est&aacute; correta, inicie o IDE NetBeans, crie um projeto de amostra e execute-o no depurador <tt>gdb</tt>.</p>


<h3><a name="start">Inicie o NetBeans IDE</a></h3>
<p><b>Para iniciar o IDE, adote um dos seguintes procedimentos:</b></p>
<ul>
<li>Abra o &iacute;cone do NetBeans IDE na &aacute;rea de trabalho.</li>
<li>Nas plataformas Linux ou Solaris, v&aacute; ao subdiret&oacute;rio <tt>bin</tt> da instala&ccedil;&atilde;o do NetBeans e digite <tt>./netbeans</tt>.
<li>Inicie o NetBeans IDE atrav&eacute;s do menu da &aacute;rea de trabalho, como faria com outras aplica&ccedil;&otilde;es.
<br>Este m&eacute;todo est&aacute; dispon&iacute;vel nas plataformas Windows e OpenSolaris, mas talvez n&atilde;o esteja dispon&iacute;vel no Solaris 10 e em algumas plataformas Linux.</li>
</ul>

<h3><a name="test"></a>Crie um projeto de amostra para testar as ferramentas</h3>
<p>Em todas as plataformas, &eacute; poss&iacute;vel criar um projeto de amostra para testar a instala&ccedil;&atilde;o do compilador e execut&aacute;-lo no depurador para testar a instala&ccedil;&atilde;o do gdb.</p>
<p><b>Para criar um projeto de amostra e execut&aacute;-lo no depurador:</b>
<ol>
<li>Abra o Assistente de Novo projeto em Arquivo &gt; Novo projeto.</li>
<li>No painel Categorias na p&aacute;gina do assistente Escolher projeto, expanda a categoria Amostras e selecione a subcategoria C/C++.</li>
<li>Na janela Projetos, selecione o projeto <tt>Welcome</tt>. Clique em Avan&ccedil;ar.
</li>
<li>Na p&aacute;gina Nome e local do projeto, clique em Concluir.
</li>
<li>Na janela Projetos do IDE, clique com o bot&atilde;o direito do mouse no projeto <tt>Welcome_1</tt> e escolha Construir projeto. Se os compiladores e o utilit&aacute;rio <tt>make</tt> estiverem instalados corretamente e o caminho que leva a eles estiver definido, a sa&iacute;da de cria&ccedil;&atilde;o &eacute; exibida na janela Sa&iacute;da e a cria&ccedil;&atilde;o do projeto &eacute; bem-sucedida.
</li>
<li>Clique duas vezes em <tt>welcome.cc</tt> para abri-lo no Editor de c&oacute;digo-fonte.</li>
<li>Clique com o bot&atilde;o direito do mouse na margem esquerda da janela do Editor de c&oacute;digo-fonte e escolha Mostrar n&uacute;meros de linhas. 
</li>
<li>Defina o ponto de interrup&ccedil;&atilde;o clicando na margem esquerda da janela Editor de c&oacute;digo-fonte ao lado de qualquer linha.
</li>
<li>Clique com o bot&atilde;o direito do mouse no projeto e escolha Depurar. Se o depurador <tt>gdb</tt> estiver instalado corretamente e o caminho para ele estiver definido, o <tt>gdb</tt> ser&aacute; iniciado, as guias do depurador ser&atilde;o exibidas e o aplicativo </tt>Welcome</tt> ser&aacute; executado e interrompido no ponto de interrup&ccedil;&atilde;o.
</li>
<li>Escolha Depurar &gt; Continuar para executar o aplicativo at&eacute; o final.
</li>
<li>Se o projeto n&atilde;o &eacute; constru&iacute;do ou o depurador n&atilde;o funciona, consulte a pr&oacute;xima se&ccedil;&atilde;o.</li>
</ol>
<h2><a name="ts"></a>Solu&ccedil;&atilde;o de problemas de ferramenta</h2>
<ol>
    <li>No IDE, selecione Ferramentas -&gt; Op&ccedil;&otilde;es e clique no bot&atilde;o C/C++.</li>
    <li>Na aba ferramentas de constru&ccedil;&atilde;o, examine a lista Cole&ccedil;&atilde;o de ferramentas para ver se sua cole&ccedil;&atilde;o de ferramentas est&aacute; listada.</li>
    <li>Selecione a cole&ccedil;&atilde;o de ferramentas se estiver listada, e verifique os caminhos para as ferramentas. Se o caminho Diret&oacute;rio base estiver incorreto, voc&ecirc; pode ter cometido um erro ao definir sua vari&aacute;vel de ambiente Path. Consulte as instru&ccedil;&otilde;es para definir seu caminho neste documento e corrija o caminho se for necess&aacute;rio.</li>
    <li>Se a cole&ccedil;&atilde;o de ferramentas n&atilde;o estiver listada, clique em Restaurar padr&otilde;es. Isso far&aacute; com que o IDE fa&ccedil;a nova varredura em seu ambiente para procurar por ferramentas e a cole&ccedil;&atilde;o de ferramentas dever&aacute; ser encontrada se a vari&aacute;vel de ambiente Path estiver correta.</li>
    <li>Se ainda tiver um problema, tente adicionar uma nova cole&ccedil;&atilde;o de ferramentas e especifique o caminho para as ferramentas, como segue:</li>
    <ol type="a">
        <li>Clique em Adicionar abaixo da lista Cole&ccedil;&atilde;o de ferramentas.</li>
        <li>Procure pelo diret&oacute;rio que contenha os execut&aacute;veis para os compiladores, depuradores e para o utilit&aacute;rio make. Este &eacute; normalmente um diret&oacute;rio denominado como bin.</li>
        <li>Selecione o diret&oacute;rio e clique em Abrir. O IDE deveria ser capaz de determinar a fam&iacute;lia de ferramentas e atualizar os outros campos na caixa de di&aacute;logo de forma apropriada. Se n&atilde;o for capaz, um erro &eacute; exibido.</li>
        <li>Se as ferramentas s&atilde;o corretamente identificadas, clique em OK na caixa de di&aacute;logo Adicionar cole&ccedil;&atilde;o de ferramentas. A nova cole&ccedil;&atilde;o deveria estar exibida na lista.</li>
        <li>Selecione a nova cole&ccedil;&atilde;o de ferramentas e clique em Padr&atilde;o para assegurar que esta cole&ccedil;&atilde;o de ferramentas seja automaticamente usada para novos projetos.</li>
    </ol>
<p class="tips">Se n&atilde;o conseguir solucionar o problema, solicite ajuda ao <a href="http://forums.netbeans.org/cnd-users.html" target="_blank">F&oacute;rum de Usu&aacute;rios do NetBeans C/C++</a>.</p>

</ol>

<!-- NEXT STEPS -->
<br>
<h2>Pr&oacute;ximas etapas</h2>
<p>Para aprender de modo r&aacute;pido como desenvolver um aplicativo C ou C++ com o NetBeans IDE, consulte o <a href="../../../kb/docs/cnd/quickstart_pt_BR.html">Tutorial de In&iacute;cio R&aacute;pido de Projetos C/C++</a>
</p>

<div class="feedback-box"><a href="mailto:users@cnd.netbeans.org?subject=Feedback:%20Configuring%20NetBeans%20IDE%206.9%20for%20C/C++/Fortran">Envie-nos seus coment&aacute;rios</a></div>

</body>
</html>
