Calculadora offset campos struct
Um char, um int e outro char ocupam 12 bytes, não 6: a calculadora mostra o deslocamento de cada membro, o preenchimento antes dele e o do final, com as mesmas regras do seu compilador. Grátis no seu navegador.
- Grátis
- Funciona no seu navegador
- Sem cadastro
- Seus dados não saem do seu aparelho
Executar grátis
Compiladores C e C++ colocam cada membro de uma struct em um deslocamento em bytes que respeita o alinhamento natural do membro e depois preenchem o tipo completo para que arrays da struct permaneçam alinhados. Esta calculadora de offset de campos de struct aceita uma lista ordenada de campos com tipos escalares C conhecidos ou com size e alignment explícitos, aplica as mesmas regras de arredondamento para cima de um compilador e devolve o offset de cada campo, o padding anterior, o tamanho total da struct, o alinhamento global e o padding final. Valores opcionais de pack modelam structs empacotadas; o abi opcional escolhe LP64, LLP64 ou ILP32 para larguras de long e ponteiro.
Como C posiciona campos: alinhamento, padding e sizeof
Para uma sequência de membros na ordem de declaração o compilador mantém um cursor de bytes que começa em zero. Antes de colocar um campo arredonda o cursor para cima até um múltiplo do alinhamento efetivo desse campo, registra esse endereço como offset do campo e avança o cursor pelo tamanho do campo. Os bytes saltados no arredondamento viram padding antes do membro e nunca fazem parte do armazenamento próprio do campo.
Após o último membro o compilador pode inserir padding final para que o tamanho total seja múltiplo do alinhamento da estrutura, definido como o máximo alinhamento efetivo entre todos os membros. Esse tamanho final é o que sizeof devolve, e cada endereço registrado é o que offsetof devolve para o nome do membro correspondente.
O alinhamento natural dos escalares segue o ABI da plataforma: em sistemas LP64 char tem um byte alinhado a um, short a dois, int a quatro, long e ponteiro a oito, float a quatro e double a oito; LLP64 mantém long em quatro enquanto ponteiros ficam em oito, e ILP32 usa quatro para long e para ponteiros. Esta calculadora codifica essas tabelas para que você possa trocar de ABI sem reescrever listas de campos.
Entender esse salto é o propósito de uma ferramenta offsetof: dumps de memória, formatos de fio e ligações geradas devem concordar com o compilador, não com uma soma mental casual de tamanhos.
Casos de uso
Protocolos binários e análise de dumps
Confirme o offset em bytes de cada campo e o sizeof total antes de escrever um decodificador de fio ou interpretar um dump de memória em relação a uma struct C.
Ligações FFI e multi-ABI
Gere ou verifique layouts LP64, LLP64 e ILP32 para a mesma lista de membros para que as ligações nativas correspondam a cada modelo de dados alvo.
Perguntas frequentes
Como calcular offsets de campos de uma struct C?
Envie fields como array ordenado de {name, type} (ou {name, size, alignment}).
Isso corresponde à macro offsetof?
Sim para membros escalares sob o ABI escolhido e o valor opcional de pack. Offsets e sizeof seguem as mesmas regras de colocação que os compiladores usam em structs escalares naturais ou empacotadas.
Quais ABIs são suportados?
lp64 (padrão: long e ponteiro com 8 bytes), llp64 (Windows 64 bits: long 4, ponteiro 8) e ilp32 (long e ponteiro 4).
Por que o sizeof da minha struct é maior que a soma dos membros?
Porque o compilador insere preenchimento. Com char, int e char, entram três bytes antes do int, que começa no deslocamento 4, e mais três no final, para que o total de 12 seja múltiplo do alinhamento da struct, que é 4.
Como simular uma struct compactada com #pragma pack?
Escolha um empacotamento de 1, 2, 4 ou 8 bytes. Cada membro passa a usar o menor valor entre o seu alinhamento natural e o empacotamento escolhido; sem essa opção, vale o layout natural, sem compactação.
Ferramentas relacionadas
Para desenvolvedores — acesso via API
Tudo nesta página está disponível via API. Esta seção é para equipes que querem integrar a ferramenta aos próprios sistemas; quem não precisa disso pode simplesmente usar a ferramenta acima.
Endpoint
Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.
Chame do seu código
curl -X POST https://api.kit.forhosting.com/dev/struct-field-offset \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"fields":[{"name":"a","type":"char"},{"name":"b","type":"int"},{"name":"c","type":"char"}]}'const res = await fetch("https://api.kit.forhosting.com/dev/struct-field-offset", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"fields": [
{
"name": "a",
"type": "char"
},
{
"name": "b",
"type": "int"
},
{
"name": "c",
"type": "char"
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/struct-field-offset",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"fields": [
{
"name": "a",
"type": "char"
},
{
"name": "b",
"type": "int"
},
{
"name": "c",
"type": "char"
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/struct-field-offset", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"fields":[{"name":"a","type":"char"},{"name":"b","type":"int"},{"name":"c","type":"char"}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"fields":[{"name":"a","type":"char"},{"name":"b","type":"int"},{"name":"c","type":"char"}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/struct-field-offset", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemplo de requisição
{
"fields": [
{
"name": "a",
"type": "char"
},
{
"name": "b",
"type": "int"
},
{
"name": "c",
"type": "char"
}
]
}Exemplo de resposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.struct_field_offset",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}A API é assíncrona: cada chamada devolve um task_id na hora. Se preferir polling, consulte o status a até 1 requisição por segundo.
Preço
Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.
Erros
| HTTP | Código | O que significa |
|---|---|---|
401 | unauthorized | Token ausente ou inválido. Confira o header Authorization. |
402 | insufficient_balance | Saldo insuficiente para esta tarefa. Faça uma recarga e tente de novo. |
404 | unknown_type | Esse tipo de tarefa não existe. Confira o campo type no catálogo. |
429 | rate_limited | Muitas requisições em pouco tempo. Espere um instante e tente de novo. |
Notas técnicas
Esse layout é exatamente o que a macro offsetof e o operador sizeof reportam; ainda assim, contar padding à mão entre ABIs e #pragma pack continua gerando bugs silenciosos em protocolos binários, ligações FFI e dumps de memória. O caminho gratuito no navegador e a API pré-paga compartilham um único módulo analítico puro, de modo que chaves de exercícios e oráculos de produção nunca discordam. Validação falha lança invalid_input e não é cobrada.
Como C posiciona campos: alinhamento, padding e sizeof
Quando dois campos adjacentes não precisam de padding, padding_before vale zero; quando um char é seguido de um int em layout natural aparecem três bytes de padding antes do int e o offset salta de um para quatro.
Contrato de entrada, packing, ABI, forma da resposta e erros
O pack opcional pode ser um, dois, quatro ou oito para modelar #pragma pack(n): o alinhamento efetivo de cada campo torna-se o mínimo entre o alinhamento natural e pack. O abi opcional tem padrão lp64 e pode ser llp64 ou ilp32. Membros opacos personalizados fornecem size inteiro positivo e alignment potência de dois sem depender da tabela de tipos. Envie por POST um corpo JSON com fields como array não vazio de objetos, cada um com name não vazio e uma string type ou então size e alignment em bytes. Tipos conhecidos incluem char, short, int, long, long long, float, double, bool, a família de largura fixa intN_t e uintN_t, e pointer ou size_t para inteiros do tamanho de endereço. Os aliases members e layout são aceitos para o array. Omita pack para layout natural sem empacotamento. Arrays vazios, nomes de tipo desconhecidos, alignments que não são potência de dois, names ausentes e valores de pack fora do enum falham com invalid_input. Em sucesso o corpo inclui abi; pack opcional quando o packing está ativo; field_count; fields com index, name, type, size, natural_alignment, effective_alignment, offset e padding_before; struct_size; struct_alignment; trailing_padding; total_padding; used_bytes (apenas a soma dos tamanhos dos membros); method c_struct_offsetof; e uma string formula curta. Exemplo: char a, int b, char c sob LP64 natural produz offsets zero, quatro e oito com struct_size doze e três bytes de padding interno antes de b mais três bytes finais para que o tamanho seja múltiplo de quatro. Combine os offsets com seu próprio dump ou gerador de código; este endpoint não emite fonte C, apenas os números de layout que offsetof e sizeof implicariam.
Onde uma API de offset de struct se paga, preço e limites
Programadores de sistemas e engenheiros de engenharia reversa usam uma calculadora de offset de campos de struct para verificar se um layout escrito à mão coincide com o compilador antes de publicar um analisador de protocolo binário ou um dump de estrutura do kernel. Geradores de FFI e de ligações precisam de números determinísticos de offsetof e sizeof para LP64 versus LLP64 do Windows para que a mesma descrição de esquema possa mirar Linux, macOS e Win64 sem recompilar um programa sonda em cada host. Validação falha não consome saldo. Mantenha as listas de campos dentro do máximo publicado, prefira tipos nomeados por portabilidade e fixe offsets nos testes. Laboratórios de ensino sobre alinhamento e packing atribuem aos alunos uma lista de campos e um valor de pack; um oráculo API puro marca como erro o equívoco comum de somar tamanhos sem padding. Suites de integração contínua fixam struct_size e cada offset para que uma mudança de esquema que insere um campo ou altera flags de ABI falhe de imediato. Como a implementação é parse pura de nível A, cada chamada bem-sucedida custa o preço base publicado US$ 0,002 sem tokens de modelo e sem rede de saída.
Casos de integração
Ensino de alinhamento e packing
Permita que alunos comparem layouts naturais versus #pragma pack e vejam padding_before e trailing_padding sem compilar programas sonda.
Perguntas técnicas
O que o pack faz?
pack modela #pragma pack(n). O alinhamento efetivo de cada campo é min(natural_alignment, n). Omita pack para layout natural (sem empacotamento).
Quanto custa a calculadora de offset de campos de struct?
A ferramenta do navegador é gratuita. Pedidos API usam saldo pré-pago KIT a US$ 0,002 por chamada bem-sucedida; entrada inválida não é cobrada.