ForHosting KIT · Ferramentas para dev

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
Use pelo WebAPIE-mailTelegramApp em breve

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.

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.

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.

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.

POSThttps://api.kit.forhosting.com/dev/struct-field-offset

Autenticação por token Bearer. Um único POST coloca a tarefa na fila; o resultado chega por webhook ou link assinado.

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"}]}'
{
  "fields": [
    {
      "name": "a",
      "type": "char"
    },
    {
      "name": "b",
      "type": "int"
    },
    {
      "name": "c",
      "type": "char"
    }
  ]
}
{
  "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.

por chamadaUS$ 0,002

Preço publicado, sem tokens nem créditos escondidos. Tarefa que falha não é cobrada.

HTTPCódigoO que significa
401unauthorizedToken ausente ou inválido. Confira o header Authorization.
402insufficient_balanceSaldo insuficiente para esta tarefa. Faça uma recarga e tente de novo.
404unknown_typeEsse tipo de tarefa não existe. Confira o campo type no catálogo.
429rate_limitedMuitas requisições em pouco tempo. Espere um instante e tente de novo.

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.

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.

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.

Ver a documentação completa do KIT →