Category: C and C++

#include <iostream>

#include <iostream>

#include <fstream>

#include <fstream>

#include <bitset>

#include <bitset>

#include <vector>

#include <vector>

#include <string>

#include <string>

#include <cstdint>

#include <cstdint>

int main() {
  return 0;
}

int main() {
  return 0;
}

// Standard Base64 alphabet
std::string base64Standard = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // Values 0-63
const char padChar = "="; // Technically, the padding character is NOT part of the alphabet and so including it above would be misleading

// Variable that holds our input file
std::string filePathInput;

std::cout << "Enter a file path to read from\n>";

// Read the line and place it directly in filePathInput
std::getline(std::cin, filePathInput);

// Variable that holds our output file
std::string filePathOutput;

std::cout << "Enter a file path to write to\n>";

// Read the line and place it directly in filePathOutput
std::getline(std::cin, filePathOutput);

// Standard Base64 alphabet
std::string base64Standard = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // Values 0-63
const char padChar = "="; // Technically, the padding character is NOT part of the alphabet and so including it above would be misleading

// Variable that holds our input file
std::string filePathInput;

std::cout << "Enter a file path to read from\n>";

// Read the line and place it directly in filePathInput
std::getline(std::cin, filePathInput);

// Variable that holds our output file
std::string filePathOutput;

std::cout << "Enter a file path to write to\n>";

// Read the line and place it directly in filePathOutput
std::getline(std::cin, filePathOutput);

std::cout << "\nAttempting to open input file...\n";

// Opening a read-only file stream to whichever path the user specified, in binary mode (since we are reading ones and zeroes, not text)
// To be more specific: On Windows systems, binary mode will prevent the OS from turning \n into \r\n, which will mess up the encoding and result in incorrect output
std::ifstream inputFileStream(filePathInput, std::ios::binary);

std::cout << "\nAttempting to open input file...\n";

// Opening a read-only file stream to whichever path the user specified, in binary mode (since we are reading ones and zeroes, not text)
// To be more specific: On Windows systems, binary mode will prevent the OS from turning \n into \r\n, which will mess up the encoding and result in incorrect output
std::ifstream inputFileStream(filePathInput, std::ios::binary);

if (!inputFileStream.is_open()) {
  std::cerr << "Failed to open file!\n";
  return 1;
}
std::cout << "File open!\n";

if (!inputFileStream.is_open()) {
  std::cerr << "Failed to open file!\n";
  return 1;
}
std::cout << "File open!\n";

std::cout << "Detecting file size...\n";
inputFileStream.seekg(0, std::ios::end);

// There is a dedicated type for file stream positions in C++
const std::streampos endPos = inputFileStream.tellg();
if (endPos < 0) { std::cerr << "Failed to get file size\n"; return 1; }
const size_t fileSizeBytes = static_cast<size_t>(endPos); // We must convert std::streampos to the dedicated type I mentioned above, size_t

std::cout << "Detected file size: " << fileSizeBytes << " bytes\n";
inputFileStream.seekg(0, std::ios::beg);

std::cout << "Detecting file size...\n";
inputFileStream.seekg(0, std::ios::end);

// There is a dedicated type for file stream positions in C++
const std::streampos endPos = inputFileStream.tellg();
if (endPos < 0) { std::cerr << "Failed to get file size\n"; return 1; }
const size_t fileSizeBytes = static_cast<size_t>(endPos); // We must convert std::streampos to the dedicated type I mentioned above, size_t

std::cout << "Detected file size: " << fileSizeBytes << " bytes\n";
inputFileStream.seekg(0, std::ios::beg);

// Each character in the vector holds raw bytes of the file
std::vector<uint8_t> fileData(fileSizeBytes);

std::cout << "Reading file...\n";

// read(...) takes char* and std::streamsize.
// In C++, a static cast is a cast (type conversion) where there is native support for the two types to convert from and to each other
// We use one here to convert the result of fileData.size() into std::streamsize
// A reinterpret cast tells the compiler that we know for sure the data coming in can be converted into a certain type (std::streamsize in this case)
// This essentially causes the type conversion to happen during runtime
// This is very unsafe and is not usually recommended
inputFileStream.read(reinterpret_cast<char*>(fileData.data()),
                     static_cast<std::streamsize>(fileData.size()));
inputFileStream.close();

std::cout << "File data read! It is now safe to modify or delete the file!\n";

// Each character in the vector holds raw bytes of the file
std::vector<uint8_t> fileData(fileSizeBytes);

std::cout << "Reading file...\n";

// read(...) takes char* and std::streamsize.
// In C++, a static cast is a cast (type conversion) where there is native support for the two types to convert from and to each other
// We use one here to convert the result of fileData.size() into std::streamsize
// A reinterpret cast tells the compiler that we know for sure the data coming in can be converted into a certain type (std::streamsize in this case)
// This essentially causes the type conversion to happen during runtime
// This is very unsafe and is not usually recommended
inputFileStream.read(reinterpret_cast<char*>(fileData.data()),
                     static_cast<std::streamsize>(fileData.size()));
inputFileStream.close();

std::cout << "File data read! It is now safe to modify or delete the file!\n";

std::cout << "Creating output file...\n";
std::ofstream encodedDataOutputFile(filePathOutput, std::ios::binary);

// Fires if an error occurs during the file creation process
if (!encodedDataOutputFile.is_open()) {
  std::cerr<< "Error opening output file\n";
  return 1;
}

std::cout << "Creating output file...\n";
std::ofstream encodedDataOutputFile(filePathOutput, std::ios::binary);

// Fires if an error occurs during the file creation process
if (!encodedDataOutputFile.is_open()) {
  std::cerr<< "Error opening output file\n";
  return 1;
}

size_t totalBits = fileData.size() * 8; // There are 8 bits in a byte

std::cout << "Processing "
  << totalBits 
  << " bits...\n";
  
 size_t bitsProcessed = 0; // Let's keep track of the bits processed here
 
 while (bitsProcessed < totalBits) {
   
 }

size_t totalBits = fileData.size() * 8; // There are 8 bits in a byte

std::cout << "Processing "
  << totalBits 
  << " bits...\n";
  
 size_t bitsProcessed = 0; // Let's keep track of the bits processed here
 
 while (bitsProcessed < totalBits) {
   
 }

size_t byteIndex = bitsProcessed / 8;
size_t bitIndex = bitsProcessed % 8; // This tells us how many bits are overflowing into the next byte

size_t byteIndex = bitsProcessed / 8;
size_t bitIndex = bitsProcessed % 8; // This tells us how many bits are overflowing into the next byte

uint8_t currentByte = fileData[byteIndex];
uint8_t nextByte = (byteIndex + 1 < fileData.size()) ? fileData[byteIndex + 1] : 0; // Six bits may span across two bytes, so we need to keep track of the next byte

uint8_t currentByte = fileData[byteIndex];
uint8_t nextByte = (byteIndex + 1 < fileData.size()) ? fileData[byteIndex + 1] : 0; // Six bits may span across two bytes, so we need to keep track of the next byte

uint16_t combined = (static_cast<uint16_t>(currentByte) << 8) | nextByte;
uint8_t sixBits = (combined >> (10 - bitIndex)) & 0x3F; // Extracting six bits

uint16_t combined = (static_cast<uint16_t>(currentByte) << 8) | nextByte;
uint8_t sixBits = (combined >> (10 - bitIndex)) & 0x3F; // Extracting six bits

char resultChar = base64Standard[static_cast<int>(sixBits)];

char resultChar = base64Standard[static_cast<int>(sixBits)];

encodedDataOutputFile << resultChar;
std::cout << resultChar;
bitsProcessed += 6; // Advance the loop

encodedDataOutputFile << resultChar;
std::cout << resultChar;
bitsProcessed += 6; // Advance the loop

size_t remaining = fileData.size() /*The size of the input file, in bits*/ % 3;
size_t padCount = (3 - remaining) % 3; // yields 0, 1, or 2

size_t remaining = fileData.size() /*The size of the input file, in bits*/ % 3;
size_t padCount = (3 - remaining) % 3; // yields 0, 1, or 2

for (size_t i = 0; i < padCount; ++i) {
    encodedDataOutputFile << padChar;
    std::cout << padChar;
}

for (size_t i = 0; i < padCount; ++i) {
    encodedDataOutputFile << padChar;
    std::cout << padChar;
}

#include <iostream>

#include <fstream>

#include <cstdint>

#include <bitset>

#include <vector>

#include <string>

int main() {
    // Standard Base64 alphabet
    std::string base64Standard = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // Values 0-63
    const char* padChar = "="; // Technically, the padding character is NOT part of the alphabet and so including it above would be misleading

    // Variable that holds our input file
    std::string filePathInput;

    std::cout << "Enter a file path to read from\n>";

    // Read the line and place it directly in filePathInput
    std::getline(std::cin, filePathInput);

    // Variable that holds our output file
    std::string filePathOutput;

    std::cout << "Enter a file path to write to\n>";

    // Read the line and place it directly in filePathOutput
    std::getline(std::cin, filePathOutput);
    std::cout << "\nAttempting to open input file...\n";

    // Opening a read-only file stream to whichever path the user specified, in binary mode (since we are reading ones and zeroes, not text)
    // To be more specific: On Windows systems, binary mode will prevent the OS from turning \n into \r\n, which will mess up the encoding and result in incorrect output
    std::ifstream inputFileStream(filePathInput, std::ios::binary);
    if (!inputFileStream.is_open()) {
        std::cerr << "Failed to open file!\n";
        return 1;
    }
    std::cout << "File open!\n";
    std::cout << "Detecting file size...\n";
    inputFileStream.seekg(0, std::ios::end);

    // There is a dedicated type for file stream positions in C++
    const std::streampos endPos = inputFileStream.tellg();
    if (endPos < 0) {
        std::cerr << "Failed to get file size\n";
        return 1;
    }
    const size_t fileSizeBytes = static_cast < size_t > (endPos); // We must convert std::streampos to the dedicated type I mentioned above, size_t

    std::cout << "Detected file size: " << fileSizeBytes << " bytes\n";
    inputFileStream.seekg(0, std::ios::beg);
    // Each character in the vector holds raw bytes of the file
    std::vector < uint8_t > fileData(fileSizeBytes);

    std::cout << "Reading file...\n";

    // read(...) takes char* and std::streamsize.
    // In C++, a static cast is a cast (type conversion) where there is native support for the two types to convert from and to each other
    // We use one here to convert the result of fileData.size() into std::streamsize
    // A reinterpret cast tells the compiler that we know for sure the data coming in can be converted into a certain type (std::streamsize in this case)
    // This essentially causes the type conversion to happen during runtime
    // This is very unsafe and is not usually recommended
    inputFileStream.read(reinterpret_cast < char * > (fileData.data()),
        static_cast < std::streamsize > (fileData.size()));
    inputFileStream.close();

    std::cout << "File data read! It is now safe to modify or delete the file!\n";
    std::cout << "Creating output file...\n";
    std::ofstream encodedDataOutputFile(filePathOutput, std::ios::binary);

    // Fires if an error occurs during the file creation process
    if (!encodedDataOutputFile.is_open()) {
        std::cerr << "Error opening output file\n";
        return 1;
    }
    size_t totalBits = fileData.size() * 8; // There are 8 bits in a byte

    std::cout << "Processing " <<
        totalBits <<
        " bits...\n";

    size_t bitsProcessed = 0; // Let's keep track of the bits processed here

    while (bitsProcessed < totalBits) {
        size_t byteIndex = bitsProcessed / 8;
        size_t bitIndex = bitsProcessed % 8; // This tells us how many bits are overflowing into the next byte
        uint8_t currentByte = fileData[byteIndex];
        uint8_t nextByte = (byteIndex + 1 < fileData.size()) ? fileData[byteIndex + 1] : 0; // Six bits may span across two bytes, so we need to keep track of the next byte
        uint16_t combined = (static_cast < uint16_t > (currentByte) << 8) | nextByte;
        uint8_t sixBits = (combined >> (10 - bitIndex)) & 0x3F; // Extracting six bits
        char resultChar = base64Standard[static_cast < int > (sixBits)];
        encodedDataOutputFile << resultChar;
        std::cout << resultChar;
        bitsProcessed += 6; // Advance the loop
    }
    size_t remaining = fileData.size() /* <-- The size of the input file, in bits */ % 3;
    size_t padCount = (3 - remaining) % 3; // yields 0, 1, or 2 (for number of padding characters we need to add)
    for (size_t i = 0; i < padCount; ++i) {
        encodedDataOutputFile << padChar;
        std::cout << padChar;
    }
    return 0;
}

#include <iostream>

#include <fstream>

#include <cstdint>

#include <bitset>

#include <vector>

#include <string>

int main() {
    // Standard Base64 alphabet
    std::string base64Standard = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; // Values 0-63
    const char* padChar = "="; // Technically, the padding character is NOT part of the alphabet and so including it above would be misleading

    // Variable that holds our input file
    std::string filePathInput;

    std::cout << "Enter a file path to read from\n>";

    // Read the line and place it directly in filePathInput
    std::getline(std::cin, filePathInput);

    // Variable that holds our output file
    std::string filePathOutput;

    std::cout << "Enter a file path to write to\n>";

    // Read the line and place it directly in filePathOutput
    std::getline(std::cin, filePathOutput);
    std::cout << "\nAttempting to open input file...\n";

    // Opening a read-only file stream to whichever path the user specified, in binary mode (since we are reading ones and zeroes, not text)
    // To be more specific: On Windows systems, binary mode will prevent the OS from turning \n into \r\n, which will mess up the encoding and result in incorrect output
    std::ifstream inputFileStream(filePathInput, std::ios::binary);
    if (!inputFileStream.is_open()) {
        std::cerr << "Failed to open file!\n";
        return 1;
    }
    std::cout << "File open!\n";
    std::cout << "Detecting file size...\n";
    inputFileStream.seekg(0, std::ios::end);

    // There is a dedicated type for file stream positions in C++
    const std::streampos endPos = inputFileStream.tellg();
    if (endPos < 0) {
        std::cerr << "Failed to get file size\n";
        return 1;
    }
    const size_t fileSizeBytes = static_cast < size_t > (endPos); // We must convert std::streampos to the dedicated type I mentioned above, size_t

    std::cout << "Detected file size: " << fileSizeBytes << " bytes\n";
    inputFileStream.seekg(0, std::ios::beg);
    // Each character in the vector holds raw bytes of the file
    std::vector < uint8_t > fileData(fileSizeBytes);

    std::cout << "Reading file...\n";

    // read(...) takes char* and std::streamsize.
    // In C++, a static cast is a cast (type conversion) where there is native support for the two types to convert from and to each other
    // We use one here to convert the result of fileData.size() into std::streamsize
    // A reinterpret cast tells the compiler that we know for sure the data coming in can be converted into a certain type (std::streamsize in this case)
    // This essentially causes the type conversion to happen during runtime
    // This is very unsafe and is not usually recommended
    inputFileStream.read(reinterpret_cast < char * > (fileData.data()),
        static_cast < std::streamsize > (fileData.size()));
    inputFileStream.close();

    std::cout << "File data read! It is now safe to modify or delete the file!\n";
    std::cout << "Creating output file...\n";
    std::ofstream encodedDataOutputFile(filePathOutput, std::ios::binary);

    // Fires if an error occurs during the file creation process
    if (!encodedDataOutputFile.is_open()) {
        std::cerr << "Error opening output file\n";
        return 1;
    }
    size_t totalBits = fileData.size() * 8; // There are 8 bits in a byte

    std::cout << "Processing " <<
        totalBits <<
        " bits...\n";

    size_t bitsProcessed = 0; // Let's keep track of the bits processed here

    while (bitsProcessed < totalBits) {
        size_t byteIndex = bitsProcessed / 8;
        size_t bitIndex = bitsProcessed % 8; // This tells us how many bits are overflowing into the next byte
        uint8_t currentByte = fileData[byteIndex];
        uint8_t nextByte = (byteIndex + 1 < fileData.size()) ? fileData[byteIndex + 1] : 0; // Six bits may span across two bytes, so we need to keep track of the next byte
        uint16_t combined = (static_cast < uint16_t > (currentByte) << 8) | nextByte;
        uint8_t sixBits = (combined >> (10 - bitIndex)) & 0x3F; // Extracting six bits
        char resultChar = base64Standard[static_cast < int > (sixBits)];
        encodedDataOutputFile << resultChar;
        std::cout << resultChar;
        bitsProcessed += 6; // Advance the loop
    }
    size_t remaining = fileData.size() /* <-- The size of the input file, in bits */ % 3;
    size_t padCount = (3 - remaining) % 3; // yields 0, 1, or 2 (for number of padding characters we need to add)
    for (size_t i = 0; i < padCount; ++i) {
        encodedDataOutputFile << padChar;
        std::cout << padChar;
    }
    return 0;
}

$TIME = Measure-Command {[Convert]::ToBase64String([System.IO.File]::ReadAllBytes("./hello.txt"))}
$TIME.TotalMilliseconds
# 7.0512
$DIY_IMPLEMENTATION = Measure-Command {echo "./hello.txt`n./res.txt`n" | ./a.exe}
$DIY_IMPLEMENTATION.TotalMilliseconds
# 31.5084

$TIME = Measure-Command {[Convert]::ToBase64String([System.IO.File]::ReadAllBytes("./hello.txt"))}
$TIME.TotalMilliseconds
# 7.0512
$DIY_IMPLEMENTATION = Measure-Command {echo "./hello.txt`n./res.txt`n" | ./a.exe}
$DIY_IMPLEMENTATION.TotalMilliseconds
# 31.5084