Hamming code Implementation in C++ with receiver side verification of code
Last Updated :
15 Mar, 2023
Hamming code is an error-correcting code used for detecting and correcting errors in data transmission. It adds redundant bits to the data being transmitted which can be used to detect and correct errors that may occur during transmission. Developed by Richard W. Hamming in the 1950s, it is widely used in applications where reliable data transmission is critical, such as computer networks and telecommunication systems.
To implement the Hamming code in C++, we can use bitwise operations and arrays to represent the data and the redundant bits. The following code snippet demonstrates how to implement the Hamming code in C++ with receiver-side verification:
Example:
C++
#include <iostream>
using namespace std;
// function to calculate the parity bit for a given position
int parity(int n, int *arr) {
int p = 0;
for (int i = 0; i < n; i++) {
if (i != (1 << p) - 1) {
p++;
}
else {
p++;
i += (1 << p) - 2;
}
}
int sum = 0;
for (int i = 0; i < n; i++) {
if ((i & (1 << p - 1)) == 0) {
sum ^= arr[i];
}
}
return sum;
}
// function to encode the data using the Hamming code
void encode(int *data, int n, int *encoded) {
int r = 0;
while ((1 << r) < n + r + 1) {
r++;
}
int j = 0;
for (int i = 0; i < n + r; i++) {
if ((i & (i + 1)) == 0) {
encoded[i] = 0;
}
else {
encoded[i] = data[j];
j++;
}
}
for (int i = 0; i < r; i++) {
int p = parity(n + r, encoded);
encoded[(1 << i) - 1] = p;
}
}
// function to decode the data using the Hamming code
bool decode(int *data, int n, int *received) {
int r = 0;
while ((1 << r) < n + r + 1) {
r++;
}
int error = 0;
for (int i = 0; i < r; i++) {
int p = parity(n + r, received);
if (p != received[(1 << i) - 1]) {
error += (1 << i) - 1;
}
}
if (error != 0) {
received[error - 1] ^= 1;
}
int j = 0;
for (int i = 0; i < n + r; i++) {
if ((i & (i + 1)) != 0) {
data[j] = received[i];
j++;
}
}
return error == 0;
}
int main() {
int n = 4; // size of data
int r = 3; // number of redundant bits
int data[n] = {1, 0, 1, 1}; // data to be transmitted
int encoded[n + r] = {0}; // encoded data
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
class hamming{
public:
string data; //it is the raw data received
int m , r = 0; // n is the length of raw data and r is the number of redundant bits
char * msg; // it will store the all bits (data + redundant). We made it dynamic because at compile time we dont know how much redundant bits will be there, we will initialize memory to it once we know the number of redundant bits.
hamming(string data){
this->data = data;
//reversing the data received
reverse(data.begin(),data.end());
m = data.size();
int power = 1;
//finding the number of redundant bits and storing them in r
while(power < (m + r + 1)){
r++;
power*=2;
}
//Allocating memory to our dynamic msg array(Note we are using one based indexing).
msg = new char[m+r+1];
int curr = 0;
//initializing the msg with data bits and for redundant bits, an initial value of n
for(int i = 1 ; i <= m+r ; i++){
if(i & (i-1)){
msg[i] = data[curr++];
}
else msg[i] = 'n';
}
//function call to set the redundant bits
setRedundantBits();
}
//function to show the whole msg
void showmsg(){
cout << "the data packet to be sent is : ";
for(int i = m+r ; i >= 1 ; i--){
cout << msg[i] << " ";
}
cout << endl;
}
void setRedundantBits(){
//for first redundant bit, check all those data bits at index where the first bit of index is set(1) similarly for second redundant bit, check all those data bits at index where the second bit of index is set(1), similarly for third redundant bit check all those data bits at index where the third bit of index is set to 1 and so on.
int bit = 0;
//outer loop runs for redundant bits (1 ,2 ,4 ,8 ....)
for(int i = 1 ; i <= m+r ; i*=2){
int count = 0;
//inner loop runs for data bits
for(int j = i+1 ; j<=m+r ; j++){
// checking if the data bit corresponds to our redundant bit or not using bit manipulation
if(j & (1 << bit)){
if(msg[j] == '1') count++; // counting the number of ones in corresponding data bits
}
}
//setting up redundant bits
if(count & 1) msg[i] = '1';
else msg[i] = '0';
//increasing the bit position.
bit++;
}
//showing up the message to be sent(data + redundant)
showmsg();
}
void receiver(){
//this ans will store the redundant bits, if they were right then according to even parity they will store 0 else if some error was made in a bit it will store 1
string ans = "";
int bit = 0;
//this loop corresponds to the logic used in set redundant bits function
for(int i = 1 ; i <= m+r ; i*=2){
int count = 0;
for(int j = i+1 ; j<=m+r ; j++){
if(j & (1 << bit)){
if(msg[j] == '1') count++;
}
}
//incrementing the ans variable with the parity of redundant bit
// if it was right then add 0 else 1
if(count & 1){
if(msg[i] == '1') ans.push_back('0');
else ans.push_back('1');
}
else{
if(msg[i]=='0') ans.push_back('0');
else ans.push_back('1');
}
bit++;
}
// if the ans had any occurrence of 1 then there is some fault
if(ans.find('1') != string::npos){
int power = 1;
int wrongbit = 0;
//evaluating the binary expression of ans variable
for(int i = 0 ; i < ans.size() ; i++){
if(ans[i]=='1') wrongbit+=power;
power*=2;
}
cout << "bit number " << wrongbit << " is wrong and having error " << endl;
}
// if the ans dont have any occurrence of 1 then it is correct
else{
cout << "correct data packet received " << endl;
}
}
};
int main(){
string data = "1011001";
hamming h(data);
// manipulating any ith data bit to check if receiver is detecting a error in that bit. If you eliminate the following line then correct code will be sent to receiver following that no error is received
//h.msg[i] == '0' ? h.msg[i] = '1' : h.msg[i] = '0';
h.receiver();
return 0;
}
//time complexity = O(nlogn) where , n = databits + redundant bits
//this code is contributed by Mayank Sharma.
Outputthe data packet to be sent is : 1 0 1 0 1 0 0 1 1 1 0
correct data packet received
Pre-requisite: Hamming Code
Given a message bit in the form of an array msgBit[], the task is to find the Hamming Code of the given message bit.
Examples:
Input: S = "0101"
Output:
Generated codeword:
r1 r2 m1 r4 m2 m3 m4
0 1 0 0 1 0 1
Explanation:
Initially r1, r2, r4 is set to '0'.
r1 = Bitwise XOR of all bits position that has '1' in its 0th-bit position.
r2 = Bitwise XOR of all bits that has '1' in its 1st-bit position.
r3 = Bitwise XOR of all bits that has '1' in its 2nd-bit position.
Input: S = "0111"
Output:
Generated codeword:
r1 r2 m1 r4 m2 m3 m4
0 0 0 1 1 1 1
Approach: The idea is to first find the number of redundant bits which can be found by initializing r with 1 and then incrementing it by 1 each time while 2r is smaller than (m + r + 1) where m is the number of bits in the input message. Follow the below steps to solve the problem:
- Initialize r by 1 and increment it by 1 until 2r is smaller than m+r+1.
- Initialize a vector hammingCode of size r + m which will be the length of the output message.
- Initialize all the positions of redundant bits with -1 by traversing from i = 0 to r - 1 and setting hammingCode [2i - 1] = -1. Then place the input message bits in all the positions where hammingCode[j] is not -1 in order where 0 <= j < (r + m).
- Initialize a variable one_count with 0 to store the number of ones and then traverse from i = 0 to (r + m - 1).
- If the current bit i.e., hammingCode[i] is not -1 then find the message bit containing set bit at log2(i+1)th position by traversing from j = i+2 to r+m by incrementing one_count by 1 if (j & (1<<x)) is not 0 and hammingCode[j - 1] is 1.
- If for index i, one_count is even, set hammingCode[i] = 0 otherwise set hammingCode[i] = 1.
- After traversing, print the hammingCode[] vector as the output message.
Below is the implementation of the above approach:
C
// C program for the above approach
#include <math.h>
#include <stdio.h>
// Store input bits
int input[32];
// Store hamming code
int code[32];
int ham_calc(int, int);
void solve(int input[], int);
// Function to calculate bit for
// ith position
int ham_calc(int position, int c_l)
{
int count = 0, i, j;
i = position - 1;
// Traverse to store Hamming Code
while (i < c_l) {
for (j = i; j < i + position; j++) {
// If current bit is 1
if (code[j] == 1)
count++;
}
// Update i
i = i + 2 * position;
}
if (count % 2 == 0)
return 0;
else
return 1;
}
// Function to calculate hamming code
void solve(int input[], int n)
{
int i, p_n = 0, c_l, j, k;
i = 0;
// Find msg bits having set bit
// at x'th position of number
while (n > (int)pow(2, i) - (i + 1)) {
p_n++;
i++;
}
c_l = p_n + n;
j = k = 0;
// Traverse the msgBits
for (i = 0; i < c_l; i++) {
// Update the code
if (i == ((int)pow(2, k) - 1)) {
code[i] = 0;
k++;
}
// Update the code[i] to the
// input character at index j
else {
code[i] = input[j];
j++;
}
}
// Traverse and update the
// hamming code
for (i = 0; i < p_n; i++) {
// Find current position
int position = (int)pow(2, i);
// Find value at current position
int value = ham_calc(position, c_l);
// Update the code
code[position - 1] = value;
}
// Print the Hamming Code
printf("\nThe generated Code Word is: ");
for (i = 0; i < c_l; i++) {
printf("%d", code[i]);
}
}
// Driver Code
void main()
{
// Given input message Bit
input[0] = 0;
input[1] = 1;
input[2] = 1;
input[3] = 1;
int N = 4;
// Function Call
solve(input, N);
}
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to generate hamming code
vector<int> generateHammingCode(
vector<int> msgBits, int m, int r)
{
// Stores the Hamming Code
vector<int> hammingCode(r + m);
// Find positions of redundant bits
for (int i = 0; i < r; ++i) {
// Placing -1 at redundant bits
// place to identify it later
hammingCode[pow(2, i) - 1] = -1;
}
int j = 0;
// Iterate to update the code
for (int i = 0; i < (r + m); i++) {
// Placing msgBits where -1 is
// absent i.e., except redundant
// bits all positions are msgBits
if (hammingCode[i] != -1) {
hammingCode[i] = msgBits[j];
j++;
}
}
for (int i = 0; i < (r + m); i++) {
// If current bit is not redundant
// bit then continue
if (hammingCode[i] != -1)
continue;
int x = log2(i + 1);
int one_count = 0;
// Find msg bits containing
// set bit at x'th position
for (int j = i + 2;
j <= (r + m); ++j) {
if (j & (1 << x)) {
if (hammingCode[j - 1] == 1) {
one_count++;
}
}
}
// Generating hamming code for
// even parity
if (one_count % 2 == 0) {
hammingCode[i] = 0;
}
else {
hammingCode[i] = 1;
}
}
// Return the generated code
return hammingCode;
}
// Function to find the hamming code
// of the given message bit msgBit[]
void findHammingCode(vector<int>& msgBit)
{
// Message bit size
int m = msgBit.size();
// r is the number of redundant bits
int r = 1;
// Find no. of redundant bits
while (pow(2, r) < (m + r + 1)) {
r++;
}
// Generating Code
vector<int> ans
= generateHammingCode(msgBit, m, r);
// Print the code
cout << "Message bits are: ";
for (int i = 0; i < msgBit.size(); i++)
cout << msgBit[i] << " ";
cout << "\nHamming code is: ";
for (int i = 0; i < ans.size(); i++)
cout << ans[i] << " ";
}
// Driver Code
int main()
{
// Given message bits
vector<int> msgBit = { 0, 1, 0, 1 };
// Function Call
findHammingCode(msgBit);
return 0;
}
Time Complexity: O((M + R)2) where M is the number of bits in the input message and R is the number of redundant bits
Auxiliary Space: O(M + R) the algorithm needs space proportional to input data size (M) plus output data size (R). This is common in data manipulation algorithms like sorting or searching. Excessive memory usage can limit problem scale, so it's important to consider auxiliary space complexity alongside time complexity.
Similar Reads
UDP Server-Client implementation in C++
There are two primary transport layer protocols to communicate between hosts: TCP and UDP. Creating TCP Server/Client was discussed in a previous post. Prerequisite: Creating TCP Server/Client Theory: In UDP, the client does not form a connection with the server like in TCP and instead sends a datag
4 min read
How to Check if a Vector Contains a Given Element in C++?
In C++, a vector is a dynamic array that provides a resizable and efficient way to store elements. Vectors store their elements in contiguous memory locations, similar to arrays, which allows for efficient access and iteration.In this article, we will learn the different methods to check whether the
3 min read
How to Implement Interfaces Using Abstract Class in C++
C++ doesn't have built-in functionality of interfaces like other programming languages such as Java. However, interfaces can be implemented in C++ using the abstract classes and pure virtual functions. In this article, we will learn how to implement interfaces using abstract classes in C++.Implement
4 min read
How to Create a Class with Private and Public Members in C++?
In C++, the classes are blueprints for creating objects with specific properties and methods that provide a feature of access specifiers to the user through which they can control the access of the data members present in a class. In this article, we will learn how to create a class with private and
3 min read
How to setup Competitive Programming in Visual Studio Code for C++
GCC compiler installation We need to install GCC compilers for Windows. Linux has already GCC installed. Steps for installation1.Download and Install the MinGW for GCC compiler using this link. 2.Open Control Panel in your system and then select: System (Control Panel) 3.Click on the Advanced system
6 min read
How to Use Deleted Functions to Prevent Object Copying in C++?
In C++, the class always has a copy constructor and assignment operator, whether it is default or user-defined which allows the program to create copies of the objects of that class. But sometimes, we need to create a class whose object should not be copied. In this article, we will learn how to use
2 min read
How to Ask User Input Until Correct Input is Received?
User input is a common source of errors in C++ programs so it’s important to validate user input to make the program more reliable. In this article, we will discuss how to ask the user for input until valid input is received in our C++ program. For Example, Input: asdf Output: Incorrect Input. Pleas
2 min read
Managing Console I/O operations in C++
Every program takes some data as input and generates processed data as an output following the familiar input process output cycle. It is essential to know how to provide the input data and present the results in the desired form. The use of the cin and cout is already known with the operator >
4 min read
Overloading of function-call operator in C++
In this article, we will discuss the Overloading of the function-call operators in C++. The function call operator is denoted by “()†which is used to call function and pass parameters. It is overloaded by the instance of the class known as a function object.When the function call operator is overlo
3 min read
Creating a C++ reusable Header File and its Implementation Files
Reusability is one of the most important concepts of Software Engineering. Reusability means developing code that can be reused either in the same program or in different programs. C++ allows reusability through inheritance, containership, polymorphism, and genericity. But, there is another way to d
4 min read