Calculadora offset campos struct
Un char, un int y otro char ocupan 12 bytes, no 6: la calculadora muestra el desplazamiento de cada miembro, el relleno que lo precede y el del final, con las mismas reglas que su compilador. Gratis en su navegador.
- Gratis
- Funciona en su navegador
- Sin registro
- Sus datos no salen de su equipo
Ejecutar — gratis
Los compiladores de C y C++ colocan cada miembro de un struct en un desplazamiento en bytes que respeta la alineación natural del miembro y luego rellenan el tipo completo para que los arrays del struct sigan alineados. Ese diseño es exactamente lo que informan la macro offsetof y el operador sizeof; aun así, contar a mano el relleno entre ABI y #pragma pack sigue provocando fallos silenciosos en protocolos binarios, enlaces FFI y volcados de memoria. Esta calculadora de offset de campos de struct acepta una lista ordenada de campos con tipos escalares C conocidos o con tamaño y alineación explícitos, aplica las mismas reglas de redondeo al alza que usa un compilador y devuelve el offset de cada campo, el relleno anterior, el tamaño total de la struct, la alineación global y el relleno final. Los valores opcionales de pack modelan structs empaquetados; el abi opcional elige LP64, LLP64 o ILP32 para anchos de long y puntero.
Cómo C coloca los campos: alineación, relleno y sizeof
Para una secuencia de miembros en orden de declaración el compilador mantiene un cursor de bytes que empieza en cero. Antes de colocar un campo redondea el cursor al alza hasta un múltiplo de la alineación efectiva de ese campo, registra esa dirección como offset del campo y avanza el cursor según el tamaño del campo. Los bytes omitidos en el redondeo se convierten en relleno anterior al miembro y nunca forman parte del almacenamiento propio del campo.
Tras el último miembro el compilador puede insertar relleno final para que el tamaño total sea múltiplo de la alineación de la estructura, definida como la máxima alineación efectiva entre todos los miembros. Ese tamaño final es lo que devuelve sizeof, y cada dirección registrada es lo que offsetof devuelve para el nombre de miembro correspondiente.
La alineación natural de los escalares sigue el ABI de la plataforma: en sistemas LP64 char mide un byte y se alinea a uno, short a dos, int a cuatro, long y puntero a ocho, float a cuatro y double a ocho; LLP64 mantiene long en cuatro mientras los punteros siguen en ocho, e ILP32 usa cuatro para long y para punteros. Esta calculadora codifica esas tablas para que usted pueda cambiar de ABI sin reescribir las listas de campos.
Comprender ese salto es el propósito de una herramienta offsetof: volcados de memoria, formatos de cable y enlaces generados deben coincidir con el compilador, no con una suma mental informal de tamaños.
Qué puede hacer con ella
Protocolos binarios y análisis de volcados
Confirme el offset en bytes de cada campo y el sizeof total antes de escribir un decodificador de cable o interpretar un volcado de memoria frente a una struct C.
Enlaces FFI y multi-ABI
Genere o verifique diseños LP64, LLP64 e ILP32 para la misma lista de miembros de modo que los enlaces nativos coincidan con cada modelo de datos objetivo.
Preguntas frecuentes
¿Cómo se calculan los offsets de campos de una struct C?
Envíe fields como array ordenado de {name, type} (o {name, size, alignment}).
¿Coincide esto con la macro offsetof?
Sí para miembros escalares bajo el ABI elegido y el valor opcional de pack. Los offsets y sizeof siguen las mismas reglas de colocación que usan los compiladores en structs escalares naturales o empaquetadas.
¿Qué hace pack?
pack modela #pragma pack(n). Omita pack para el diseño natural (sin empaquetar).
¿Qué ABI se admiten?
lp64 (por defecto: long y puntero de 8 bytes), llp64 (Windows 64 bits: long 4, puntero 8) e ilp32 (long y puntero 4).
¿Por qué el sizeof de mi struct es mayor que la suma de sus miembros?
Porque el compilador añade relleno. Con un char, un int y un char, se insertan tres bytes antes del int para que empiece en el desplazamiento 4, y otros tres al final para que el total de 12 sea múltiplo de la alineación de la struct, que es 4.
Herramientas relacionadas
Para desarrolladores — acceso por API
Todo lo de esta página está disponible por programación. Esta sección es para equipos que quieren integrarlo en sus sistemas; el resto puede usar la herramienta de arriba sin más.
Endpoint de API
¿Prefiere automatizarlo? Un POST autenticado crea la tarea; el resultado llega por webhook o enlace firmado. La misma capacidad también se ejecuta aquí en la web, por email y desde Telegram — y pronto también desde nuestra app.
Llámela desde su stack
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)Ejemplo de solicitud
{
"fields": [
{
"name": "a",
"type": "char"
},
{
"name": "b",
"type": "int"
},
{
"name": "c",
"type": "char"
}
]
}Ejemplo de respuesta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.struct_field_offset",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}La API es asíncrona: la llamada devuelve un task_id al instante y el resultado llega por webhook. El polling está limitado a 1 req/s por tarea.
Precio
Precio publicado — sin tokens ni créditos inventados. Una tarea fallida no se cobra.
Errores
| HTTP | Código | Significado |
|---|---|---|
401 | unauthorized | API key ausente o inválida. |
402 | insufficient_balance | El saldo no cubre el precio de la tarea. |
404 | unknown_type | El tipo de tarea no existe. |
429 | rate_limited | Demasiadas peticiones. Use el webhook en vez de sondear. |
Notas técnicas
La ruta gratuita del navegador y la API de prepago comparten un único módulo analítico puro, de modo que las claves de ejercicios y los oráculos de producción no discrepan. Una validación fallida lanza invalid_input y no se factura.
Cómo C coloca los campos: alineación, relleno y sizeof
Cuando dos campos adyacentes no necesitan relleno, padding_before vale cero; cuando un char va seguido de un int en diseño natural aparecen tres bytes de relleno antes del int y el offset salta de uno a cuatro.
Contrato de entrada, empaquetado, ABI, forma de respuesta y errores
El pack opcional puede ser uno, dos, cuatro u ocho para modelar #pragma pack(n): la alineación efectiva de cada campo pasa a ser el mínimo entre su alineación natural y pack. Omita pack para el diseño natural sin empaquetar. El abi opcional vale lp64 por defecto y puede ser llp64 o ilp32. Los miembros opacos personalizados aportan tamaño entero positivo y alineación potencia de dos sin depender de la tabla de tipos. Envíe por POST un cuerpo JSON con fields como array no vacío de objetos, cada uno con un name no vacío y bien una cadena type o bien size y alignment en bytes. Los tipos conocidos incluyen char, short, int, long, long long, float, double, bool, la familia de ancho fijo intN_t y uintN_t, y pointer o size_t para enteros del tamaño de dirección. Se aceptan los alias members y layout para el array. Arrays vacíos, nombres de tipo desconocidos, alineaciones que no son potencia de dos, names ausentes y valores de pack fuera del enum fallan con invalid_input. Si tiene éxito, el cuerpo incluye abi; pack opcional cuando el empaquetado está activo; field_count; fields con index, name, type, size, natural_alignment, effective_alignment, offset y padding_before; struct_size; struct_alignment; trailing_padding; total_padding; used_bytes (solo la suma de tamaños de miembros); method c_struct_offsetof; y una cadena formula breve. Ejemplo: char a, int b, char c bajo LP64 natural produce offsets cero, cuatro y ocho con struct_size doce y tres bytes de relleno interno antes de b más tres bytes finales para que el tamaño sea múltiplo de cuatro. Combine los offsets con su propio volcado o generador de código; este endpoint no emite fuente C, solo los números de diseño que implicarían offsetof y sizeof.
Dónde aporta valor una API de offset de struct, precio y límites
Programadores de sistemas e ingenieros de ingeniería inversa usan una calculadora de offset de campos de struct para comprobar que un diseño escrito a mano coincide con el compilador antes de publicar un analizador de protocolo binario o un volcado de estructura del núcleo. Los generadores de FFI y de enlaces necesitan números deterministas de offsetof y sizeof para LP64 frente a LLP64 de Windows de modo que la misma descripción de esquema pueda apuntar a Linux, macOS y Win64 sin recompilar un programa de sonda en cada host. La validación fallida no consume saldo. Mantenga las listas de campos dentro del máximo publicado, prefiera tipos con nombre por portabilidad y fije los offsets en las pruebas. Los laboratorios de enseñanza sobre alineación y empaquetado asignan a los alumnos una lista de campos y un valor de pack; un oráculo API puro marca como error el fallo habitual de sumar tamaños sin relleno. Las suites de integración continua fijan struct_size y cada offset para que un cambio de esquema que inserta un campo o altera banderas ABI falle de inmediato. Como la implementación es parse pura de nivel A, cada llamada correcta cuesta el precio base publicado $0.002 sin tokens de modelo ni red saliente.
Casos de integración
Enseñanza de alineación y empaquetado
Permita que los alumnos comparen diseños naturales frente a #pragma pack y vean padding_before y trailing_padding sin compilar programas de sonda.
Preguntas técnicas
¿Cuánto cuesta la calculadora de offset de campos de struct?
La herramienta del navegador es gratuita. Las peticiones API usan saldo prepago de KIT a $0.002 por llamada correcta; la entrada inválida no se factura.