In this post we’ll be exploring one of the most important and powerful features of the Rust programming language: Structs. Structs are a fundamental part of Rust’s type system and are used to define custom data types that can represent complex data structures. They play a crucial role in organizing code and making it more maintainable and readable.

We’ll take a closer look at what a struct is, how to define and use it, and the various ways in which it can be customized to suit your specific needs. We’ll also explore some of the advanced features of Rust’s structs, such as adding methods and implementing traits.

Like in C, in Rust, a struct is a data structure that allows you to group together related data and define your own custom data types. Here’s a comparison of C struct and equivalent definition in rust:

struct person {
    char *name;
    uint32_t age;
    bool is_student;
void main() {
    struct person john = {
        .name = "John Doe",
        .age = 30,
        .is_student = true
    printf("Name: %s\n",;
    printf("Age: %d\n", john.age);
    printf("Is student: %d\n", john.is_student);

struct Person {
    name: String,
    age: u32,
    is_student: bool,
fn main() {
    let john = Person {
        name: String::from("John Doe"),
        age: 30,
        is_student: true,
    println!("Name: {}",;
    println!("Age: {}", john.age);
    println!("Is student: {}", john.is_student);

Rust and C have similar syntax for defining structs, but there are some key differences between the two.
First difference is how they handle method calls. In C, structs do not have methods, so you must use functions that take a pointer to the struct as an argument. In Rust, structs can have methods defined directly on them, which allows for a more object-oriented style of programming.

Secondly, Rust’s struct system is more flexible than C’s. Rust’s struct system allows for the definition of “tuple structs” and “unit structs”, which don’t have named fields. This allows for more flexibility in defining custom data types. Additionally, Rust’s struct system has the concept of “derived traits”, which allows for the automatic implementation of certain traits like Eq, Ord, and Debug based on the struct’s fields.

We will learn rust sturcts by building a simple tool to dump ELF headers. Similar to what the command readelf -h does.

$ readelf -h ./a.out
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:                             ELF64
  Data:                              2's complement, little endian
  Version:                           1 (current)
  OS/ABI:                            UNIX - System V
  ABI Version:                       0
  Type:                              DYN (Position-Independent Executable file)
  Machine:                           Advanced Micro Devices X86-64
  Version:                           0x1
  Entry point address:               0x1060
  Start of program headers:          64 (bytes into file)
  Start of section headers:          13976 (bytes into file)
  Flags:                             0x0
  Size of this header:               64 (bytes)
  Size of program headers:           56 (bytes)
  Number of program headers:         13
  Size of section headers:           64 (bytes)
  Number of section headers:         31
  Section header string table index: 30

Quick intro to ELF – The ELF (Executable and Linkable Format) file format is used in most Unix-like operating systems, including Linux. It serves as a standard file format for executables, shared libraries, and object code. The ELF file format consists of several sections, including the header, the program headers, the section headers, and the sections themselves. The header provides information about the type of file and its architecture. We will print the header in human readable format. You can read more above the ELF file format from the ELF specification

Here is a C program to print the first two lines of readelf -h.

#include <stdint.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <elf.h>
#include <errno.h>

/*  The following are defined in elf.h; added in this comment for quick reference.
#define EI_NIDENT 16

typedef uint64_t	Elf64_Addr;
typedef uint16_t	Elf64_Half;
typedef uint64_t	Elf64_Off;
typedef int32_t		Elf64_Sword;
typedef int64_t		Elf64_Sxword;
typedef uint32_t	Elf64_Word;
typedef uint64_t	Elf64_Lword;
typedef uint64_t	Elf64_Xword;

typedef struct {
        unsigned char   e_ident[EI_NIDENT];
        Elf64_Half      e_type;
        Elf64_Half      e_machine;
        Elf64_Word      e_version;
        Elf64_Addr      e_entry;
        Elf64_Off       e_phoff;
        Elf64_Off       e_shoff;
        Elf64_Word      e_flags;
        Elf64_Half      e_ehsize;
        Elf64_Half      e_phentsize;
        Elf64_Half      e_phnum;
        Elf64_Half      e_shentsize;
        Elf64_Half      e_shnum;
        Elf64_Half      e_shstrndx;
} Elf64_Ehdr;
bool is_valid_elf_header(Elf64_Ehdr *header) {
    return header->e_ident[0] == 0x7f &&
            header->e_ident[1] == 'E' &&
            header->e_ident[2] == 'L' &&
            header->e_ident[3] == 'F'

void print_elf_magic(Elf64_Ehdr *header) {
    int i;

    printf("  Magic:   ");
    for (i=0; i < sizeof(header->e_ident); i++)
        printf("%02x ", header->e_ident[i]);

void print_elf_class(Elf64_Ehdr *header) {
    printf("  Class:   ");
    switch (header->e_ident[EI_CLASS]) {
        case ELFCLASS32:
        case ELFCLASS64:

int print_elf_header(char *file_path) {
    int fd, len;
    Elf64_Ehdr header;

    fd = open(file_path, O_RDONLY);
    if (fd == -1) {
        fprintf(stderr, "unable to open file %s: ", file_path);
        return errno;
    len = read(fd, &header, sizeof(header));
    if (len != sizeof(header)) {
        fprintf(stderr, "unable to read file %s: ", file_path);
        return -1;

    if (!is_valid_elf_header(&header)) {
        fprintf(stderr, "Not a ELF file");
        return -2;
    printf("ELF Header:\n");
    return 0;

int main(int argc, char *argv[]) {
    if (argc <= 1) {
        printf("Usage : %s \n", argv[0]);
        return -1;
    return print_elf_header(argv[1]);

If we compile and run this program, it print the Magic and Class of the ELF.

$ gcc elf_info.c -o elf_info
$ elf_info ./elf_info
ELF Header:
  Magic:   7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 
  Class:   ELF64

Lets convert this program into Rust and see how struct advanced in Rust.

use std::env;
use std::io::Read;

const EI_NIDENT:usize = 16;
const EI_CLASS:usize = 4;

type Elf64Addr = u64;
type Elf64Half = u16;
type Elf64Off = u64;
type Elf64Word = u32;

const ELFCLASSNONE:u8 =	0;
const ELFCLASS32:u8 = 1;
const ELFCLASS64:u8 = 2;

struct Elf64Ehdr {
        e_ident: [u8; EI_NIDENT],
        e_type: Elf64Half,
        e_machine: Elf64Half,
        e_version: Elf64Word,
        e_entry: Elf64Addr,
        e_phoff: Elf64Off,
        e_shoff: Elf64Off,
        e_flags: Elf64Word,
        e_ehsize: Elf64Half,
        e_phentsize: Elf64Half,
        e_phnum: Elf64Half,
        e_shentsize: Elf64Half,
        e_shnum: Elf64Half,
        e_shstrndx: Elf64Half,

impl Elf64Ehdr {
    fn is_valid_elf_header(&self) -> bool {
        self.e_ident[0] == 0x7f &&
        self.e_ident[1] == b'E' &&
        self.e_ident[2] == b'L' &&
        self.e_ident[3] == b'F'

impl std::fmt::Display for Elf64Ehdr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "ELF Header:");
        write!(f, "ELF Header:")

fn print_elf_magic(header: &Elf64Ehdr) {
    print!("  Magic:   ");
    for b in header.e_ident {
        print!("{b:02x} ");

fn print_elf_class(header: &Elf64Ehdr) {
    print!("  Class:   ");
    if header.e_ident[EI_CLASS] == ELFCLASS32 {
    } else if header.e_ident[EI_CLASS] == ELFCLASS64 {
    } else {
        println!("Invalid class");

fn read_elf_header_from_file(file_path: &String) -> Elf64Ehdr {
    let mut file = std::fs::File::open(file_path).unwrap();
    let header: Elf64Ehdr = {
        let mut h = [0u8; std::mem::size_of::()];

        file.read_exact(&mut h[..]).unwrap();

        unsafe { std::mem::transmute(h) }

fn print_elf_header(file_path: &String) {
    let header = read_elf_header_from_file(file_path);
    if !header.is_valid_elf_header() {
        eprintln!("Not a ELF file");
    println!("{}", header);
    println!("ELF Header:");

fn main() {
    let args: Vec<_> = env::args().collect();

This article can be viewed as video here

Categorized in:

Tagged in: