Motivação: Por que modularizar ?

• O que acontece se o programa é composto por muitas funções ?
  • Todas ficam dentro do mesmo código-fonte
  • Código pode se tornar muito extenso e difícil de gerenciar
• Isso também cria dois outros problemas:
  • Dificulta a reutilização das funções em outros programas
  • Dificulta o trabalho em equipe
• Então, qual é a solução ?

Solução: Modularização

Agrupam-se as funções relacionadas em módulos. Para cada módulo são utilizados dois arquivos:

• Declarações
  • Sufixo .h
  • Contém apenas as declarações das funções (protótipos) e das constantes
• Implementação
  • Sufixo .cpp
  • Contém a implementação das funções declaradas no arquivo .h correspondente
  • Inclui o arquivo .h correspondente

Para usar uma função em outro módulo, basta então incluir o arquivo .h correspondente

Criação do header> da biblioteca de funções (2)

Para exemplificar, criaremos uma biblioteca simples de funções matemáticas. Primeiro, escrevemos os protótipos das funções no arquivo bibfunc.h:

float fatorial(int v);
float somatorio(int v);
...

Criação do header> da biblioteca de funções (2)

Porém, se por engano esse arquivo for incluído mais de uma vez, haverá uma duplicidade de todas as definições. Como isso pode acontecer facilmente, acrescentamos 3 linhas no arquivo .h:

#ifndef BIBFUNC_H
#define BIBFUNC_H

float fatorial(int v);
float somatorio(int v);
...
#endif

• Essas linhas contêm comandos do pré-processador, que definem um símbolo BIBFUNC_H caso este ainda não exista.
• Se existir, é porque o arquivo já foi incluído e portanto, o pré-processador pula o código até o #endif.

Implementação das funções

A seguir, escrevemos o arquivo bibfunc.cpp, que contém a implementação das funções definidas anteriormente.

#include "bibfunc.h"

float fatorial(int v) {
  int res = 1;
  for(int i=1; i<=v; i++)
    res = res * i;
  return res;
}
...

• Note que este arquivo deve incluir o arquivo bibfunc.h

Programa Principal

Finalmente, o programa principal deve ser implementado em um arquivo separado, como por exemplo main.cpp:

#include <iostream>
#include "bibfunc.h"

using namespace std;

int main()
{
    cout << "Digite um valor: ";
    int v;
    cin >> v;
    cout << "Fatorial: " << fatorial(v);
    cout << "Somatório: " << somatorio(v);
    ...
}

• Observe que o arquivo bibfunc.h deve ser incluído, pois contém a definição de classe.

Compilação dos Módulos

Para compilar o programa completo, é preciso indicar todos os fontes na linha de comando:

• g++ -o main main.cpp bibfunc.cpp

Porém, essa estratégia tem algumas implicacões:

• Todos os módulos são SEMPRE compilados novamente
• Mas e se apenas mudar a implementação das funções ?
• E se apenas o programa principal mudar ?

Para um programa tão pequeno, isso não faz tanta diferença...

Mas se o programa for composto por muitos módulos, compilá-los separadamente pode ter um custo considerável, além de não ser muito prático.

Compilação Modular: Makefiles

Um Makefile é um roteiro de compilação:

• Informa as dependências entre os arquivos
• Indica os comandos necessários para a compilação

O nome do arquivo deve ser preferencialmente Makefile.
Para utilizá-lo, basta digitar o comando make no terminal.

all: main

main: main.o bibfunc.o
	g++ -o main main.o bibfunc.o

main.o: main.cpp
	g++ -c main.cpp

bibfunc.o: bibfunc.cpp
	g++ -c bibfunc.cpp

• O comando g++ -c ... apenas compila o módulo especificado, produzindo um arquivo .o, que é o chamado código-objeto (sem ligação com bibliotecas).

Compilação Modular: Makefiles (2)

Os comandos de compilação não parecem meio repetitivos ? Podemos melhorar o Makefile, criando regras genéricas:

CXXFLAGS = -Wall -g    # Opções do compilador: todos warnings e debug info

PROG = main
FONTES = main.cpp bibfunc.cpp
OBJETOS = $(FONTES:.cpp=.o)

$(PROG): $(OBJETOS)
	g++ $(CXXFLAGS) $(OBJETOS) -o $@

clean:
	-@ rm -f $(OBJETOS) $(PROG)

• PROG = ... define o nome do programa executável
• FONTES = ... define todos os módulos
• OBJETOS = ... define como transformar um .cpp em um .o
• clean permite apagar os arquivos .o e executável gerados (make clean)

Compilação Modular: Makefiles (3)

Mas e como especificar dependências automáticas para os .h ?
Uma forma é incluir uma regra que use o comando makedepend:

...
clean:
	-@ rm -f $(OBJETOS)

depend:
	makedepend -- ${CFLAGS} -- ${FONTES}

Ao digitarmos make depend, o comando makedepend será ativado, e verificará as dependências de cada módulo, incluindo estas no final do próprio Makefile:

...
depend:
	makedepend -- ${CFLAGS} -- ${FONTES}

# DO NOT DELETE

main.o: bibfunc.h
bibfunc.o: bibfunc.h

Compilação Modular: Alternativas ao make

Já existem alguns sistemas alternativos ao make:

• SCons - escrito em Python, oferece uma sintaxe mais flexível, é multiplataforma e tem diversos recursos interessantes.
• CMake (Cross-Platform Make) - este sistema tem o objetivo de gerar Makefiles adaptados para a plataforma de compilação.
• Boost.Build - específico para C++, também multiplataforma e com uma sintaxe simples.
• GNU Build System (autotools) - sistema mais utilizado atualmente para instalação de software no Linux/Unix (Com software adicional instalado, pode ser utilizado também no Windows).
• Obs: projetos criados em IDEs como Visual Studio ou Code::Blocks simplesmente automatizam essa tarefa.