Struct-Feld-Offset-Rechner
Ein char, ein int und noch ein char belegen 12 Bytes, nicht 6: Der Rechner zeigt Ihnen den Offset jedes Mitglieds, das Padding davor und das am Ende, nach denselben Regeln wie Ihr Compiler. Kostenlos in Ihrem Browser.
- Kostenlos
- Läuft in Ihrem Browser
- Ohne Anmeldung
- Ihre Daten bleiben auf Ihrem Gerät
Im Browser ausführen – kostenlos
C- und C++-Compiler legen jedes Struct-Mitglied an einen Byte-Offset, der die natürliche Ausrichtung des Mitglieds einhält, und polstern den Gesamtyp anschließend so auf, dass Arrays des Structs ausgerichtet bleiben. Genau dieses Layout melden die Makros offsetof und der Operator sizeof; dennoch führt das manuelle Zählen von Padding über ABIs und #pragma pack hinweg weiterhin zu stillen Fehlern in Binärprotokollen, FFI-Bindings und Speicherabzügen. Dieser Struct-Feld-Offset-Rechner nimmt eine geordnete Feldliste mit bekannten skalaren C-Typen oder mit expliziter Größe und Ausrichtung entgegen, wendet dieselben Aufrundungsregeln wie ein Compiler an und liefert den Offset jedes Feldes, das Padding davor, die Gesamtgröße des Structs, die Gesamtausrichtung und das abschließende Padding. Optionale pack-Werte modellieren gepackte Structs; optional wählt abi LP64, LLP64 oder ILP32 für long- und Zeigerbreiten.
Wie C Felder platziert: Ausrichtung, Padding und sizeof
Für eine Folge von Mitgliedern in Deklarationsreihenfolge führt der Compiler einen Byte-Cursor, der bei null beginnt. Bevor er ein Feld platziert, rundet er den Cursor auf ein Vielfaches der effektiven Ausrichtung dieses Feldes auf, speichert diese Adresse als Feld-Offset und schiebt den Cursor um die Feldgröße vor. Beim Aufrunden übersprungene Bytes werden zu Padding vor dem Mitglied und gehören nie zum eigenen Speicher des Feldes.
Nach dem letzten Mitglied kann der Compiler abschließendes Padding einfügen, damit die Gesamtgröße ein Vielfaches der Struct-Ausrichtung ist, definiert als die maximale effektive Ausrichtung aller Mitglieder. Diese Endgröße ist, was sizeof liefert, und jede gespeicherte Adresse ist, was offsetof für den entsprechenden Mitgliedsnamen liefert.
Die natürliche Ausrichtung von Skalaren folgt dem Plattform-ABI: unter LP64 ist char ein Byte ausgerichtet auf eins, short auf zwei, int auf vier, long und Zeiger auf acht, float auf vier, double auf acht; LLP64 hält long bei vier, während Zeiger bei acht bleiben, und ILP32 nutzt vier für long und Zeiger. Dieser Rechner kodiert diese Tabellen, damit Sie das ABI wechseln können, ohne Feldlisten umzuschreiben.
Genau diesen Sprung zu verstehen ist der Sinn eines offsetof-Werkzeugs: Speicherabzüge, Drahtformate und generierte Bindings müssen mit dem Compiler übereinstimmen, nicht mit einer lockeren mentalen Summe der Größen.
Anwendungsfälle
Binärprotokolle und Dump-Analyse
Bestätigen Sie den Byte-Offset jedes Feldes und die Gesamt-sizeof, bevor Sie einen Draht-Decoder schreiben oder einen Speicherabzug gegen eine C-Struct interpretieren.
FFI- und Multi-ABI-Bindings
Erzeugen oder prüfen Sie LP64-, LLP64- und ILP32-Layouts für dieselbe Mitgliederliste, damit native Bindings jedem Zieldatenmodell entsprechen.
Häufige Fragen
Wie berechne ich C-Struct-Feld-Offsets?
Senden Sie fields als geordnetes Array von {name, type} (oder {name, size, alignment}).
Stimmt das mit dem offsetof-Makro überein?
Ja für skalare Mitglieder unter dem gewählten ABI und optionalem pack-Wert. Offsets und sizeof folgen denselben Platzierungsregeln, die Compiler für natürliche oder gepackte skalare Structs verwenden.
Was bewirkt pack?
pack modelliert #pragma pack(n). Lassen Sie pack weg für natürliches (ungepacktes) Layout.
Welche ABIs werden unterstützt?
lp64 (Standard: long und Zeiger 8 Bytes), llp64 (Windows 64-Bit: long 4, Zeiger 8) und ilp32 (long und Zeiger 4).
Warum ist sizeof meiner Struct größer als die Summe ihrer Mitglieder?
Weil der Compiler Padding einfügt. Bei char, int und char stehen drei Bytes vor dem int, der bei Offset 4 beginnt, und drei weitere am Ende, damit die Gesamtgröße 12 ein Vielfaches der Struct-Ausrichtung 4 ist.
Verwandte Tools
Für Entwickler — API-Zugang
Alles auf dieser Seite ist auch per API verfügbar. Dieser Abschnitt richtet sich an Teams, die es in ihre eigenen Systeme einbinden möchten; alle anderen nutzen einfach das Tool oben.
Endpunkt
Authentifizierung per Bearer-Token. Ein einziger POST stellt die Aufgabe in die Warteschlange; das Ergebnis erhalten Sie per Webhook oder über einen signierten Link.
Aufruf aus Ihrem 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)Beispiel-Anfrage
{
"fields": [
{
"name": "a",
"type": "char"
},
{
"name": "b",
"type": "int"
},
{
"name": "c",
"type": "char"
}
]
}Beispiel-Antwort
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.struct_field_offset",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}Die API arbeitet asynchron: Sie erhalten sofort eine task_id. Polling ist mit 1 Anfrage pro Sekunde erlaubt.
Preis
Der Preis steht auf der Seite – keine Tokens, keine Credits. Fehlgeschlagene Aufgaben werden nicht berechnet.
Fehler
| HTTP | Code | Bedeutung |
|---|---|---|
401 | unauthorized | Der API-Schlüssel fehlt oder ist ungültig – prüfen Sie den Authorization-Header (Bearer). |
402 | insufficient_balance | Ihr Guthaben reicht für diese Aufgabe nicht aus – Aufladungen verfallen nicht. |
404 | unknown_type | Unbekannter Aufgabentyp – prüfen Sie das Feld „type“ gegen den Katalog. |
429 | rate_limited | Zu viele Anfragen – warten Sie kurz; Polling ist mit 1 Anfrage pro Sekunde erlaubt. |
Technische Hinweise
Der kostenlose Browser-Pfad und die vorausbezahlte API teilen ein reines analytisches Modul, sodass Übungskeys und Produktionsorakel nie auseinanderlaufen. Fehlgeschlagene Validierung wirft invalid_input und wird nicht berechnet.
Wie C Felder platziert: Ausrichtung, Padding und sizeof
Wenn zwei benachbarte Felder kein Padding brauchen, ist padding_before null; folgt auf ein char ein int im natürlichen Layout, erscheinen drei Bytes Padding vor dem int und der Offset springt von eins auf vier.
Eingabevertrag, Packing, ABI, Antwortform und Fehler
Optionales pack kann eins, zwei, vier oder acht sein, um #pragma pack(n) zu modellieren: die effektive Ausrichtung jedes Feldes wird zum Minimum aus natürlicher Ausrichtung und pack. Lassen Sie pack weg für natürliches, ungepacktes Layout. Optionales abi ist standardmäßig lp64 und kann llp64 oder ilp32 sein. Benutzerdefinierte opake Mitglieder liefern positive ganzzahlige size und eine Zweierpotenz-Ausrichtung ohne Typentabelle. Kombinieren Sie die Offsets mit Ihrem eigenen Dump oder Codegenerator; dieser Endpunkt gibt keinen C-Quelltext aus, sondern nur die Layout-Zahlen, die offsetof und sizeof implizieren würden. Senden Sie per POST einen JSON-Body mit fields als nicht leerem Array von Objekten, jeweils mit nicht leerem name und entweder einer type-Zeichenkette oder sowohl size als auch alignment in Bytes. Bekannte Typen umfassen char, short, int, long, long long, float, double, bool, die Festbreitenfamilie intN_t und uintN_t sowie pointer oder size_t für adressenbreite Ganzzahlen. Die Aliase members und layout werden für das Array akzeptiert. Leere Arrays, unbekannte Typnamen, Ausrichtungen ohne Zweierpotenz, fehlende names und pack-Werte außerhalb des enum scheitern mit invalid_input. Bei Erfolg enthält der Body abi; optionales pack, wenn Packing aktiv ist; field_count; fields mit index, name, type, size, natural_alignment, effective_alignment, offset und padding_before; struct_size; struct_alignment; trailing_padding; total_padding; used_bytes (nur Summe der Mitgliedsgrößen); method c_struct_offsetof; und eine kurze formula-Zeichenkette. Beispiel: char a, int b, char c unter natürlichem LP64 ergeben Offsets null, vier und acht mit struct_size zwölf und drei Bytes internem Padding vor b plus drei abschließenden Bytes, damit die Größe ein Vielfaches von vier ist.
Wo eine Struct-Offset-API Nutzen stiftet, Preis und Grenzen
Systemprogrammierer und Reverse Engineers nutzen einen Struct-Feld-Offset-Rechner, um zu prüfen, ob ein handgeschriebenes Layout dem Compiler entspricht, bevor ein Parser für ein Binärprotokoll oder ein Kernel-Struktur-Dump ausgeliefert wird. FFI- und Binding-Generatoren brauchen deterministische offsetof- und sizeof-Zahlen für LP64 gegenüber Windows-LLP64, damit dieselbe Schemabeschreibung Linux, macOS und Win64 ansteuern kann, ohne auf jedem Host ein Sondenprogramm neu zu kompilieren. Fehlgeschlagene Validierung wird nicht abgerechnet. Halten Sie Feldlisten innerhalb des veröffentlichten Maximums, bevorzugen Sie benannte Typen für Portabilität und pinnen Sie Offsets in Tests. Lehrlabore zu Ausrichtung und Packing geben Studierenden eine Feldliste und eine pack-Einstellung; ein reines API-Orakel markiert den häufigen Fehler, Größen ohne Padding zu addieren, als falsch. Continuous-Integration-Suiten pinnen struct_size und jeden Offset, sodass eine Schemaänderung, die ein Feld einfügt oder ABI-Flags ändert, Tests sofort scheitern lässt. Weil die Implementierung reines Parse der Stufe A ist, kostet jeder erfolgreiche Aufruf den veröffentlichten Basispreis $0.002 ohne Modell-Tokens und ohne ausgehendes Netz.
Integrationsbeispiele
Lehre von Ausrichtung und Packing
Lassen Sie Studierende natürliche Layouts mit #pragma pack vergleichen und padding_before sowie trailing_padding sehen, ohne Sondenprogramme zu kompilieren.
Technische Fragen
Was kostet der Struct-Feld-Offset-Rechner?
Das Browser-Werkzeug ist kostenlos. API-Anfragen nutzen vorausbezahltes KIT-Guthaben zu $0.002 pro erfolgreichem Aufruf; ungültige Eingabe wird nicht berechnet.