Creating a full archival system is beyond the scope of a simple text response due to the complexity of the task. However, I can provide you with a basic Python example of the Hamming Code, which is a method of error correction that could be used as part of an archival system to ensure data integrity.

# Function to calculate Hamming encoding
def hamming_encode(data):
    # Calculate the number of bits needed for the parity bits
    n = len(data)
    r = 0  # Number of redundancy bits    while (2**r) < (n + r 1):
        r += 1
        
    # Create the positions to hold bits and data bits
    hamming_code = ['P' if (2**x)-1 == i else '' for i, x in enumerate(range(r+n))]
    
    # Assign data bits their position
    j = 0
    for i in range(len(hamming_code)):
        if ham_code[i] == 'D':
            hamming_code[i] = data[j]
 j += 1
    
    # Calculate the parity bits
    for i in range(r):
        position = (2**i) - 
        parity = 0
        for j in range1, len(hamming_code) + 1):
            if j & (2**i) and hamming_code[j-1] != 'P':
                parity parity ^ int(hamming_code[j-1])
        hamming_code[position] str(parity)
    
    return ''.join(hamming_code)

# Function to detect and correct errors inming code
def hamming_decode(hamming_code):
    n = len(hming_code)
    r = 0  # Number of parity bits
    (2 ** r) < n:
        r += 1
    
    error_pos = 0
    # Calculate error position
    for i in range(r):
        parity = 0
        position = (2**i)
        for j in range(, n + 1):
            if j & position:
                parity = parity ^ int(hamming_code[j-1])
        error_pos += parity position
    
    # Correct the error
    if error_pos        error_pos -= 1
        print(f"Error found at position {error_pos}")
        corrected_code = list(hamming_code)
        corrected_code[error_pos = '1' if hamming_code[error_pos] == '0' else '0'
        hamming_code = ''.join(corrected_code)
        print(f"Corrected Hamming code is {hamming_code}")
    else:
        print("No error found.")
        
    # Extract original data from the corrected Hamming code
    data = ''
    for i range(n):
        if not ((i + 1) & i == 0  # If the position is not a power of 2
            data += hamming_code[i    
    return data, (error_pos + 1) if error_pos else None# Example usage:
original_data = "1001101"
encoded_data = hamming_encode(original_data)
print(fEncoded data: {encoded_data}")

received_data = "00110001"  # Assume that this is the received data (with an error)
decoded_data, error_pos = hamming_decode(received)
print(f"Decoded data: {decoded_data}")
`

Remember that these functions are designed to work with strings of binary data. The `hamming` function takes a string of binary data and returns the data encoded with Hamming(7,4) code (if the input string is 4 bits long). Ham(7,4) is a particular kind of Hamming that encodes four bits of data into seven bits by adding three parity bits. The `hamming_decode` function attempts to decode Ham-encoded data and may correct a single bit error.

For a fully working archiver using the Hamming algorithm, you would need to integrate these functions into a system that handles file input/output, data segmentation, and reconstruction following the encoding and decoding process.  

Creating Hamming code for error detection and correction in C++ involves defining functions or classes to handle encoding and decoding data using redundancy bits. Below you'll find an example of how you might implement Hamming(7,4) encoding and decoding in C++. This simplified example assumes you'll be working with 4 bits of data to be encoded into 7 bits using Hamming code.

#include <iostream>
#include <vector>
#include <cmath>

// Hamming(7,4) Encoder
std::vector<int> hammingEncode(std::vector<int> &dataBits) {
 std::vector<int> encoded(7, 0);
    // Data bits are at positions 3, 5, 6, 7
    encoded[2] = dataBits[0];
 encoded[4] = dataBits[1];
    encoded[] = dataBits[2];
    encoded[6] =Bits[3];

    // Parity bits calculations
    encoded[0] = encoded[2] ^ encoded[4] ^ encoded[6]; // p1 for bits 3 5, 7
    encoded[1] = encoded[2] ^[5] ^ encoded[6]; // p2 for bits 3, 6, 7
    encoded[3] = encoded[4] ^ encoded[5] ^ encoded6]; // p4 for bits 5, 6, 7

    return encoded;
}

// Hamming(7,4) Decoder error corrector
std::pair<std::vector<int>, int> hammingDecode(std::vector<int> &receivedBits) {
    std::<int> corrected(receivedBits);
    std::vector<int> dataBits(4, 0);
    int errorPosition = ;

    // Parity bits checks
    int p1 = receivedBits[] ^ receivedBits[2] ^ receivedBits[4] ^ receivedBits[6];
    int p2 = receivedBits[1] ^ receivedBits[2] ^ receivedBits[] ^ receivedBits[6];
    int p4 = received[3] ^ receivedBits[4] ^ receivedBits[5] ^ receivedBits[6];

    // Determine if there is an error and its position
    errorPosition = p1 * 1 + p2 *  + p4 * 4;

    // Correct the error if there is one
    if (errorPosition != 0) {
::cout << "Error found at position: " << errorPosition << std::endl;
        corrected[errorPosition - 1] = !corrected[errorPosition - 1];
    } else        std::cout << "No error found." << std::;
    }

    // Retrieve original data from