Academic Databases
Explore Our Semantic Databases
STEM & Tech
Math, Physics, CS & Engineering...
Economics
Macro, Micro, Econometrics...
Business
Management, Marketing, Finance...
Health & Life Sciences
Biology, Medicine, Neuroscience...
Humanities & Social Sciences
Psychology, Law, Philosophy, History...
General Studies
General & interdisciplinary studies...
Explore Topics
Features

C Struct Serialization to Files in C Programming

Added: 2026-08-07

Deep Dive

Understanding of C structures (structs), including how to define them, access members, and allocate memory for them.

C structs 🏠

C structs 🏠

334.8K

A struct (short for structure) is a fundamental data structure in C that groups related members of potentially different data types into a single unit under one name, stored in contiguous memory. Structs are similar to classes in object-oriented languages but lack methods—containing only member variables. To define a struct, use 'struct' followed by a tag name, curly braces enclosing member declarations, and a semicolon. Members can include various data types like character arrays and integers. Variables of the struct type are declared using 'struct tag_name variable_name', creating separate memory blocks for each instance. Access members using the dot operator (.), and for character arrays, use strcpy() for assignment. Display members with appropriate format specifiers in printf(). Each struct instance maintains its own unique memory block with independent member values.

Click to watch →

Structs - Aula 18

Structs - Aula 18

476

Structs in C are user-defined data types that combine multiple variables of different types into a single unit, enabling organized data storage. To define a struct, use the 'struct' keyword with curly braces containing member variables. Create instances by declaring variables of that type and access members using the dot operator. Structs allocate memory for all members at once, with total size equal to sum of member sizes plus overhead. When passing structs to functions, two approaches exist: pass-by-value creates a copy (changes don't affect original), while pass-by-reference uses pointers with '&' operator to access original memory. For pointer access, use the arrow operator ('->') instead of dot operator. Understanding these fundamentals is essential for effective C programming.

Click to watch →

Structures in C

Structures in C

135

C programming has three data types: primitive (integers, floats, characters), derived (arrays, pointers, strings), and user-defined (structures, unions, enumerations). Structures combine different data types logically related to one group, solving array limitations. A structure is defined using 'struct' keyword with a tag name and member declarations. After definition, variables are declared using 'struct tagname varname'. Each structure variable allocates memory for all members (e.g., 24 bytes for name[20], roll_number, marks). Structure members cannot be accessed directly; they require the dot operator (.) for member access.

Click to watch →

Estruturas de Dados - Struct

Estruturas de Dados - Struct

363

This section covers struct basics in C/C++. A struct (estrutura) is a heterogeneous data container that can hold different types of data (integers, characters, vectors) in a single unit. Structs must be declared with lowercase names. The declaration defines the format (formato) including member types and names, but does not allocate memory. Memory is only allocated when you create an instance using the struct name. Struct members are accessed using the dot operator (e.g., lista1.a = 5). This encapsulation allows organizing complex data hierarchically.

Click to watch →

Unit 55.2 구조체 안의 구조체 멤버에 메모리 할당하기

Unit 55.2 구조체 안의 구조체 멤버에 메모리 할당하기

2.6K

In C programming, when allocating memory for struct members dynamically, use malloc() with sizeof() to allocate memory, access members through the arrow operator (->) for pointer members and dot operator (.) for regular variables, and when deallocating nested struct pointers, always free the inner members first to prevent memory access violations.

Click to watch →

Deep Dive

Basic file handling (I/O) in C, specifically opening, writing to, reading from, and closing files using functions like fopen, fclose, and fprintf.

C Final | Konu Anlatımı

C Final | Konu Anlatımı

1K

File handling uses FILE* pointers and <stdio.h>. fopen() opens files with modes: 'r' (read), 'w' (write/create), 'a' (append). fprintf() writes formatted data to files. fgets() reads lines into buffers (buffer, size, fp). fclose() closes files and flushes buffers. Always close files after use. File handling enables programs to read/write data to external files, essential for data persistence and file-based applications.

Click to watch →

Introduction to Files in C || easy programming || #programming || #file handling functions ||#files

Introduction to Files in C || easy programming || #programming || #file handling functions ||#files

106

C provides built-in file handling functions prefixed with 'f'. fopen() opens files, fclose() closes them. fgetc() reads single characters, fputc() writes single characters. fgets() reads lines of text, fputs() writes lines of text. fscanf() reads formatted data, fprintf() writes formatted data. fread() reads binary data, fwrite() writes binary data. These functions enable comprehensive file input/output operations in C programs.

Click to watch →

How to Create, Read and Write to a File in C Programming

How to Create, Read and Write to a File in C Programming

63K

This comprehensive tutorial covers file handling in C programming, covering both theoretical foundations and practical implementation. Key topics include: understanding stream-oriented versus system-oriented data files, mastering the five essential file operations (creation, opening, reading, writing, closing), learning the four-step processing workflow (declare FILE pointer, open with fopen(), process with appropriate functions, close with fclose()), and becoming proficient with standard library functions including fopen(), fclose(), fgetc(), fputc(), fscanf(), fprintf(), fgets(), fputs(), and feof(). Practical demonstrations show how to write text to files using fprintf() and read file contents using fgets(), providing complete working examples for beginners to understand file I/O operations in C programming.

Click to watch →

#66 C Programming File Handling Bangla Tutorial

#66 C Programming File Handling Bangla Tutorial

2.9K

File handling in C programming involves using the stdio.h header file to perform operations like opening, closing, creating, reading, and writing files through functions such as fopen(), fclose(), fgetc(), fputc(), fscanf(), fprintf(), fgets(), and fputs(), with file pointers declared using FILE *filename; and file operations controlled by mode strings like 'r', 'w', 'a', 'rb', 'wb', and 'ab'.

Click to watch →

Files_Unit 5 ✔✔✔

Files_Unit 5 ✔✔✔

149

File handling in C programming involves storing and retrieving data using file pointers (FILE *fp) with four key operations: fopen() to open files with modes (r, w, a, r+, w+, a+ for text files or rb, wb, ab, rb+, wb+, ab+ for binary files), fclose() to close files, fprintf() to write data to files, and fscanf() to read data from files, with sequential access reading from the beginning and random access allowing direct file position seeking.

Click to watch →

Deep Dive

Familiarity with pointer concepts and memory representation in C, as serialization involves manipulating raw memory blocks and data addresses.

Operações com endereços de memória (Ponteiros) em C

Operações com endereços de memória (Ponteiros) em C

2.4K

Pointers are the most challenging topic in C programming, typically introduced at the end of courses. Despite being intimidating, pointers represent the greatest power of C, enabling direct memory manipulation essential for high-performance programs. Memory can be represented by addresses and content stored at each address. Each variable is associated with a specific memory address, and using a variable means manipulating its associated memory portion. The address-of operator (&) returns the memory address of a variable. Memory addresses can be printed using the %p format specifier. Pointer variables are declared using the asterisk (*) operator, such as 'int *p', which declares a variable that will store memory addresses. Pointers can store memory addresses in their memory location by assigning the address-of operator result to the pointer. The indirection operator (*) accesses the content at a memory address, allowing modification of values at those locations.

Click to watch →

PF Lecture # 10: Pointers in C/C++

PF Lecture # 10: Pointers in C/C++

320

A pointer is a special variable type that stores memory addresses of other variables. Unlike regular variables that store data values, pointers store addresses. Memory addresses are always positive numbers, so pointers store unsigned addresses. The size of a pointer depends on the operating system architecture: 32-bit systems use 4-byte pointers (addressing up to 4GB RAM), while 64-bit systems use 8-byte pointers (addressing terabytes of memory). Memory addresses are stored in binary format but represented in hexadecimal notation for readability, using the '0x' prefix. Each hexadecimal digit represents 4 binary bits, making large addresses easier to read and write.

Click to watch →

2. Углублённое программирование на C/С++. Память в C++

2. Углублённое программирование на C/С++. Память в C++

38.2K

A pointer is a variable storing a memory address, enabling CPU to read/write specific locations. The null pointer (nullptr) represents invalid addresses. Pointer size depends on architecture: 4 bytes on 32-bit, 8 bytes on 64-bit systems. The 'void*' type is generic, pointing to any data type without specifying the target. Pointer dereferencing (*) retrieves the value at the address, while address-of (&) retrieves the variable's address. Pointer arithmetic adds/subtracts based on the pointed-to type's size, not raw bytes. The 'ptrdiff_t' type should be used for pointer differences to guarantee sufficient size.

Click to watch →

Pointers - CS50 Shorts

Pointers - CS50 Shorts

229.9K

Pointers are fundamental C concepts enabling data passing between functions that regular variables cannot achieve. In C, all data is passed by value (copies), meaning function changes don't affect original variables. Pointers solve this by accessing actual memory locations. Memory consists of hard drives (permanent storage) and RAM (volatile working memory). All programming occurs in RAM, which is destroyed when the computer turns off. Memory is organized as byte-sized cells with unique addresses. Different data types require different sizes: integers (4 bytes), characters (1 byte), floats (4 bytes), doubles (8 bytes). Pointers are memory addresses themselves, declared with types like 'int* pk'. The & operator extracts addresses, and pointers can be visualized as arrows pointing to memory locations.

Click to watch →

Desmistificando pointers em C | #devadev com Daniel Ferreira

Desmistificando pointers em C | #devadev com Daniel Ferreira

22.9K

Pointers are essential for memory handling in C and its derivatives. Using a city analogy: houses represent memory addresses, residents represent values. The address is fixed, but the resident (value) can change. Pointers are variables storing memory addresses, declared with an asterisk (e.g., 'int *'). The dereference operator (*) retrieves values at addresses, while the address-of operator (&) retrieves addresses of variables. Memory allocation uses malloc to request blocks at runtime. Pointers enable passing values by reference, allowing functions to modify original variables. Arrays are contiguous memory blocks where indexing is equivalent to pointer arithmetic. C strings are null-terminated character arrays.

Click to watch →

Deep Dive

The difference between text-based (ASCII) data representation and binary data representation in computer memory.

Prof. Dr. Boesnecker Digitaltechnik 1 Teil 4 V2.0

Prof. Dr. Boesnecker Digitaltechnik 1 Teil 4 V2.0

10.1K

Computers store all data as binary numbers (bits). Text characters are stored as ASCII codes: 'D' is hex 44, 'i' is hex 69. Line breaks are represented by CR (hex 0D) and LF (hex 0A). Computers do not inherently understand letters, music, or images—they only work with binary numbers. The meaning of stored data is assigned through encoding standards like ASCII. This principle applies to all digital devices including smartphones, tablets, and embedded systems.

Click to watch →

INFM 109 Data Representation - ASCII

INFM 109 Data Representation - ASCII

1.2K

Textual data is represented in computers through ASCII encoding, where each character corresponds to a specific decimal value (e.g., 'I' = 73, 'V' = 118, 'Y' = 121), and the computer stores the binary equivalent of these decimal ASCII values rather than the decimal numbers themselves; for example, the decimal value 73 converts to the binary 01001001, allowing all text to be represented as streams of ones and zeros.

Click to watch →

04.05. Streams and File System (Курс Основы .NET)

04.05. Streams and File System (Курс Основы .NET)

400

Binary data preserves the exact memory representation of values (e.g., a byte takes 1 byte, a long takes 8 bytes), while text representation uses human-readable characters. Text representation requires encoding (like UTF-8) and may include additional metadata (like string length). Binary data is more compact but less portable across systems with different endianness or character encodings.

Click to watch →

9. Memory and Data Units - Data .2 - ICT | December 2023 UGC NET Paper 1 | Bharat Kumar

9. Memory and Data Units - Data .2 - ICT | December 2023 UGC NET Paper 1 | Bharat Kumar

127.8K

Data in computers is fundamentally represented in binary form using only two digits: 0 and 1. This binary representation applies to all types of data including images, songs, videos, and text. Unlike humans who have multiple communication tools like alphabets and decimal numbers, computers are limited to only two states (0 and 1) for representing all data. Data storage units follow a hierarchical structure based on powers of 2: kilobyte (KB) = 1024 bytes (2^10), megabyte (MB) = 1024 KB (2^20), gigabyte (GB) = 1024 MB (2^30), terabyte (TB) = 1024 GB (2^40), petabyte (PB) = 1024 TB (2^50), exabyte (EB) = 1024 PB (2^60), zettabyte (ZB) = 1024 EB (2^70). Each unit is 1024 times larger than the previous one. Computers have a memory hierarchy: Registers (smallest, fastest), Cache Memory (megabytes), RAM (gigabytes), and Hard Disk/SSD (gigabytes or terabytes). The trade-off is that faster memory has smaller capacity, while slower memory has larger capacity. ASCII (American Standard Code for Information Interchange) is a character encoding standard that assigns binary codes to characters. Each character (letters, numbers, symbols) is represented by exactly 8 bits, allowing for 256 different characters (2^8 = 256). The standard was developed by the American Standards Institute (ANSI) and is used universally across different operating systems and devices. Uppercase letters start at code 65 (A), lowercase letters start at code 97 (a), and numbers start at code 48 (0). To convert a character to its ASCII binary code, find its decimal value first, then convert that decimal number to binary.

Click to watch →

Introduction à l'encodage de caractère de l'ASCII à l'UNICODE UTF-8

Introduction à l'encodage de caractère de l'ASCII à l'UNICODE UTF-8

1.6K

Binary data is a sequence of bytes representing raw information that software handles automatically. Text data, while also a sequence of bytes, has a special meaning assigned to it for human visual interpretation. The key difference is that text data is interpreted to display visual characters (glyphs) rather than being processed as raw binary information.

Click to watch →

Serialization Basics

File Opening

Format Definition

Cursor Reset

Deserialization Setup

Data Validation

Format Flexibility

Format Matching

Serialization Basics

0:00

Playing Section

1
Introduces serialization as saving in-memory data to files.
2
Defines a 'Person' struct with name, age, and gender fields.
3
Initializes a struct variable with values for demonstration.

Deep Dive

Deep dive into binary serialization using fwrite and fread, including handling compiler padding, struct alignment, and '#pragma pack'.

SDP on Foundations of Programming using C - Day 13

SDP on Foundations of Programming using C - Day 13

712

Binary I/O uses fread and fwrite for raw data transfer without formatting, offering superior speed for structures, arrays, databases, and images. Critical considerations include: always use sizeof() instead of hardcoded sizes, maintain consistent structure layouts between programs, avoid padding mismatches using #pragma pack, never store pointers (become invalid across runs), use binary modes exclusively, and avoid dynamic arrays. Endianness (little-endian vs big-endian) causes binary files written on one architecture to fail on others. Safe cross-platform sharing requires byte-order conversion or same-platform operations. Binary I/O with structures uses fwrite and fread with sizeof(structure) for efficient serialization.

Click to watch →

C ile Programlamaya Giriş 10 : Dosyalar (File)

C ile Programlamaya Giriş 10 : Dosyalar (File)

80.2K

This section covers fread() and fwrite() for binary data and structured data I/O. fread() and fwrite() read/write binary data from/to files. Syntax: fread(buffer, size, count, file_pointer) reads 'count' items of 'size' bytes each into 'buffer'. fwrite(buffer, size, count, file_pointer) writes 'count' items of 'size' bytes each from 'buffer'. These functions are used for reading/writing complex data structures (structs) directly to files, preserving exact byte representation. The instructor demonstrates reading a struct (character array) from a file using fread() and writing a struct to a file using fwrite(). fread() reads exactly the specified number of items into the buffer, regardless of how much data remains in the file. For large files (like videos or databases), loading the entire file into RAM is impractical. Buffer management involves reading/writing chunks of data at a time, processing each chunk, then reading the next chunk. This technique (double buffering) allows processing large files efficiently without requiring all data in memory.

Click to watch →

Binary Files | Starter C++ Programming, Ch. 12C

Binary Files | Starter C++ Programming, Ch. 12C

612

Fixed-length structures can be efficiently serialized to binary files as single units using read() and write() functions, processing entire structures in one operation rather than individual members. The syntax involves casting the structure address to char* and specifying sizeof(structure). However, this method has limitations: it fails with C++ string objects (dynamic memory) and structures containing pointers. Compilers automatically add padding bytes to structures to align data on memory addresses divisible by data type sizes, improving CPU efficiency. For example, a 51-byte char array followed by a 4-byte int receives one padding byte so the int starts at address 52. This causes structure sizes to exceed simple member sum calculations. Always use sizeof() to determine actual byte counts.

Click to watch →

Learn to program with c - Part 15 - Files

Learn to program with c - Part 15 - Files

4.3K

fwrite and fread handle binary data by reading/writing raw memory blocks. fwrite takes a void pointer to source data, object size in bytes, number of objects, and file pointer. The object size and count together determine total bytes written. fwrite returns objects successfully written, enabling error detection. fread mirrors this for reading binary data into memory. These functions are essential for writing structures, arrays, or arbitrary memory blocks to files. For example, writing 50 pixel structures (each 4 bytes) uses sizeof(pixel) as object size and 50 as count. fread returns objects successfully read, allowing detection of read errors or premature file endings. The file structure contains an internal position pointer that advances during reads and can be moved using fseek for random access.

Click to watch →

✌🍮FILE HANDLING (PART5) fread() fwrite() ✌🍮

✌🍮FILE HANDLING (PART5) fread() fwrite() ✌🍮

303

Binary mode differs from text mode, used for audio, video, and picture files. The fwrite() function writes binary data with syntax: fwrite(void *buffer, int size, int count, FILE *fp). Parameters include buffer (memory address), size (bytes per element), count (number of elements), and fp (file pointer). fwrite() can write single variables, entire arrays, partial arrays, structure variables, arrays of structures, and partial arrays of structures. The fread() function reads binary data with syntax: fread(void *buffer, int size, int count, FILE *fp). fread() can read the same data types. A complete program demonstrates writing and reading employee records: include stdio.h, define structure employee, declare variables, open file in 'wb' mode for writing and 'rb' mode for reading, check for null file pointer, get user input, call fwrite() to write records, use while loop with fread() to read records, print records, close file. fread() returns 1 until end of file, then returns value less than 1 when end of file is encountered. The sizeof operator automatically calculates the size in bytes, keeping the program unchanged even if structure elements change.

Click to watch →

Deep Dive

Exploring endianness and network byte order to ensure serialized binary files are portable across different CPU architectures.

Dealing with Endianness Issues in your Programs

Dealing with Endianness Issues in your Programs

29.2K

Endianness refers to the byte order used to store multi-byte integers in memory, where big-endian stores the most significant byte first and little-endian stores the least significant byte first; when transferring binary data between machines with different endianness, data interpretation becomes incorrect, so developers must use standard network byte order (big-endian) or platform-provided conversion functions like htonl() and ntohs() to ensure consistent data interpretation across different architectures.

Click to watch →

Byte Order (Endianness)

Byte Order (Endianness)

25K

Byte order, or endianness, refers to the way computers store multi-byte data in memory, with big-endian format storing the most significant byte at the lowest memory address and little-endian format storing it at the highest address; while both formats function equally well in modern 64-bit systems, big-endian is mandated for network data transmission (network byte order) to ensure consistent data exchange between different computer architectures.

Click to watch →

the TRUTH about numbers and network programming (endianess or ELSE)

the TRUTH about numbers and network programming (endianess or ELSE)

85.8K

Endianness refers to the byte order used to store multi-byte data types in memory, where little-endian systems store the least significant byte first and big-endian systems store the most significant byte first; when sending data over networks between systems with different endianness, programmers must convert data to network byte order (big-endian) using functions like htonl() and ntohl() to ensure correct interpretation across all platforms.

Click to watch →

Little Endian Vs Big Endian | C Programming Language| Endianness

Little Endian Vs Big Endian | C Programming Language| Endianness

3K

Endianness matters when reading/writing data through files or network streams, communicating with hardware devices, working with binary data like images or audio files, and using languages supporting multiple endianness like Java and C++. A simple C program can identify system endianness by storing a hexadecimal value in a character variable. When performing typecasting, endianness affects results. Network byte order (Big Endian) is the standard for network communication. Functions like htons, htonl, ntohs, and ntohl ensure portability by converting between host and network endianness.

Click to watch →

엔디안(Endian) 이야기 | 빅엔디안 | 리틀엔디안

엔디안(Endian) 이야기 | 빅엔디안 | 리틀엔디안

5.2K

Endian refers to the byte order in which multi-byte data is stored in computer memory, with Big Endian storing the most significant byte at the lowest memory address (e.g., 0x1234 stored as 0x12, 0x34) and Little Endian storing the least significant byte first (e.g., 0x1234 stored as 0x34, 0x12). While different CPU architectures like SPARC/Motorola use Big Endian and x86/Intel use Little Endian, network communication requires a standardized byte order to prevent data corruption between devices with different architectures. The networking community standardized on Big Endian as the network byte order, requiring developers to convert data between host and network byte order using functions like htons() and htonl() for 2-byte and 4-byte values respectively.

Click to watch →

Deep Dive

Integrating external C libraries for advanced data interchange formats, such as cJSON, Jansson, or Protocol Buffers.

WICED Wi-Fi 101: Lesson 4-2 JSON Parser

WICED Wi-Fi 101: Lesson 4-2 JSON Parser

334

To use CJSON in a project, add one line to the Makefile to include the library functions. In the C file, include 'cjson.h' to bring all APIs into the project. A constant character array holds the JSON data, which would normally be received from the cloud but can be hardcoded for testing purposes.

Click to watch →

Programming Lifestyle App in C From Scratch (pt. 17)

Programming Lifestyle App in C From Scratch (pt. 17)

124

JSON (JavaScript Object Notation) can be used as a data format in C applications through libraries like cJSON. JSON provides a structured way to store and manipulate data that is easier to read and write than raw text files. The developer considers switching from custom text file formats to JSON for better data management, though this requires learning a new library and potentially restructuring existing code.

Click to watch →

"High-Performance Web-Services mit C/C++" von Maximilian Haupt

"High-Performance Web-Services mit C/C++" von Maximilian Haupt

316

JSON libraries differ in their implementation approaches: (1) nlohmann/json uses STL containers and is very fast but has a simpler interface, (2) RapidJSON is also very fast and uses zero-copy techniques, (3) jansson (C library) is slower but has a simpler interface. The choice depends on the specific requirements of the application - some prioritize speed, others prioritize ease of use or cross-platform compatibility.

Click to watch →

ep22.2 - Intro to Protocol Buffers (protobuf)

ep22.2 - Intro to Protocol Buffers (protobuf)

2.1K

Protocol Buffers are Google's language-neutral binary serialization format designed for efficient message exchange. Unlike Gob (Go-specific), Protocol Buffers enable interoperability across programming languages. Key benefits include: common message exchange description regardless of language, fast encoding/decoding for high-performance systems, space efficiency by not sending field names (using numbers instead), and simple readability compared to SOAP/XML/IDL. Google developed Protocol Buffers for microservices exchanging billions of messages daily. To use Protocol Buffers, install the Protocol Buffers compiler (protoc) for your operating system. For Go code generation, you must also install the Go plugin separately. The compiler supports generating code for C++, C#, Java, JavaScript, Objective-C, PHP, Python, Ruby, and Go.

Click to watch →

Protocol Buffers Crash Course

Protocol Buffers Crash Course

290K

Protocol Buffers (Protobuf) is a method of serializing structured data that provides a compact binary format for transmitting data over networks or storing it on disk, achieved through a schema-defined approach that enforces data structure consistency across different programming languages; unlike JSON which is unstructured and allows any data format, Protobuf requires defining a .proto file that specifies message structures with field types and numbers, which is then compiled into language-specific code using the protoc compiler, resulting in significantly smaller data sizes (e.g., 52 bytes vs 125 bytes for three employees) but requiring additional setup and maintenance overhead compared to simple JSON serialization.

Click to watch →

Deep Dive

Applying serialization in networking concepts, such as marshalling data payloads for socket communication between client and server applications.

Part 1 Programmation réseaux par Sockets By Mohamed Youssfi

Part 1 Programmation réseaux par Sockets By Mohamed Youssfi

75.2K

To exchange objects between client and server, use ObjectInputStream and ObjectOutputStream. The sending side uses writeObject() to convert an object to bytes, and the receiving side uses readObject() to reconstruct the object. Objects must implement Serializable interface.

Click to watch →

Tema 2 - Sockets - parte 3

Tema 2 - Sockets - parte 3

285

Java serialization converts objects into byte sequences for network transmission or file storage. Objects must implement the Serializable interface (which contains no methods to implement) to be serializable. All attributes must be of serializable types (primitives, Strings, or other serializable objects). To send objects, wrap the socket's OutputStream with ObjectOutputStream and use writeObject(). To receive objects, wrap the InputStream with ObjectInputStream and use readObject(). The transient keyword marks attributes that should not be serialized, useful for sensitive data or non-serializable references.

Click to watch →

Видео курс C# Professional. Урок 8. Сериализация

Видео курс C# Professional. Урок 8. Сериализация

19.8K

The instructor explains that marshaling/demarshaling is used for inter-level communication, such as between a client computer and a server. Microsoft refers to these as different 'levels' (not layers). This terminology is used in Microsoft's architecture documentation. The instructor notes that this will be covered in more detail in a separate course on architecture.

Click to watch →

Разработка MVC приложения на Java за два часа | Компьютерная школа Hillel

Разработка MVC приложения на Java за два часа | Компьютерная школа Hillel

212.4K

There is a mechanism that transforms the Front-end model into the Backend model, called serialization. This process involves converting data between client and server formats. The serialized data is constantly passed between the client and server parts of the application, enabling communication and data exchange.

Click to watch →

socket external data representation marshling

socket external data representation marshling

208

Socket communication enables client-server interaction through IP addresses and port numbers, using stub and skeleton objects for remote method invocation. Stub objects on the client side initiate connections, marshal parameters, transmit data, and unmarshal responses, while skeleton objects on the server side read parameters, invoke remote methods, and transmit results. External data representation converts structured data into byte formats for transmission, using marshalling to assemble data and unmarshalling to reconstruct it. Common marshalling techniques include CORBA, Java object serialization, and JSON, with data transmitted in either big-endian or little-endian byte order.

Click to watch →

Serialization Basics

File Opening

Format Definition

Cursor Reset

Deserialization Setup

Data Validation

Format Flexibility

Format Matching

Serialization Basics

0:00

Playing Section

1
Introduces serialization as saving in-memory data to files.
2
Defines a 'Person' struct with name, age, and gender fields.
3
Initializes a struct variable with values for demonstration.

81.8K views1.9K14:40@CodeVaultOriginal Release: 2020-04-21

Serialization is the process of converting structured data (like structs in C) into a file format that can be stored and later reconstructed. In C, this is achieved using fprintf() with format strings to write struct members to a file, and fscanf() with corresponding format strings to read them back, while managing file operations with fopen() and fseek() to properly handle file positioning.

[00:00:00]in today's video we'll take a look at the serialization says they shouldn't read the process of taking something that is in memory so basically the value for valuable office of a variable that is a struct that is a class for whatever saving it to a file in a certain format and using the same format to be able to read that data and put it back into a variable okay so this is what we're gonna do here first let's have some data let's create a structure that we want to write to the file here we're gonna create a struct or type def struct to say person just wants a person a person should have let's say want a name twenty characters should be enough for most people in age and then char general here so that's going to be either M or M and of course your person to finish up the definition of our type now let's declare here a person variable person P 1 equals I'm gonna actually initialize them like so and I say P 1 right it's going to have the values that are typed in here and in here I'm gonna type in the value for the name right so this is going to set the name value from within the struct which is I think pretty nice and you can set it using the equals sign something that you usually cannot do with these types of strings ok and dot name equals let's say Andrew why not age is I don't know 22 and gender is male okay so what we want to do is to save this to a file first let's open that file so that we are able to save it I'm gonna use F open underscore s for my program you can use F open it's more as the same thing except instead of passing in the first parameter that is the the path to the file you actually pass in here a reference to where you want to save the file handler but only known it's actually the same thing so here I can say file this is our file handler and here I'm going to pass a reference to it so double pointer to file the file name and call it people dot P 12.8 e and we're going to open it with W plus this W plus I will talk about this in a previous video which you can check up top this double pass is basically a way of saying open this file but let me read and write to it right just going to allow me to do both above these operations okay so now as it's open let's check if it actually is something so if file is no I'm just going to return one and that's going to be the end of it so that's going to return out the main function and it's gonna be something basically if you return something different than zero that means that it's an error code so there's that next let's try to write this structure to the file how do we do that well there's a function called F print F let me use again underscore s here but you can use just a normal one first we take in the streams or the file then we take in a format now the format it's like in printf the same exact thing that format well we should actually save it somewhere sort of in a variable because if you want to serialize this destruct in many places in your program it's going to be very easy to change just how you're going to serialize it in the file itself so here I can say or actually I'm gonna say it above this type def const char pointer let's call it something like person for mapped out by the way out because we're using it to print out to the file and this guy's going to have the value well it's going to be the format for that for this struct and we can decide on whatever format we want I'm just going to use a simple topper with parentheses here and say well first is going to be the names of % s then a comma then the age % D then a comma and then the gender so % C and that's it and a backslash n at the end it just so that we have a simple a clean line here and we don't add many structures on the same line ok next we need to use this so I'm going to say Paulsen format out then we have to pass in the parameters in the order that we have passed in in here of course so we're gonna say first P 1 dot name P 1 dot H and P 1 dot gender okay at the first step so now that we written it to the file we can also read it but due to the fact that we're using w+ we have to first move the cursor so the cursor cursor is sort of a position at which it should read or write all right into a file right and right now our position or course is not at position 0 it wrote some characters and it's at position something like 26 I believe or something a lot so do that we have to change it back to 0 so that we can read the same line that we wrote here to do that we just have to say F seek file someone to F seek the file want to set up set to 0 and the origin to be sick set that says to the beginning and the difference between the beginning and where we wanted to set is 0 so we want to set it at the beginning so next let's DC realize this data right so we want to get this data and store it inside in other variables so let me define first here a third son p2 and this is where we want to save the data and if I want to read I have to use a can of function at least if one to read using a format string some people don't actually recommend using scanf but for this in this situation I think it's a very fit solution for it because it takes in if a string format it can then modify it and it's much easier to discharge data rather than parsing it with for example STR tokenizer okay so whose F scanf and I used underscore s because the compiler does sort of force me well it just wants me that I should use the underscore s version of it and if you're using a modern compiler you should be able to do so otherwise just use F scanf they're almost the same I'm gonna tell you the difference so here again we're passing for the file the file handler then we're gonna have to define another format alright so similar to this I'm just gonna copy and paste it and it's gonna be person format in and % s is not quite right because % s in a scanf situation what percent s does is basically tells can have to read as many characters as it can until it hits a whitespace right but we don't actually want to read until the whitespace we want to read until the comma right we want to read everything before the first qualities in the files so what we're gonna do is just say instead of percentage read all the characters except the comma like this so this is a sort of percent s the specified what types of characters to read and here i just specified that it should not read a comma and the rest are fine so % DM % c should work fine and in this case we don't really need a back session but we could actually add a back session there so file then the person format in next up is the parameter so we need again all these parameters right so we can technically copy and paste these but be careful because scanf expect addresses right so p1 dot name well that is already an address it's on a way but it evaluates to the first character of that array to the address of the first cat or to that array more specifically and that is correct already we don't need to get the address of that that's evaluated he wanted age is just an int so we need to get the address of that p1 dot gender same finger just a char we get the address of that and one more thing beside from the semicolon one more thing here with the underscore s we just save four versions of these kind of functions you actually have to pass in the number of characters you have allocated for every sting every string you pass in here so I can take a look at this call and the only string that I passed in here are only string as a parameter to the format string except the format string itself of course is p1 dot name right so we have to pass in after it the number of characters that I have allocated and that is actually 20 right I have a repeated 20 characters food and of course I didn't notice some mistake here instead of p1 we want to save into p2 that we have defined here notice that I don't initialize this guy but it's actually allocated so the memory for it is actually allocate or no stack automatically so is the char array the into the gender it hazardous space allocated for it I just have to use it so I'm gonna use it here of course saying p2 lot mean of people unlocked name and same thing for the rest now if I add a breakpoint here and if I launch this we're gonna notice down here that p1 does have the name Andrew this is actually age 22 I believe because it's 16 but in hexadecimal and this is just a clock for M and same for p2 as you can see here the name is Andrew again 22 and M for the jungle so that worked nicely and the nice part about this is you can actually change the serialization so you only have to change this part to basically set the sterilization setup for it but now if I continue this program and finish let it execute completely I can take a look at the file here people dot that and you can see that I have the the structure saved there in a readable manner so not only did I realize it in a way that the computer can read it but also in a way that humans can read it which is pretty nice you can also see realize it in a way that humans cannot read it that's fine but this is much nicer I think now one more thing we can change here is for example if we want to show us this as JSON instead of just our own strange sterilization method we can actually do that so let's go so as you can see I changed here the format so basically I just added everything that there should be for a JSON except there's one single mistake that is this specifier is now incorrect because well Jason usually specifies strings in between double quotes so our string or actual value is going to have at the end a double quote here not a comma as we had before so I have to change this to a not double coding I mean I have to actually say Baxter's double code because I want to escape it so it doesn't end my actual string here so now if I try to launch this we should see that yes in fact p2 actually got the values of p1 so we have Andrew we have 22 and we have M as we have before and if we let it continue and reopen the file here we can see that the file has saved in a JSON format so this can technically be read by you can actually feed this to JavaScript and it's going to actually out we interpret this as an javascript object which is I think very nice and you can really expand on this as much as you want here I have changed it so that it explores it to a more nicely format than JSON file so if I run this it's gonna finish executing and if I open the file itself it's gonna actually have a nicely formatted JSON file with like every property on a line of its own right so I just basically just added some back sessions and back search teas so that's a new line and back fifty is a tab if you do know and yeah this is very simple I think to serialize a file all you have to do is just use these formats or format strings in a manner that makes the string look nice and you just have to sort of match the input with the output format but not one to one is can see here I had to use this format for this for the name but I had to only use percent s for the name of the person when printing out to the file right so there small differences but if you keep them neatly together it should be fine all right thanks so much for watching I hope you got something out of this video I hope this was useful if you do have any questions do leave them down the comments below or on our discord server take care bye you

Up Next

Building a B+Tree Database: Node Binary Representation Explained

@CodeWithSep

1.9K views•2024-06-25

BitTorrent Protocol Explained: Piece Selection & Peer Choking

@StevenGordonAU

481 views•2013-02-22

Memory Leaks in C/C++: Causes, Detection, and Prevention Strategies

@CodeVault

26.8K views•2019-04-05

Enigma Machine Mechanics: WWII Encryption Explained

@JaredOwen

13.2M views•2021-12-11

Related Study Plans & Knowledge Roadmaps

Structured learning paths in Computer Science

View All Computer Science Topics

computer-science

Building BitTorrent: Go, P2P & Concurrency

01Go Fundamentals & Concurrency

02Networking Foundations & P2P Architecture

03Bencode Parsing & Torrent Metadata

+ 3 more learning modules

Explore Roadmap

computer-science

Actor Models (C++ Concurrency & Lock-Free)

01C++ Multi-Threading Foundations

02Thread Pools and Task Scheduling

03Atomics and Lock-Free Queue Design

+ 3 more learning modules

Explore Roadmap

computer-science

Coding HM Type Inference: Algorithm W & OCaml

01Introduction to Functional Programming & OCaml

02Abstract Syntax Trees & Language Interpreters

03Type Systems & Lambda Calculus

+ 2 more learning modules

Explore Roadmap

computer-science

Building OAuth 2.0: Node.js OIDC Server

01Web & Security Foundations

02Authentication vs. Authorization & JWTs

03The OAuth 2.0 Protocol & Grant Types

+ 3 more learning modules

Explore Roadmap