ForHosting KIT · Outils pour développeurs

Calculateur offset champs struct

Un char, un int et un autre char occupent 12 octets, pas 6 : le calculateur affiche le décalage de chaque membre, le remplissage qui le précède et celui de fin, selon les règles de votre compilateur. Gratuit dans votre navigateur.

Gratuit
Fonctionne dans votre navigateur
Sans inscription
Vos données restent sur votre appareil

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Les compilateurs C et C++ placent chaque membre d'une struct à un décalage en octets qui respecte l'alignement naturel du membre, puis rembourrent le type global pour que les tableaux de la struct restent alignés. Cette disposition est exactement ce que rapportent la macro offsetof et l'opérateur sizeof ; pourtant, compter le padding à la main entre ABI et #pragma pack produit encore des bogues silencieux dans les protocoles binaires, les liaisons FFI et les dumps mémoire. Ce calculateur d'offset de champs de struct accepte une liste ordonnée de champs avec des types scalaires C connus ou une taille et un alignement explicites, applique les mêmes règles d'arrondi vers le haut qu'un compilateur et renvoie l'offset de chaque champ, le padding précédent, la taille totale de la struct, l'alignement global et le padding final. Les valeurs pack optionnelles modélisent les structs packées ; l'abi optionnel choisit LP64, LLP64 ou ILP32 pour les largeurs de long et de pointeur.

Comment C place les champs : alignement, padding et sizeof

Pour une suite de membres dans l'ordre de déclaration le compilateur tient un curseur d'octets qui part de zéro. Avant de placer un champ il arrondit le curseur vers le haut à un multiple de l'alignement effectif de ce champ, enregistre cette adresse comme offset du champ, puis avance le curseur de la taille du champ. Les octets sautés lors de l'arrondi deviennent du padding avant le membre et ne font jamais partie du stockage propre du champ.

Après le dernier membre le compilateur peut insérer un padding final pour que la taille totale soit un multiple de l'alignement de la structure, défini comme le maximum des alignements effectifs de tous les membres. Cette taille finale est ce que renvoie sizeof, et chaque adresse enregistrée est ce que offsetof renvoie pour le nom de membre correspondant.

L'alignement naturel des scalaires suit l'ABI de la plateforme : sur les systèmes LP64 char fait un octet aligné sur un, short sur deux, int sur quatre, long et pointeur sur huit, float sur quatre, double sur huit ; LLP64 garde long à quatre tandis que les pointeurs restent à huit, et ILP32 utilise quatre pour long et pour les pointeurs. Ce calculateur encode ces tables afin que vous puissiez changer d'ABI sans réécrire les listes de champs.

Comprendre ce saut est tout l'intérêt d'un outil offsetof : dumps mémoire, formats filaires et liaisons générées doivent s'accorder avec le compilateur, et non avec une simple somme mentale des tailles.

Cas d’usage

Protocoles binaires et analyse de dumps

Confirmez l'offset en octets de chaque champ et le sizeof total avant d'écrire un décodeur filaire ou d'interpréter un dump mémoire par rapport à une struct C.

Liaisons FFI et multi-ABI

Générez ou vérifiez les dispositions LP64, LLP64 et ILP32 pour la même liste de membres afin que les liaisons natives correspondent à chaque modèle de données cible.

Questions fréquentes

Comment calculer les offsets de champs d'une struct C ?

Envoyez fields comme tableau ordonné de {name, type} (ou {name, size, alignment}).

Cela correspond-il à la macro offsetof ?

Oui pour les membres scalaires sous l'ABI choisi et la valeur pack optionnelle. Les offsets et sizeof suivent les mêmes règles de placement que les compilateurs pour les structs scalaires naturelles ou packées.

Que fait pack ?

pack modélise #pragma pack(n). Omettez pack pour la disposition naturelle (non packée).

Quels ABI sont pris en charge ?

lp64 (défaut : long et pointeur de 8 octets), llp64 (Windows 64 bits : long 4, pointeur 8) et ilp32 (long et pointeur 4).

Pourquoi le sizeof de ma struct dépasse-t-il la somme de ses membres ?

Parce que le compilateur ajoute du remplissage. Avec un char, un int et un char, trois octets sont insérés avant l'int, qui commence au décalage 4, et trois autres à la fin, pour que le total de 12 soit un multiple de l'alignement de la struct, soit 4.

Outils associés

Pour les développeurs — accès API

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

Endpoint

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

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

Appeler depuis votre 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)

Exemple de requête

{
  "fields": [
    {
      "name": "a",
      "type": "char"
    },
    {
      "name": "b",
      "type": "int"
    },
    {
      "name": "c",
      "type": "char"
    }
  ]
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.struct_field_offset",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

Tarifs

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Erreurs

HTTP	Code	Signification
`401`	`unauthorized`	Clé API absente ou invalide : vérifiez l’en-tête Authorization.
`402`	`insufficient_balance`	Solde insuffisant : rechargez votre compte pour lancer cette tâche.
`404`	`unknown_type`	Type de tâche inconnu : vérifiez le champ type de votre requête.
`429`	`rate_limited`	Trop de requêtes : ralentissez la cadence, puis réessayez.

Notes techniques

Le parcours gratuit du navigateur et l'API prépayée partagent un seul module analytique pur, de sorte que les clés d'exercices et les oracles de production ne divergent jamais. Une validation échouée lève invalid_input et n'est pas facturée.

Comment C place les champs : alignement, padding et sizeof

Lorsque deux champs adjacents n'ont pas besoin de padding, padding_before vaut zéro ; lorsqu'un char est suivi d'un int en disposition naturelle trois octets de padding apparaissent avant l'int et l'offset saute de un à quatre.

Contrat d'entrée, packing, ABI, forme de réponse et erreurs

Le pack optionnel peut valoir un, deux, quatre ou huit pour modéliser #pragma pack(n) : l'alignement effectif de chaque champ devient le minimum entre son alignement naturel et pack. Omettez pack pour la disposition naturelle non packée. L'abi optionnel vaut lp64 par défaut et peut être llp64 ou ilp32. Les membres opaques personnalisés fournissent une size entière positive et un alignment puissance de deux sans s'appuyer sur la table des types. Associez les offsets à votre propre dump ou générateur de code ; ce point de terminaison n'émet pas de source C, seulement les nombres de disposition qu'impliqueraient offsetof et sizeof. Envoyez en POST un corps JSON avec fields comme tableau non vide d'objets, chacun avec un name non vide et soit une chaîne type, soit size et alignment en octets. Les types connus incluent char, short, int, long, long long, float, double, bool, la famille à largeur fixe intN_t et uintN_t, ainsi que pointer ou size_t pour les entiers de la taille d'une adresse. Les alias members et layout sont acceptés pour le tableau. Tableaux vides, noms de type inconnus, alignments non puissance de deux, names manquants et valeurs pack hors enum échouent avec invalid_input. En cas de succès le corps inclut abi ; pack optionnel lorsque le packing est actif ; field_count ; fields avec index, name, type, size, natural_alignment, effective_alignment, offset et padding_before ; struct_size ; struct_alignment ; trailing_padding ; total_padding ; used_bytes (somme des tailles des membres uniquement) ; method c_struct_offsetof ; et une courte chaîne formula. Exemple : char a, int b, char c sous LP64 naturel donne les offsets zéro, quatre et huit avec struct_size douze et trois octets de padding interne avant b plus trois octets finaux pour que la taille soit un multiple de quatre.

Où une API d'offset de struct se justifie, tarification et limites

Les programmeurs système et les ingénieurs en rétro-ingénierie utilisent un calculateur d'offset de champs de struct pour vérifier qu'une disposition écrite à la main correspond au compilateur avant de livrer un analyseur de protocole binaire ou un dump de structure noyau. Les générateurs FFI et de liaisons ont besoin de nombres déterministes d'offsetof et de sizeof pour LP64 versus LLP64 Windows afin que la même description de schéma puisse cibler Linux, macOS et Win64 sans recompiler un programme sonde sur chaque hôte. Une validation échouée ne consomme pas de solde. Gardez les listes de champs dans le maximum publié, préférez les types nommés pour la portabilité et figez les offsets dans les tests. Les travaux pratiques sur l'alignement et le packing confient aux étudiants une liste de champs et un réglage pack ; un oracle API pur marque comme faute l'erreur courante consistant à additionner les tailles sans padding. Les suites d'intégration continue figent struct_size et chaque offset pour qu'un changement de schéma qui insère un champ ou modifie des drapeaux ABI fasse échouer les tests immédiatement. Comme l'implémentation est pure parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant.

Cas d'intégration

Enseignement de l'alignement et du packing

Permettez aux étudiants de comparer les dispositions naturelles et #pragma pack et de voir padding_before et trailing_padding sans compiler de programmes sonde.

Questions techniques

Combien coûte le calculateur d'offset de champs de struct ?

L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →

Lancer gratuitement

Comment C place les champs : alignement, padding et sizeof

Cas d’usage

Protocoles binaires et analyse de dumps

Liaisons FFI et multi-ABI

Questions fréquentes

Outils associés

Pour les développeurs — accès API

Endpoint

Appeler depuis votre stack

Exemple de requête

Exemple de réponse

Tarifs

Erreurs

Notes techniques

Comment C place les champs : alignement, padding et sizeof

Contrat d'entrée, packing, ABI, forme de réponse et erreurs

Où une API d'offset de struct se justifie, tarification et limites

Cas d'intégration

Enseignement de l'alignement et du packing

Questions techniques

merci