Headers em

Sobre Headers

Em C++, as declarações geralmente são separadas das definições. As declarações são agrupadas em arquivos chamados de cabeçalho, e as respectivas implementações ficam em arquivos fonte. Você pode pensar nos arquivos de cabeçalho como uma API. O arquivo de cabeçalho diz o que uma base de código tem a oferecer, sem entrar nos detalhes de como.

Cabeçalho e fonte

A extensão de arquivo mais comum para arquivos de cabeçalho é .h. Alguns projetos usam .hpp ou dispensam a extensão por completo.

As definições ficam em um arquivo .cpp separado. Para reunir as partes, o arquivo fonte começa incluindo o respectivo arquivo de cabeçalho.

Se você quiser escrever uma biblioteca chamada "quick_math" que oferece uma função "super_root" que você quer usar com frequência, os arquivos ficariam assim:

// A file named quick_math.h
#pragma once

namespace quick_math {

double super_root(double x, int n);

}

// A file named quick_math.cpp
#include <cmath>

#include "quick_math.h"

double quick_math::super_root(double x, int n) {
    while (n) {
        x = std::sqrt(x), --n;
    }
    return x;
}

Se você precisar incluir um cabeçalho que só é necessário para a implementação, a respectiva linha #include só é necessária no arquivo fonte. Tudo o que é incluído no cabeçalho também fica disponível no arquivo .cpp, como a biblioteca string no exemplo abaixo. Atenção: o ; é necessário depois da declaração no arquivo de cabeçalho, mas não depois da definição no arquivo fonte.

Classes e cabeçalhos

As classes podem ficar muito complexas, e a relação delas com a divisão entre cabeçalho e fonte pode ser confusa. Uma organização possível é manter todos os detalhes de implementação no arquivo fonte e todas as declarações e variáveis membro no cabeçalho:

// A file named robot_flower.h
#if !defined(ROBOT_FLOWER_H)
#define ROBOT_FLOWER_H

#include <string>

namespace robots {

class Flower {
   private:
    bool needs_water{};
    int size{};
    std::string name{};

   public:
    Flower(std::string name, int size = 0);
    void give_water();
    std::string get_name();
    int get_size();
    void start_next_day();
};
}  // namespace robots
#endif

// A file named robot_flower.cpp
#include "robot_flower.h"

robots::Flower::Flower(std::string name, int size) {
    this->name = "Robotica " + name;
    this->size = size;
}

void robots::Flower::start_next_day() {
    if (!needs_water) ++size;
    needs_water = true;
}

std::string robots::Flower::get_name() { return name; }

int robots::Flower::get_size() { return size; }

Quando o cabeçalho é usado como uma visão geral da API, é ali que a pessoa procuraria informações como valores padrão. O valor padrão do parâmetro size do construtor é, portanto, definido no cabeçalho, e não na implementação. As definições no arquivo fonte são prefixadas com o namespace robots e o tipo de classe Flower.

Outra opção de organização é uma biblioteca header only, que não tem nenhum arquivo .cpp:

// A file named robot_flower.h
#pragma once

#include <string>

namespace robots {

class Flower {
   private:
    bool needs_water{};
    int size{};
    std::string name{};

   public:
    Flower(std::string name, int size = 0) {
        this->name = "Robotica " + name;
        this->size = size;
    }
    void give_water() { needs_water = false; }
    std::string get_name() { return name; }
    int get_size() { return size; }
    void start_next_day() {
        if (!needs_water) ++size;
        needs_water = true;
    }
};
}  // namespace robots

Os projetos podem usar combinações dessas organizações, e há muita discussão sobre qual seria a melhor opção para cada caso de uso.

Guardas de inclusão

Você deve ter notado a linha #pragma once no arquivo de cabeçalho de exemplo acima. Isso é chamado de guarda de inclusão, e ela garante que o conteúdo do arquivo seja incluído apenas uma vez durante a compilação, para evitar erros. Existe outra variação, mais complexa, de guarda de inclusão, que começa com #ifndef e termina com #endif, detalhada abaixo.

int myFunction(int n) {
    if (n < 10) {
        return n;
    } else {
        return myOtherFunction(n / 10);
    }
}

int myOtherFunction(int m) { return myFunction(m / 2); }

int myFunction(int n);       // Forward declaration of myFunction
int myOtherFunction(int m);  // Forward declaration of myOtherFunction

// Definition of myFunction
int myFunction(int n) {
    if (n < 0) {
        return 0;
    } else {
        return myOtherFunction(n - 2);
    }
}

// Definition of myOtherFunction
int myOtherFunction(int m) { return myFunction(m / 2); }

#ifndef MY_HEADER_FILE_H /* any name uniquely mapped to file name */
#define MY_HEADER_FILE_H

// file content

#endif