Compilando com gcc, g++

Ønymush4
(usa Slackware)

Enviado em 10/11/2005 - 19:58h

Compilando com gcc, g++

Slackware + Ønymush4 + Dejavu = hacking em família via linuX

O gcc/g++ é o compilador C/C++ da GNU. Pode ser baixado no site da gnu, individualmente,
Ou como parte do pacote do EGCS (que inclue um conjunto de programas acessórios).

Obs.: para mais detalhes baixe o manual do gcc no site da GNU

Protótipo e parâmetros do gcc/g++

Aqui vao os protótipo/parâmetros q vc vai passar para o compilador GNU
Como dito acima baixe o manual para mais detalhes

Protótipo do gcc/g++:

g++ [opções] [parâmetros] arquivos.
-v ------------------------------------------------------------------------------Mostra detalhes da compilação.
-wall -----------------------------------------------------------------------Mostra todos os warnings.
-onome -------------------------------------------------------------------Define o nome do arquivo de saída (opcional).
-w ---------------------------------------------------------------------------Elimina mensagens de warning.
-I/path ------------------------------------------------------------------------Acrescenta path include.
-l/path/lib ---------------------------------------------------------------------Inclue biblioteca (lib).
-ggdb --------------------------------------------------------------------------Informações extras para o gdb.
-O -----------------------------------------------------------------------------Optimiza o código (-O1,-O2,-O3).
-c--------------------------------------- ---------------------------------------Somente compila (gera o arquivo *.o).
-S -----------------------------------------------------------------------------Somente compila o arquivo, não linka.
-lcomplex ------------------------------------------------------------------Inclue biblioteca dos complexos.
-lm Inclue -----------------------------------------------------------------biblioteca matemática.
-E --------------------------------------------------------------------------Cria somente o arquivo pré-processado.
-C --------------------------------------------------------------------------Não inclue comentários no executável.
-g --------------------------------------------------------------------------Gera informações para o debuger (código lento).


Arquivos gerados pelo gcc/g++


-qdigraph ----------------------------------------------------------------------------Adiciona teclas dígrafas.
-qcompact---------------------------------------------------------------------- Deixa o código mais compacto.
-xlinguagem--------------------------------------------------------------------- Expecfica a linguagem (C, C++,assembler).
-p --------------------------------------------------------------------------------------Informações para o profiler proff.
-pg -----------------------------------------------------------------------------------Informações para o gro_.
-m686 -------------------------------------------------------------------------------Especifica que a máquina alvo é um 686.
-static --------------------------------------------------------------------------------Especifica que a linkagem deve ser estática.
-p -----------------------------------------------------------------------------Especifica inclusão de instruções para o profiler.
-pg ----------------------------------------------------------------------------Especifica inclusão de instruções para o profiler da gnu (gprof ).

A medida q os arquivos sao compilados e linkados, sao gerados alguns arquivos adicionais.
Lista-se a seguir os arquivos de entrada (*.h, *.cpp), e os arquivos de saída gerados pelo g++.
*.h ----------------------------------------------------------Arquivos header.
*.i----------------------------------------------------------- Arquivos de pré-processamento para programas em C.
*.ii ----------------------------------------------------------Arquivos de pré-processamento para programas em C++.
.c,.cc,.C,.c++,.cpp, ------------------------------------Arquivos de fonte.
.o ------------------------------------------------------------Arquivo objeto.
.s -------------------------------------------------------------Arquivo assembler.
.a -----------------------------------------------------------------Arquivo de biblioteca estática.
.sa --------------------------------------------------------------Blocos de bibliotecas estáticas linkados ao programa.
.so.n -------------------------------------------------------------Arquivo de biblioteca dinâmica.
a.out---------------------------------------------------------------- Arquivo de saída (executável).


Exemplo de uso do gcc/g++


Exemplo básico:

1. Edita o programa hello.cpp com o emacs.
Abra um terminal e execute emacs hello.cpp.

#include <iostream>
using namespace std;
main()
{
cout < < “hello!” < < endl;
}
/*No emacs use ctrl+x ctrl+s para salvar o arquivo
e ctrl+x ctrl+q para sair do emacs*/

2. Cria o arquivo de pré-processamento [opcional]
g++ -E hello.cpp

3. Compila o módulo hello (gera o hello.o)
g++ -c hello.cpp

4. Linka o programa e gera o executável
g++ -ohello hello.o

5. Executa o programa
./hello

6. Observe que os passos 2,3 e 4 podem ser executados usando:
g++ -v -ohello hello.cpp
O -v Mostra um conjunto de informações a respeito dos passos da compilação.
Neste exemplo o nome do programa executável é hello e foi especificado com a opção -ohello.
Se vc naum especificar um nome, o programa executável se chamará a.out.
Tarefa: Compare o tamanho dos códigos (dos executáveis) gerados com as opções:
g++ hello.cpp #comun
g++ -g2 hello.cpp #com debuger
g++ -o3 hello.cpp #com otimização


Só pra lembrar:

Linker: O linker transforma um ou mais arquivos *.obj (*.o) em um arquivo executável. Os
arquivos que serão unidos são definidos em um arquivo de projeto ou em um arquivo makefile.
Depois de linkado um programa tem um arquivo executável *.exe no Windows, a.out no Linux. Os
Erros de ligação são detectados pelo linker. Veja mais em baixo as extensões dos arquivos gerados nas diferentes plataformas.



Situações: **************************Windows*****************************linux
Antes de compilar*********************nome.h/nome.cpp*******************nome.h/nome.cpp
Depois de compilar *******************nome.obj*****************************nome.o
Depois de linkar***********************nome.exe*****************************nome



leave me alone

Sinapse codename perigo