Base85 Class

Base85.h

#pragma once
#include<string>
#include<sstream>
#include<vector>
#include<math.h>

using namespace std;

class Base85
{
    public:
        Base85(void);
        ~Base85(void);
        vector<unsigned char> DecodeBlock(string chars);
        string EncodeBlock(vector<unsigned char> bytes, bool lastblock);
    private:
        string ToBinary(long long input, int length);
        double ToDoub(string input);
};


Base85.cpp

#include "Base85.h"

using namespace std;

Base85::Base85(void)
{
}

Base85::~Base85(void)
{
}

//Takes a vector of 4 8-bit bytes and return a string of 5-7 characters, depending on last block
string Base85::EncodeBlock(vector<unsigned char> bytes, bool lastblock)
{
    string retval = "";	
    string ss = "";
    int size = bytes.size();
    //Pad the block to 4 8-bit bytes
    for(int i = 0; i < 4 - size; i++)
    {
        bytes.push_back(0);
    }
    //convert the 4 8-bit bytes to one 32-bit binary
    for(int j = 0; j<4;j++)
    {			
        ss += ToBinary(bytes[j],8);
    }
    //Convert the 32-bit binary to to base10.
    double bintodoub = ToDoub(ss);
    //Convert the base10 to 5 digit base85.  This also adds 33 to each one, to make it a displayable character,
    //and stores it in the return string
    for(int j = 0; j < 5; j++)
    {
        retval += ((unsigned char)((long long)(bintodoub/pow(85.0,(double)4-j)) % 85) + 33);
    }
    //Add last block signifier if necessary
    retval = retval.substr(0,retval.length() - (4 - size)) + "~>";
    return retval;
}

//Takes a string of 5 characters and returns a vector of up to 4 8-bit bytes
vector<unsigned char> Base85::DecodeBlock(string chars)
{
    vector<unsigned char> retval;
    double base85todoub = 0;
    //Remove last block signifier if necessary
    if(chars[chars.length() - 1] == '>' && chars[chars.length() - 2] == '~')
        chars = chars.substr(0, chars.length() - 2);
    //Take each character subtract 33 and convert from base85 to base10
    for(int i = 0; i <4; i++)
    {
        base85todoub += (double)(chars[i]-33) * pow(85.0, (double)(4-i));
    }
    base85todoub += chars[4] - 33;
    //Convert the base 10 number to 32-bit binary
    string doubtobin = ToBinary((int)base85todoub,32);
    //Break the 32-bit binary into 8-bit binary blocks and convert each block to base10 8-bit byte
    for(int i = 0; i < 32; i+=8)
    {
        retval.push_back((unsigned char)(ToDoub(doubtobin.substr(i,8))));
    }
    return retval;
}

//Takes integer and the required length and returns a binary string representation.
//This does no checking to see if the length is long enough to adequately represent the value of the integer
string Base85::ToBinary(long long input, int length)
{
    string output = "";
    for(int i = 1; i <= length; i++)
    {
        output +=  "0";
    }
    for(int i = length - 1; i >= 0; i--)
    {
        long long test = pow(2.0,i);
        if(input >= test)
        {
            output[(length - 1)-i] = '1';
            input -= test;
        }
    
    }
    return output;
}

//Take a string representation of a binary number and return the base10 representation of it.  
//There's no validation of the string
double Base85::ToDoub(string input)
{
    int length = input.length();
    double output = 0;
    double temp = 0;
    for(int i = 0; i < length; i++)
    {
        stringstream ss;
        ss << input[(length - 1) - i];
        ss >> temp;
        output += pow(2.0,i) * temp;
    }
    return output;
}


Main.cpp

using namespace std;

Base85 b85;
vector<unsigned char> test;
string testout;

void printout()
{
    for(int i = 0; i < 4; i++)
    {
        cout << test[i] << " , ";
    }
    cout << endl;
}

int main()
{
  
    test.push_back(18);
    test.push_back(52);
    test.push_back(86);
    test.push_back(120);
    printout();
    testout = b85.EncodeBlock(test, true);
    cout << testout << '\t' << testout.length() << endl;	test.clear();
    test = b85.DecodeBlock(testout);
    printout();
    system("pause");
    return 0;
}