The Norm (42) Guide.

O guia definitivo de regras e padrões de codificação para projetos em C na 42. Escrito profissionalmente, baseado na Versão 4.1.

1) Naming (Nomes)

  • Tipos devem seguir prefixos: s_ (struct), t_ (typedef), u_ (union), e_ (enum), g_ (global).
  • Identificadores: apenas minúsculas, dígitos e _ (snake_case). Sem maiúsculas.
  • Nomes de arquivos e pastas: apenas snake_case.
  • ASCII apenas (exceto dentro de strings/chars literais).
  • Globais não const ou não static são proibidas.
ERRO Fail 
typedef struct Pessoa
{
    char *Nome;
} Pessoa;

int Global;
CORRETO Success 
typedef struct s_person
{
    char    *name;
}   t_person;

static int  g_counter;
PREFIXOS ERRADOS Fail 
union Data { int i; };      // sem u_
enum Color { RED, BLUE };   // sem e_
int my_global;              // sem g_
PREFIXOS CORRETOS Success 
union u_data { int i; };
enum e_color { RED, BLUE };
static int g_my_global;
Dica: Use nomes autoexplicativos em inglês. A clareza é o pilar da Norma.

2) Formatting (Formatação)

  • Função: máximo de 25 linhas (sem contar as chaves).
  • Linhas: máximo de 80 colunas (incluindo comentários).
  • Indentação: use TAB real de 4 colunas.
  • Chaves: sozinhas em sua própria linha (exceto em struct/enum/union).
  • Variáveis: Declarações no início; 1 por linha; sem inicialização (exceto static/const).
  • Operadores: exatamente 1 espaço de cada lado.
  • Asterisco: colado ao nome da variável (ex: char *str).
  • Estruturas de controle: sempre usam chaves, a menos que 1 instrução em 1 linha.
ESTILO E DECLARAÇÃO Fail 
if (x>0) { y=1; z=2; }
int a, b, c;          // + de 1 por linha
int x = 10;          // init na decl
char *s1;
int counter;          // nomes desalinhados
PADRÃO 42 (TAB E ALINHAMENTO) Success 
if (x > 0)
{
	y = 1;
	z = 2;
}

int	a;
int	b;
char	*s1;   // use TAB para alinhar *
int	counter;
OPERADORES E VÍRGULAS Fail 
if (! x)                 // espaço extra
func(a,b , c);           // espaço antes/falta depois
i++;  // ok
i +=1;                 // falta espaço
ESPAÇAMENTO UNIFORME Success 
if (!x)                 // unário colado
func(a, b, c);          // espaço APÓS vírgula

i++;
i += 1;                // bi-operador com espaços

3) Functions (Funções)

  • Máximo de 4 parâmetros nomeados.
  • Sem argumentos? Use void explicitamente.
  • Máximo de 5 variáveis por função.
  • return: sempre entre parênteses.
  • Tipo de retorno: um TAB entre o tipo e o nome.
LIMITES E VOID Fail 
int sum(int a, int b, int c, int d, int e)
{
	int v1; int v2; int v3;
	int v4; int v5; int v6; // > 5 vars
	return a + b;
}

int get_val()  // falta void
{
	return (42);
}
CONTROLE DE ESCOPO Success 
int	sum(int a, int b)
{
	int	res;

	res = a + b;
	return (res);
}

int	get_val(void)
{
	return (42);
}

4) Types (Struct/Enum)

  • Espaço obrigatório após struct/enum/union.
  • Proibido: declarar struct em arquivos .c.
MODELO EM HEADER (.h) FORTE
typedef struct s_point
{
	int		x;
	int		y;
}	t_point;

typedef enum e_status
{
	IDLE,
	RUNNING,
	ERROR
}	t_status;

typedef union u_value
{
	int		i;
	float	f;
}	t_value;

5) Headers (.h)

  • Apenas includes, declarações, defines, protótipos e macros.
  • Includes: sempre no início do arquivo.
  • Proibição: nunca inclua um arquivo .c.
  • Header Guards: use NAME_H ou FT_NAME_H em caixa alta.
  • Protótipos: tipos e nomes devem estar alinhados com TABs.
ERROS COMUNS Fail 
#include "file.c"       // Erro: incluir .c
void ft_test(int);     // Erro: sem nome param

void f1(int n);
int f2(int n);         // Desalinhado
ESTRUTURA CORRETA Success 
#ifndef LIBFT_H
#define LIBFT_H

#include <unistd.h>

void	ft_putchar(char c);
int		ft_strlen(const char *s);

#endif

6) Standard 42 Header

Todo arquivo deve começar com o cabeçalho ASCII oficial contendo login, e-mail e timestamps.

CABEÇALHO OFICIAL
/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   ft_example.c                                        :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: login <login@student.42...>                +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2026/01/11 00:00:00 by login              #+#    #+#             */
/*   Updated: 2026/01/11 00:00:00 by login             ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */

7) Macros & Preprocessor

  • #define: use apenas para constantes literais.
  • Macros multi-linha: estritamente proibidas.
  • Nomes: sempre em CAIXA ALTA.
  • Diretivas: proibidas fora do escopo global.
MACROS COM LÓGICA Fail 
#define MAX(a, b) (a > b ? a : b)
#define PRINT_OK { ft_putstr("OK\n"); }
CONSTANTES PURAS Success 
#define BUFFER_SIZE 4096
#define TIMEOUT_SEC 10

8) Forbidden (Proibidos)

Palavras-chave e técnicas banidas para promover clareza e controle de fluxo simples.

ESTRUTURAS BANIDAS Fail 
for (int i = 0; i < 10; i++) { ... }
switch (n) { case 1: ... }
do { ... } while (x);
EQUIVALENTES OK Success 
while (i < 10)
{
	...
	i++;
}

if (n == 1) { ... }
NÍVEIS DE IDENTAÇÃO Fail 
while (i)
{
	if (j)
	{
		while (k)
		{
			if (l) // > 3 níveis (branching)
				do_something();
		}
	}
}
FLUXO SIMPLIFICADO Success 
while (i && j)
{
	ft_handle_deep_logic(k);
}

9) Comments (Comentários)

  • Proibido: comentários dentro do corpo da função.
  • Posição: Fim da linha ou linha própria.
  • Idioma preferencial: Inglês.
COMENTÁRIO INTERNO Fail 
void	ft_test(void)
{
	int i; // comentario aqui proibido
	i = 0;
}
COMENTÁRIO EXTERNO Success 
// Esta função não faz nada
void	ft_test(void)
{
	int	i;

	i = 0;
}

10) Files

  • Não inclua arquivos .c em outros arquivos .c.
  • Máximo de 5 funções por arquivo.

11) Makefile

  • Regras obrigatórias: all, clean, fclean, re e $(NAME).
  • Relink: seu Makefile não pode compilar novamente se nada mudou.
  • Fontes: Listagem explícita (nada de *.c).
MAKEFILE ROBUSTO (NO RELINK)
NAME	= libft.a
CC		= cc
CFLAGS	= -Wall -Wextra -Werror
SRCS	= ft_strlen.c ft_memset.c
OBJS	= $(SRCS:.c=.o)

all: $(NAME)

$(NAME): $(OBJS)
	ar rcs $(NAME) $(OBJS)

clean:
	rm -f $(OBJS)

fclean: clean
	rm -f $(NAME)

re: fclean all

.PHONY: all clean fclean re

Exemplo Final Complacente

PRODUÇÃO (PASS)
#include <unistd.h>

static int	ft_putstr(char *str)
{
	int	i;

	i = 0;
	while (str[i] != '\0')
	{
		write(1, &str[i], 1);
		i++;
	}
	return (i);
}

int	main(void)
{
	ft_putstr("Hello, Norm!\n");
	return (0);
}