求个代码，C++，qaq
实现对26个英文字母的编码和译码，设计完成以下功能:1.能够对27个字符进行编码、并存储。
2.利用编码能够实现任意英文句子的编码操作，并存储编码。3.能够将二进制的密码翻译成句子，并将译文存储。
4.能随时查看字母的编码。
5.有能力的同学尽可能使用文件去存储相关内容。
可以给26个字母对应一个密码表，用这个密码表来编码和解码。
运行结果及代码如下：
代码：
#include <iostream>
#include <cstring>
#include <fstream>
using namespace std;
//定义编码表
const char g_code[] = { 'U','>','<','[',']','x','K','c',
'q','=','/','d','y','a','V','b',
'W','T','h','j','|','{','}','^',
'P','R' };
//对英文句子加密，buf是需要编码的字符串，dst是编码后的字符串
void encode(char buf[], char dst[])
{
int i = 0;
int index;
while (buf[i] != '\0')
{
index = buf[i] - 'a';
if (index >= 0 && index <= 25)
dst[i] = g_code[index];
else
dst[i] = buf[i];
i++;
}
dst[i] = 0;//结尾
}
//翻译句子，buf是需要解码的字符串，dst是阶码后的字符串
void decode(char buf[], char dst[])
{
int i = 0, j;
int index = -1;
while (buf[i] != '\0')
{
for (j = 0; j < 26; j++)
{
if (buf[i] == g_code[j])
break;
}
if (j < 26)
dst[i] = 'a' + j;
else
dst[i] = buf[i];
i++;
}
dst[i] = 0; //结尾
}
//写文件
void write2file(char buf[],const char* filename)
{
ofstream os;
os.open(filename, ios::binary);
os.write(buf, strlen(buf));
os.close();
}
//读文件
void readFile(char buf[], const char* filename)
{
ifstream is;
is.open(filename, ios::binary);
if (is.is_open())
{
is.read(buf, 1000);
is.close();
}
else
buf[0] = 0; //字符串结尾
}
int main()
{
int op,i;
char filename[100] = { 0 };
char buf[1000] = { 0 };
char dst[1000] = { 0 };
char zm[27]={0};
//26个英文字母
for (i = 0; i < 26; i++)
zm[i] = 'a' + i;
while (1)
{
system("cls"); //清屏
cout << "1.对26个英文字母编码并存储" << endl;
cout << "2.对任意英文句子进行编码并存储" << endl;
cout << "3.将二进制的密码翻译成句子，并将译文存储" << endl;
cout << "4.查看字母的编码" << endl;
cout << "0.退出" << endl;
cout << "请选择：";
cin >> op;
cin.get(); //吸收回车符
switch (op)
{
case 0:return 0;
case 1:
cout << "请输入存储文件名称：";
cin >> filename;
encode(zm, buf);
write2file(buf, filename);
cout << "已将26个英文字母的编码存储到" << filename << "文件（二进制文件）" << endl;
break;
case 2:
cout << "请输入一条英文句子：" << endl;
cin.getline(buf, 1000); //读取一行
encode(buf, dst);//编码
cout <<"编码后的：" << dst << endl;
cout << "请输入编码保存的文件名：";
cin >> filename;
write2file(dst, filename);
cout <<"已将句子的编码存储到" << filename << "文件（二进制文件）" << endl;
break;
case 3:
cout << "请输入需要译码的文件名(从文件中读取密码)：";
cin >> filename;
readFile(buf, filename);
decode(buf, dst); //译码
cout << "译码后的：" << dst << endl;
cout << "请输入需要保存译码的文件名：";
cin >> filename;
write2file(dst, filename); //将译码存储到文件
break;
case 4:
cout << "26个字母对应的编码表为：" << endl;
for (i = 0; i < 26; i++)
{
cout << (char)zm[i] << " ";
}
cout << endl;
for (i = 0; i < 26; i++)
{
cout << (char)g_code[i] << " ";
}
cout << endl;
break;
}
system("pause");
}
}
base64.cpp
#include "base64.h"
#include <algorithm>
#include <stdexcept>
//
// Depending on the url parameter in base64_chars, one of
// two sets of base64 characters needs to be chosen.
// They differ in their last two characters.
//
static const char* base64_chars[2] = {
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"+/",
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"-_"};
static unsigned int pos_of_char(const unsigned char chr) {
//
// Return the position of chr within base64_encode()
//
if (chr >= 'A' && chr <= 'Z') return chr - 'A';
else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A') + 1;
else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
else if (chr == '+' || chr == '-') return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
else if (chr == '/' || chr == '_') return 63; // Ditto for '/' and '_'
else
//
// 2020-10-23: Throw std::exception rather than const char*
//(Pablo Martin-Gomez, https://github.com/Bouska)
//
throw std::runtime_error("Input is not valid base64-encoded data.");
}
static std::string insert_linebreaks(std::string str, size_t distance) {
//
// Provided by https://github.com/JomaCorpFX, adapted by me.
//
if (!str.length()) {
return "";
}
size_t pos = distance;
while (pos < str.size()) {
str.insert(pos, "\n");
pos += distance + 1;
}
return str;
}
template <typename String, unsigned int line_length>
static std::string encode_with_line_breaks(String s) {
return insert_linebreaks(base64_encode(s, false), line_length);
}
template <typename String>
static std::string encode_pem(String s) {
return encode_with_line_breaks<String, 64>(s);
}
template <typename String>
static std::string encode_mime(String s) {
return encode_with_line_breaks<String, 76>(s);
}
template <typename String>
static std::string encode(String s, bool url) {
return base64_encode(reinterpret_cast<const unsigned char*>(s.data()), s.length(), url);
}
std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
size_t len_encoded = (in_len +2) / 3 * 4;
unsigned char trailing_char = url ? '.' : '=';
//
// Choose set of base64 characters. They differ
// for the last two positions, depending on the url
// parameter.
// A bool (as is the parameter url) is guaranteed
// to evaluate to either 0 or 1 in C++ therefore,
// the correct character set is chosen by subscripting
// base64_chars with url.
//
const char* base64_chars_ = base64_chars[url];
std::string ret;
ret.reserve(len_encoded);
unsigned int pos = 0;
while (pos < in_len) {
ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
if (pos+1 < in_len) {
ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
if (pos+2 < in_len) {
ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
ret.push_back(base64_chars_[ bytes_to_encode[pos + 2] & 0x3f]);
}
else {
ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
ret.push_back(trailing_char);
}
}
else {
ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
ret.push_back(trailing_char);
ret.push_back(trailing_char);
}
pos += 3;
}
return ret;
}
template <typename String>
static std::string decode(String encoded_string, bool remove_linebreaks) {
//
// decode(…) is templated so that it can be used with String = const std::string&
// or std::string_view (requires at least C++17)
//
if (encoded_string.empty()) return std::string();
if (remove_linebreaks) {
std::string copy(encoded_string);
copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
return base64_decode(copy, false);
}
size_t length_of_string = encoded_string.length();
size_t pos = 0;
//
// The approximate length (bytes) of the decoded string might be one or
// two bytes smaller, depending on the amount of trailing equal signs
// in the encoded string. This approximation is needed to reserve
// enough space in the string to be returned.
//
size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
std::string ret;
ret.reserve(approx_length_of_decoded_string);
while (pos < length_of_string) {
//
// Iterate over encoded input string in chunks. The size of all
// chunks except the last one is 4 bytes.
//
// The last chunk might be padded with equal signs or dots
// in order to make it 4 bytes in size as well, but this
// is not required as per RFC 2045.
//
// All chunks except the last one produce three output bytes.
//
// The last chunk produces at least one and up to three bytes.
//
size_t pos_of_char_1 = pos_of_char(encoded_string[pos+1] );
//
// Emit the first output byte that is produced in each chunk:
//
ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char(encoded_string[pos+0]) ) << 2 ) + ( (pos_of_char_1 & 0x30 ) >> 4)));
if ( ( pos + 2 < length_of_string ) && // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
encoded_string[pos+2] != '=' &&
encoded_string[pos+2] != '.' // accept URL-safe base 64 strings, too, so check for '.' also.
)
{
//
// Emit a chunk's second byte (which might not be produced in the last chunk).
//
unsigned int pos_of_char_2 = pos_of_char(encoded_string[pos+2] );
ret.push_back(static_cast<std::string::value_type>( (( pos_of_char_1 & 0x0f) << 4) + (( pos_of_char_2 & 0x3c) >> 2)));
if ( ( pos + 3 < length_of_string ) &&
encoded_string[pos+3] != '=' &&
encoded_string[pos+3] != '.'
)
{
//
// Emit a chunk's third byte (which might not be produced in the last chunk).
//
ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char_2 & 0x03 ) << 6 ) + pos_of_char(encoded_string[pos+3]) ));
}
}
pos += 4;
}
return ret;
}
std::string base64_decode(std::string const& s, bool remove_linebreaks) {
return decode(s, remove_linebreaks);
}
std::string base64_encode(std::string const& s, bool url) {
return encode(s, url);
}
std::string base64_encode_pem (std::string const& s) {
return encode_pem(s);
}
std::string base64_encode_mime(std::string const& s) {
return encode_mime(s);
}
#if __cplusplus >= 201703L
//
// Interface with std::string_view rather than const std::string&
// Requires C++17
// Provided by Yannic Bonenberger (https://github.com/Yannic)
//
std::string base64_encode(std::string_view s, bool url) {
return encode(s, url);
}
std::string base64_encode_pem(std::string_view s) {
return encode_pem(s);
}
std::string base64_encode_mime(std::string_view s) {
return encode_mime(s);
}
std::string base64_decode(std::string_view s, bool remove_linebreaks) {
return decode(s, remove_linebreaks);
}
#endif // __cplusplus >= 201703L
base64.h
#include "base64.h"
#include <algorithm>
#include <stdexcept>
//
// Depending on the url parameter in base64_chars, one of
// two sets of base64 characters needs to be chosen.
// They differ in their last two characters.
//
static const char* base64_chars[2] = {
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"+/",
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789"
"-_"};
static unsigned int pos_of_char(const unsigned char chr) {
//
// Return the position of chr within base64_encode()
//
if (chr >= 'A' && chr <= 'Z') return chr - 'A';
else if (chr >= 'a' && chr <= 'z') return chr - 'a' + ('Z' - 'A') + 1;
else if (chr >= '0' && chr <= '9') return chr - '0' + ('Z' - 'A') + ('z' - 'a') + 2;
else if (chr == '+' || chr == '-') return 62; // Be liberal with input and accept both url ('-') and non-url ('+') base 64 characters (
else if (chr == '/' || chr == '_') return 63; // Ditto for '/' and '_'
else
//
// 2020-10-23: Throw std::exception rather than const char*
//(Pablo Martin-Gomez, https://github.com/Bouska)
//
throw std::runtime_error("Input is not valid base64-encoded data.");
}
static std::string insert_linebreaks(std::string str, size_t distance) {
//
// Provided by https://github.com/JomaCorpFX, adapted by me.
//
if (!str.length()) {
return "";
}
size_t pos = distance;
while (pos < str.size()) {
str.insert(pos, "\n");
pos += distance + 1;
}
return str;
}
template <typename String, unsigned int line_length>
static std::string encode_with_line_breaks(String s) {
return insert_linebreaks(base64_encode(s, false), line_length);
}
template <typename String>
static std::string encode_pem(String s) {
return encode_with_line_breaks<String, 64>(s);
}
template <typename String>
static std::string encode_mime(String s) {
return encode_with_line_breaks<String, 76>(s);
}
template <typename String>
static std::string encode(String s, bool url) {
return base64_encode(reinterpret_cast<const unsigned char*>(s.data()), s.length(), url);
}
std::string base64_encode(unsigned char const* bytes_to_encode, size_t in_len, bool url) {
size_t len_encoded = (in_len +2) / 3 * 4;
unsigned char trailing_char = url ? '.' : '=';
//
// Choose set of base64 characters. They differ
// for the last two positions, depending on the url
// parameter.
// A bool (as is the parameter url) is guaranteed
// to evaluate to either 0 or 1 in C++ therefore,
// the correct character set is chosen by subscripting
// base64_chars with url.
//
const char* base64_chars_ = base64_chars[url];
std::string ret;
ret.reserve(len_encoded);
unsigned int pos = 0;
while (pos < in_len) {
ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
if (pos+1 < in_len) {
ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) + ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
if (pos+2 < in_len) {
ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) + ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
ret.push_back(base64_chars_[ bytes_to_encode[pos + 2] & 0x3f]);
}
else {
ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
ret.push_back(trailing_char);
}
}
else {
ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
ret.push_back(trailing_char);
ret.push_back(trailing_char);
}
pos += 3;
}
return ret;
}
template <typename String>
static std::string decode(String encoded_string, bool remove_linebreaks) {
//
// decode(…) is templated so that it can be used with String = const std::string&
// or std::string_view (requires at least C++17)
//
if (encoded_string.empty()) return std::string();
if (remove_linebreaks) {
std::string copy(encoded_string);
copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
return base64_decode(copy, false);
}
size_t length_of_string = encoded_string.length();
size_t pos = 0;
//
// The approximate length (bytes) of the decoded string might be one or
// two bytes smaller, depending on the amount of trailing equal signs
// in the encoded string. This approximation is needed to reserve
// enough space in the string to be returned.
//
size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
std::string ret;
ret.reserve(approx_length_of_decoded_string);
while (pos < length_of_string) {
//
// Iterate over encoded input string in chunks. The size of all
// chunks except the last one is 4 bytes.
//
// The last chunk might be padded with equal signs or dots
// in order to make it 4 bytes in size as well, but this
// is not required as per RFC 2045.
//
// All chunks except the last one produce three output bytes.
//
// The last chunk produces at least one and up to three bytes.
//
size_t pos_of_char_1 = pos_of_char(encoded_string[pos+1] );
//
// Emit the first output byte that is produced in each chunk:
//
ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char(encoded_string[pos+0]) ) << 2 ) + ( (pos_of_char_1 & 0x30 ) >> 4)));
if ( ( pos + 2 < length_of_string ) && // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
encoded_string[pos+2] != '=' &&
encoded_string[pos+2] != '.' // accept URL-safe base 64 strings, too, so check for '.' also.
)
{
//
// Emit a chunk's second byte (which might not be produced in the last chunk).
//
unsigned int pos_of_char_2 = pos_of_char(encoded_string[pos+2] );
ret.push_back(static_cast<std::string::value_type>( (( pos_of_char_1 & 0x0f) << 4) + (( pos_of_char_2 & 0x3c) >> 2)));
if ( ( pos + 3 < length_of_string ) &&
encoded_string[pos+3] != '=' &&
encoded_string[pos+3] != '.'
)
{
//
// Emit a chunk's third byte (which might not be produced in the last chunk).
//
ret.push_back(static_cast<std::string::value_type>( ( (pos_of_char_2 & 0x03 ) << 6 ) + pos_of_char(encoded_string[pos+3]) ));
}
}
pos += 4;
}
return ret;
}
std::string base64_decode(std::string const& s, bool remove_linebreaks) {
return decode(s, remove_linebreaks);
}
std::string base64_encode(std::string const& s, bool url) {
return encode(s, url);
}
std::string base64_encode_pem (std::string const& s) {
return encode_pem(s);
}
std::string base64_encode_mime(std::string const& s) {
return encode_mime(s);
}
#if __cplusplus >= 201703L
//
// Interface with std::string_view rather than const std::string&
// Requires C++17
// Provided by Yannic Bonenberger (https://github.com/Yannic)
//
std::string base64_encode(std::string_view s, bool url) {
return encode(s, url);
}
std::string base64_encode_pem(std::string_view s) {
return encode_pem(s);
}
std::string base64_encode_mime(std::string_view s) {
return encode_mime(s);
}
std::string base64_decode(std::string_view s, bool remove_linebreaks) {
return decode(s, remove_linebreaks);
}
#endif // __cplusplus >= 201703L
测试验证test_time.cpp
#include "base64.h"
#include <iostream>
#include <chrono>
int main() {
const std::string lorem_ipsum =
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus consectetur\n"
"eros eros, eu aliquet massa fermentum eu. Vestibulum vehicula imperdiet est ut\n"
"efficitur. Quisque at urna commodo, semper tortor sed, varius orci. Nulla\n"
"commodo neque urna, nec fermentum eros posuere quis. Ut facilisis lacus vitae\n"
"congue sagittis. Donec ac eros in justo ornare bibendum. Ut mollis consequat\n"
"quam, id egestas mauris rutrum at. Donec condimentum rutrum turpis, non\n"
"pulvinar mi. Donec tincidunt, ligula pulvinar iaculis dignissim, arcu dolor\n"
"dignissim ipsum, ac viverra ipsum orci vitae nunc. Pellentesque ut gravida\n"
"velit. Etiam enim velit, maximus eu mauris eu, tincidunt ultrices est. Class\n"
"aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos\n"
"himenaeos. Sed maximus nunc ut tempor porta. Suspendisse lacinia scelerisque\n"
"nunc, sit amet iaculis lacus dictum ac. Nunc feugiat venenatis tortor, eget\n"
"congue magna. Morbi sagittis pulvinar odio. Pellentesque habitant morbi\n"
"tristique senectus et netus et malesuada fames ac turpis egestas. Vestibulum\n"
"sit amet aliquet neque. Praesent venenatis orci sed nibh pulvinar scelerisque.\n"
"Curabitur dapibus cursus lorem, non lacinia arcu luctus at. Nullam accumsan\n"
"facilisis nisl, a lacinia leo tempus et. Nulla facilisi. Morbi placerat\n"
"elementum mauris vel malesuada. Aliquam egestas porta massa, id vehicula nibh\n"
"tincidunt quis. Cras tortor massa, pharetra nec molestie non, pellentesque et\n"
"tellus. Ut id ante mattis, condimentum risus in, placerat magna. Sed faucibus\n"
"nulla lorem, sit amet aliquet lorem tincidunt finibus. Aliquam erat volutpat.\n"
"Vestibulum maximus ut risus ac eleifend. Curabitur id neque massa. Mauris\n"
"euismod suscipit elementum. Sed consectetur ex in ante eleifend consequat.\n"
"Vivamus lectus dolor, posuere vitae metus eu, lobortis hendrerit sapien. Donec\n"
"nisi elit, pulvinar non diam at, pretium convallis ante. Quisque nec pulvinar\n"
"velit, vel placerat nunc. Cras sed tellus in lorem vehicula dapibus. Nunc non\n"
"dignissim ligula. Cras imperdiet porta iaculis. Nulla pulvinar porta est,\n"
"suscipit auctor nisl sodales vel. Maecenas scelerisque dignissim erat, quis\n"
"semper tortor. Nam sed tincidunt urna. Quisque maximus sed erat et pulvinar.\n"
"Pellentesque viverra maximus ultrices. Donec blandit dictum enim vel\n"
"pellentesque. Sed nec sodales nunc. Nullam lacinia mattis lacus a dapibus.\n"
"Proin ut erat vestibulum, semper massa maximus, tempor risus. Donec vulputate\n"
"eget turpis ac placerat. Quisque gravida tellus nec diam mollis scelerisque.\n"
"Nullam egestas pellentesque dictum. Suspendisse quis ex justo. Pellentesque id\n"
"nisi dapibus, convallis augue sit amet, rhoncus neque. Maecenas et justo velit.\n"
"Mauris et sollicitudin arcu, porta posuere urna. Mauris vestibulum elit eu enim\n"
"pretium, eu blandit metus lobortis. Phasellus sit amet mollis odio. Mauris\n"
"vehicula at nunc at mattis. Morbi non justo sapien. Mauris sodales, justo in\n"
"hendrerit pellentesque, orci metus suscipit erat, a suscipit arcu justo ut\n"
"ipsum. Duis eget nisl quam. Aenean vulputate, odio at scelerisque ultricies,\n"
"mauris enim elementum purus, non cursus enim neque sed mauris. Nulla suscipit\n"
"risus at ipsum efficitur vestibulum. Phasellus non eleifend urna. Quisque\n"
"dapibus turpis et dignissim tempor. Integer pulvinar est sit amet mollis\n"
"accumsan. Nunc vel massa maximus, ullamcorper turpis eget, elementum sem. Sed\n"
"faucibus vulputate velit, vitae cursus nunc suscipit at. Maecenas justo ante,\n"
"lacinia vel fermentum ac, mattis in orci. Duis aliquet tincidunt congue. Sed\n"
"nec velit felis. Fusce pulvinar pharetra elit, et dictum dolor sagittis a. In\n"
"hac habitasse platea dictumst. Morbi ac ligula vel mauris pellentesque rutrum.\n"
"Aliquam vitae velit imperdiet, facilisis lectus id, ultricies dui. Vivamus\n"
"porttitor, sapien non mattis lacinia, velit nisi dapibus arcu, vel euismod mi\n"
"diam vitae mauris. Vestibulum rhoncus auctor nunc, ac imperdiet nisi\n"
"vestibulum at. Fusce odio enim, interdum eget leo viverra, gravida aliquet\n"
"lorem. Praesent faucibus viverra ligula vel convallis. In hac habitasse platea\n"
"dictumst. Proin nec mi eget arcu porttitor consectetur eu eget ante. In sed\n"
"placerat lacus, eget scelerisque arcu. Phasellus sed blandit lectus, tincidunt\n"
"efficitur libero. Proin tincidunt lorem vulputate elit egestas mattis. Maecenas\n"
"efficitur rhoncus diam eu consectetur. Nam maximus vulputate nulla a auctor.\n"
"Aenean a velit tempus, pellentesque est dictum, eleifend tortor. Mauris quis\n"
"nulla nisi. Morbi ac arcu condimentum, eleifend libero molestie, accumsan nisl.\n"
"Suspendisse eu volutpat dolor. Etiam sodales sapien ut nunc iaculis, id viverra\n"
"lorem aliquet. Aliquam erat volutpat. Sed libero leo, sodales vel malesuada et,\n"
"volutpat a est. Cras faucibus felis eget cursus feugiat. Nullam ac sapien nec\n"
"nisl pulvinar sagittis vel sed risus. Ut nec lobortis arcu. Nullam ac cursus\n"
"nisi, eu auctor lectus. In hac habitasse platea dictumst. Morbi id lorem sed\n"
"velit venenatis laoreet. Aenean diam massa, congue quis lorem finibus, egestas\n"
"pellentesque lacus. Duis eget turpis in nisi efficitur consequat. Integer ipsum\n"
"mi, commodo ut purus vitae, dictum dignissim urna. Cras tempor ligula rhoncus\n"
"magna fermentum dignissim. Duis posuere tortor ante, nec tristique urna pretium\n"
"in. Quisque suscipit, sapien eu malesuada placerat, ipsum ante consectetur ex,\n"
"a mollis enim orci sed orci. Proin placerat mi nec interdum interdum. Quisque\n"
"lorem libero, vehicula eu facilisis quis, accumsan eu lacus. Sed sed orci ac\n"
"nisl sodales hendrerit vel ut mauris. Donec condimentum nec elit id feugiat.\n"
"Etiam placerat sollicitudin lorem sed consequat. Quisque iaculis porta dolor\n"
"sed placerat. In hendrerit ac felis eu bibendum. Suspendisse potenti. Aliquam\n"
"erat volutpat. Vestibulum condimentum justo erat, ornare varius lectus maximus\n"
"id. Cras commodo lacus ante, vel imperdiet dui facilisis et. Praesent placerat\n"
"diam quis diam pellentesque, ac tincidunt elit luctus. Vestibulum ac orci odio.\n"
"Pellentesque lobortis elit at semper fringilla. Duis vel tellus id tortor\n"
"commodo elementum in id ligula. Integer diam lorem, mattis sit amet sem non,\n"
"mattis maximus leo. Nunc mattis nulla eu purus vehicula luctus. Aenean\n"
"tristique a eros quis aliquet. Cras quis arcu libero. Sed ac tortor eu turpis\n"
"maximus dignissim. Sed vel sapien eget est blandit pulvinar a quis ipsum. In\n"
"consequat vehicula nulla, vitae aliquam sapien ultrices sit amet. Sed faucibus\n"
"augue non ipsum dictum maximus. Curabitur eu odio porttitor, ultrices libero\n"
"at, gravida purus. Phasellus tincidunt libero at ante congue, id dapibus ipsum\n"
"scelerisque. Nulla feugiat sed nibh vitae pulvinar. Vivamus id eros augue. Ut\n"
"scelerisque elementum massa, ut condimentum quam venenatis nec. Mauris eget\n"
"felis vel ligula viverra consectetur. Donec condimentum nec odio ac hendrerit.\n"
"Ut rhoncus nec ipsum rhoncus dignissim. Proin sed nulla auctor, accumsan enim\n"
"vitae, ornare ex. Phasellus et condimentum tellus. Vivamus auctor est eu\n"
"consectetur luctus. Integer ac eros vel dolor tempus tristique a in lacus.\n"
"Pellentesque eget pulvinar neque, in finibus nulla. Donec scelerisque massa a\n"
"tortor ultricies, id ullamcorper ligula ullamcorper. Nam eget tempor erat. Nam\n"
"pharetra consequat velit, in imperdiet nunc aliquam vel. Proin ut nisi\n"
"tristique, ullamcorper leo sed, venenatis tellus. Sed consequat felis purus,\n"
"quis pellentesque nulla facilisis nec. Cras eu ullamcorper velit. Vivamus non\n"
"dui tristique, finibus odio ut, mollis est. Mauris at aliquam mauris. Donec id\n"
"luctus turpis, suscipit porttitor nulla. Vivamus condimentum sem et velit\n"
"feugiat elementum. Pellentesque vehicula turpis in massa consectetur luctus.\n"
"Etiam interdum rhoncus blandit. Fusce in nisl vitae odio accumsan condimentum.\n"
"Nam dignissim, odio a tincidunt malesuada, sem purus lobortis dui, eu rhoncus\n"
"mi leo ac enim. Integer tincidunt turpis eros. Quisque sollicitudin sodales\n"
"mauris, vitae lacinia orci commodo vitae. Curabitur malesuada mattis luctus.\n"
"Nullam quis magna consequat, consequat nisl nec, blandit nunc. Aliquam eget\n"
"tristique urna. Nulla odio sem, aliquam sed ultricies lacinia, egestas tempor\n"
"enim. Morbi quis dapibus nisl, sit amet elementum nibh. Vestibulum ante ipsum\n"
"primis in faucibus orci luctus et ultrices posuere cubilia curae; Nam tincidunt\n"
"a sem eget sollicitudin. Morbi et nisi accumsan lorem congue lobortis. Cras\n"
"tempus ligula sit amet neque elementum, eget dictum nulla aliquet. Integer\n"
"ultrices ligula vel tellus luctus, non porta quam vulputate. Nam mattis quis\n"
"nisl a auctor. Quisque sed lacus eget dui tempor scelerisque ut ut quam. Nam\n"
"nec tempor justo. Sed eget varius risus. Duis placerat auctor ornare. Ut\n"
"interdum maximus aliquam. Maecenas volutpat risus non pellentesque\n"
"scelerisque. Maecenas finibus tempor sollicitudin. Nunc malesuada rhoncus quam\n"
"non luctus. Integer facilisis mauris in nunc viverra, sit amet lobortis leo\n"
"gravida. Nam ut magna congue, tincidunt nisl id, ullamcorper urna. Praesent\n"
"ultricies ipsum sed lorem sagittis mollis. Sed varius arcu ac nibh ornare, vel\n"
"consectetur nibh congue. Phasellus quis ligula ligula. Quisque volutpat lectus\n"
"sed gravida auctor. Etiam placerat fringilla quam, vel facilisis lorem\n"
"imperdiet nec. Sed massa turpis, finibus vitae pretium ut, laoreet interdum\n"
"leo. Mauris vitae orci dui. Fusce eu odio lacinia, accumsan lectus nec, laoreet\n"
"dolor. Pellentesque dui turpis, iaculis ut est sed, tincidunt molestie quam.\n"
"Phasellus maximus rhoncus magna eu interdum. Fusce venenatis at nunc vestibulum\n"
"congue. Curabitur ut imperdiet leo. Nulla eu neque rutrum, volutpat ante eu,\n"
"posuere eros. Ut sed tempus mauris. Vestibulum mollis libero at turpis aliquet,\n"
"luctus commodo libero posuere. Praesent porttitor vel odio et sagittis. Lorem\n"
"ipsum dolor sit amet, consectetur adipiscing elit. Cras a ante ac ex lobortis\n"
"sollicitudin non quis nulla. Etiam tincidunt leo fringilla, suscipit dolor nec,\n"
"semper nibh. Donec mattis metus et tortor pulvinar pulvinar. Maecenas quis\n"
"varius dolor. Proin convallis lorem varius egestas auctor. Duis et quam eu\n"
"ipsum scelerisque commodo. Donec et sollicitudin mauris. Praesent iaculis\n"
"faucibus diam, id pharetra nunc egestas vel. Nulla ultricies quam et augue\n"
"pellentesque ultrices. Suspendisse in nulla ullamcorper, lacinia sapien non,\n"
"tristique enim. Donec iaculis sollicitudin scelerisque. Morbi lorem purus,\n"
"consectetur et cursus ac, interdum sit amet nulla. In ullamcorper placerat\n"
"velit nec aliquet. Nunc non tincidunt nibh, eget rhoncus justo. Sed sit amet\n"
"libero neque.\n"
;
auto time_encoding_begin = std::chrono::system_clock::now();
std::string encoded = base64_encode(reinterpret_cast<const unsigned char*>(lorem_ipsum.c_str()), lorem_ipsum.length());
auto time_encoding_end = std::chrono::system_clock::now();
auto time_decoding_begin = std::chrono::system_clock::now();
std::string decoded = base64_decode(encoded);
auto time_decoding_end = std::chrono::system_clock::now();
std::chrono::duration<double> duration_encoding = time_encoding_end - time_encoding_begin;
std::chrono::duration<double> duration_decoding = time_decoding_end - time_decoding_begin;
std::cout << "Encoding took: " << duration_encoding.count() << std::endl;
std::cout << "Decoding took: " << duration_decoding.count() << std::endl;
if (decoded != lorem_ipsum) {
std::cout << "Strings differ!" << std::endl;
return 1;
}
return 0;
}