DEV Community: Alen Bluberry

Binary File Handling in C++: A Beginner’s Guide

Alen Bluberry — Thu, 20 Feb 2025 00:53:32 +0000

Introduction

Binary file handling in C++ is a powerful technique that allows us to store and retrieve data efficiently. Unlike text files, which store data as human-readable characters, binary files store raw data in a format that is directly understood by the computer. This makes them faster and more suitable for handling structured data such as objects, arrays, and large datasets.

In this article, we will explore the basics of binary file handling in C++, including how to read, write, append, search, modify, and delete records in a binary file.

1. Why Use Binary Files?

Binary files offer several advantages over text files:
✔ Faster reading and writing operations.
✔ No conversion is needed between data types and text.
✔ Suitable for storing complex data like images, videos, and database records.

2. File Handling in C++

C++ provides the <fstream> library for file handling. It contains three important classes:

ifstream → For reading files.

ofstream → For writing files.

fstream → For both reading and writing.

To work with binary files, we use ios::binary mode when opening a file.

We use the .write() function to store data in a binary file.

Example: Writing a Single Record to a Binary File

#include <iostream>
#include <fstream>
using namespace std;

struct Student {
    char name[30];
    int age;
    float marks;
};

int main() {
    Student s = {"John", 20, 85.5};

    ofstream file("student.dat", ios::binary);
    file.write((char*)&s, sizeof(s));
    file.close();

    cout << "Data saved successfully!" << endl;
    return 0;
}

✔ We define a structure Student to store student details.
✔ The file is opened in binary write mode using ios::binary.
✔ .write() saves the entire Student object to the file.
✔ Finally, we close the file.

4. Reading Data from a Binary File

We use the .read() function to retrieve stored data.

Example: Reading a Record from a Binary File

#include <iostream>
#include <fstream>
using namespace std;

struct Student {
    char name[30];
    int age;
    float marks;
};

int main() {
    Student s;

    ifstream file("student.dat", ios::binary);
    file.read((char*)&s, sizeof(s));
    file.close();

    cout << "Name: " << s.name << "\nAge: " << s.age << "\nMarks: " << s.marks << endl;
    return 0;
}

✔ The file is opened in binary read mode.
✔ .read() retrieves the stored object and loads it into memory.
✔ We then display the retrieved information.

5. Appending Data to a Binary File

To add new data without overwriting existing records, we use append mode (ios::app).

Example: Appending Data

#include <iostream>
#include <fstream>
using namespace std;

struct Student {
    char name[30];
    int age;
    float marks;
};

int main() {
    Student s = {"Alice", 21, 90.2};

    ofstream file("student.dat", ios::binary | ios::app);
    file.write((char*)&s, sizeof(s));
    file.close();

    cout << "Data appended successfully!" << endl;
    return 0;
}

✔ The file is opened in an append mode.
✔ New data is added without deleting previous records.

6. Searching for a Record in a Binary File

We can search for a specific record by reading each entry one by one.

Example: Searching for a Student by Name

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

struct Student {
    char name[30];
    int age;
    float marks;
};

int main() {
    Student s;
    char searchName[30];

    cout << "Enter name to search: ";
    cin >> searchName;

    ifstream file("student.dat", ios::binary);
    bool found = false;

    while (file.read((char*)&s, sizeof(s))) {
        if (strcmp(s.name, searchName) == 0) {
            cout << "Record Found!\n";
            cout << "Name: " << s.name << "\nAge: " << s.age << "\nMarks: " << s.marks << endl;
            found = true;
            break;
        }
    }

    if (!found) cout << "Record not found!" << endl;
    file.close();
    return 0;
}

✔ We loop through all records and compare names using strcmp().
✔ If a match is found, the details are displayed.

7. Modifying a Record in a Binary File

To modify a record, we:

Read the file.
Find the record to modify.
Update the data and rewrite it.

Example: Modifying Marks of a Student

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

struct Student {
    char name[30];
    int age;
    float marks;
};

int main() {
    Student s;
    char searchName[30];

    fstream file("student.dat", ios::binary | ios::in | ios::out);

    cout << "Enter name to modify: ";
    cin >> searchName;

    while (file.read((char*)&s, sizeof(s))) {
        if (strcmp(s.name, searchName) == 0) {
            cout << "Enter new marks: ";
            cin >> s.marks;

            file.seekp(-sizeof(s), ios::cur);
            file.write((char*)&s, sizeof(s));

            cout << "Record updated successfully!" << endl;
            break;
        }
    }

    file.close();
    return 0;
}

✔ We open the file in both read and write mode.
✔ The .seekp() function moves the file pointer back to update the record in place.

8. Deleting a Record from a Binary File

To delete a record:

Copy all records except the one to be deleted into a new file.
Replace the old file with the new file.

Example: Deleting a Record

#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;

struct Student {
    char name[30];
    int age;
    float marks;
};

int main() {
    Student s;
    char deleteName[30];

    cout << "Enter name to delete: ";
    cin >> deleteName;

    ifstream file("student.dat", ios::binary);
    ofstream temp("temp.dat", ios::binary);

    while (file.read((char*)&s, sizeof(s))) {
        if (strcmp(s.name, deleteName) != 0) {
            temp.write((char*)&s, sizeof(s));
        }
    }

    file.close();
    temp.close();

    remove("student.dat");
    rename("temp.dat", "student.dat");

    cout << "Record deleted successfully!" << endl;
    return 0;
}

✔ We use a temporary file to store all records except the one to delete.
✔ The old file is removed and replaced with the new file.

Conclusion

Binary file handling in C++ is essential for efficient data storage and retrieval. We covered:
✔ Writing and reading binary files.
✔ Appending new records.
✔ Searching, modifying, and deleting records.

Understanding these concepts will help you efficiently manage structured data in real-world applications. Happy coding!

Also you can check all the above cpp codes on my GitHub repo... ;)
https://github.com/AlenBluBerry/Binary-File-Handling/tree/main/Cpp%20codes

Unveiling the Magic of HTML: A Journey Through the Building Blocks of the Web

Alen Bluberry — Sat, 04 Jan 2025 17:17:14 +0000

HTML, or HyperText Markup Language, is the cornerstone of web development, structuring content and defining the layout of web pages. Understanding its various elements, tags, and associated abbreviations is essential for crafting effective and engaging web content.

The Essence of HTML

HTML employs a system of tags to delineate different parts of a web page, such as headings, paragraphs, links, and images. These tags are enclosed in angle brackets, for example, <tagname>. Many tags come in pairs: an opening tag <tagname> and a closing tag </tagname>, with the content placed between them. Some tags, known as empty elements, are self-closing, like <br> for a line break.

Fundamental HTML Tags

Here are some foundational HTML tags that are integral to web development:

<html>: Encapsulates the entire HTML document.

<head>: Contains meta-information about the document, such as its title and links to stylesheets.

<title>: Sets the title of the web page, displayed on the browser's title bar or tab.

<body>: Houses the content of the web page, including text, images, and other media.

<h1> to <h6>: Define headings, with <h1> being the highest level and <h6> the lowest.

<p>: Denotes a paragraph of text.

<a>: Creates a hyperlink; the href attribute specifies the destination URL.

<img>: Embeds an image; the src attribute defines the image source URL, and the alt attribute provides alternative text for accessibility.

<ul> and <ol>: Represent unordered (bulleted) and ordered (numbered) lists, respectively.

<li>: Specifies a list item within <ul> or <ol>.

<div>: Defines a division or section in the document, commonly used for grouping elements to apply CSS styles.

<span>: Used to group inline elements for styling purposes.

These tags form the backbone of HTML, enabling developers to structure content semantically and effectively.

Decoding HTML Abbreviations and Acronyms

The digital realm is replete with abbreviations and acronyms that are pivotal in web development. Here are some commonly encountered ones:

HTML: HyperText Markup Language.

CSS: Cascading Style Sheet, used for styling HTML documents.

URL: Uniform Resource Locator, the address of a resource on the internet.

HTTP: HyperText Transfer Protocol, the foundation of data communication on the web.

HTTPS: HyperText Transfer Protocol Secure, an encrypted version of HTTP for secure communication.

API: Application Programming Interface, a set of functions allowing the creation of applications that access data and features of other services.

FTP: File Transfer Protocol, used for transferring files between a client and a server.

XML: eXtensible Markup Language, designed to store and transport data.

W3C: World Wide Web Consortium, the main international standards organization for the web.

SEO: Search Engine Optimization, the practice of enhancing a website to improve its ranking on search engine results pages.

Understanding these terms is crucial for effective communication and implementation in web development.

Enhancing Accessibility with the <abbr> Tag

In HTML, the <abbr> tag is employed to represent abbreviations or acronyms, providing additional information about them through the title attribute. This practice enhances accessibility, as screen readers can convey the full term to users.

Example:

<p>The <abbr title="World Health Organization">WHO</abbr> provides global health guidelines.</p>

In this instance, hovering over "WHO" may display "World Health Organization," offering clarity to users.

The Evolution of HTML
Since its inception, HTML has undergone significant transformations, introducing new elements and attributes to meet the evolving demands of web development. For instance, HTML5 introduced semantic elements like <article>, <section>, and <nav>, enhancing the meaning and structure of web content.

Staying abreast of these developments is vital for developers to leverage the full potential of HTML in creating modern, responsive, and accessible web pages.

Conclusion

HTML is a dynamic and robust language that forms the foundation of web content creation. A comprehensive understanding of its tags, abbreviations, and best practices is indispensable for developers aiming to craft engaging and accessible web experiences. As the web continues to evolve, so does HTML, adapting to new challenges and opportunities in the digital landscape.

References:

HTML Elements Reference - MDN Web Docs

HTML Tags List - W3Schools

Abbreviations and Acronyms in HTML - PerfectElearning

Semantic Elements in HTML5 - MDN Web Docs

Accessible Rich Internet Applications (ARIA) - W3C
.