C++程序实现加密和解密算法的

头文件

#include<bits/stdc++.h>
#include<windows.h>
#define GetGoTo(A) A:
#define GoTo(A) goto A
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
using namespace std;
const string VERSION="V3.2.2"; 
bool EncryptionLock,DecryptionLock,NumberLock;
long long Bin[]={128,64,32,16,8,4,2,1};
long long ProblemNumber;
struct ProblemList{
	string Problem;
	string Types;
	string Source;
	long long data;
}ProblemList_One[500];
void Initialization(bool EncryptionLock,bool DecryptionLock,bool NumberLock){
	srand(time(NULL));
	::EncryptionLock=EncryptionLock;
	::DecryptionLock=DecryptionLock;
	::NumberLock=NumberLock;
	return;
}

string Encryption(string strk,string &keyt){
	if(!EncryptionLock){
		ProblemList_One[ProblemNumber].Problem="You haven't opened EncryptionLock.";
		ProblemList_One[ProblemNumber].Types="Error";
		ProblemList_One[ProblemNumber].Source="<Encryption And Decryption "+VERSION+"> : Encryption(string strk,string &keyt)";
		ProblemList_One[ProblemNumber].data=ProblemNumber++;
		return "";
	}
	for(long long i=0;i<strk.size();i+=2){
		long long rands=rand()%26;
		string l;
		l=char(rands+'A');
		strk.insert(i,l);
	}
	string ans="",ansk="",key="";
	for(long long i=0;i<strk.size();i++){
		long long Ascll_128=strk[i];
		for(long long j=0;j<8;j++){
			long long rands=rand()%2;
			key=key+char(rands+'0');
			if(Bin[j]<=Ascll_128){
				ansk=ansk+char(int(1^rands)+'0');
				Ascll_128-=Bin[j];
			}else{
				ansk=ansk+char(int(0^rands)+'0');
			}
		}
	}
	while(ansk.size()%6!=0){
		ansk="0"+ansk;
	}
	for(long long i=0;i<ansk.size();i+=6){
		long long cnt=0;
		for(long long j=0;j<6;j++){
			cnt=cnt+int(ansk[i+j]-'0')*Bin[j+2];
		}
		ans=ans+char(cnt+'0');
	}
	while(key.size()%6!=0){
		key="0"+key;
	}
	for(long long i=0;i<key.size();i+=6){
		long long cnt=0;
		for(long long j=0;j<6;j++){
			cnt=cnt+int(key[i+j]-'0')*Bin[j+2];
		}
		keyt=keyt+char(cnt+'0');
	}
	return ans;
}

string Decryption(string strk,string key){
	if(!DecryptionLock){
		ProblemList_One[ProblemNumber].Problem="You haven't opened DecryptionLock.";
		ProblemList_One[ProblemNumber].Types="Error";
		ProblemList_One[ProblemNumber].Source="<Encryption And Decryption "+VERSION+"> : Decryption(string strk,string key)";
		ProblemList_One[ProblemNumber].data=ProblemNumber++;
		return "";
	}
	string ans="",Bstrt="",Bkey="";
	for(long long i=0;i<key.size();i++){
		long long Ascll_64=key[i]-'0';
		for(long long j=0;j<6;j++){
			if(Ascll_64>=Bin[j+2]){
				Ascll_64-=Bin[j+2];
				Bkey=Bkey+"1";
			}else{
				Bkey=Bkey+"0";
			}
		}
	}
	for(long long i=0;i<strk.size();i++){
		long long Ascll_64=strk[i]-'0';
		for(long long j=0;j<6;j++){
			if(Ascll_64>=Bin[j+2]){
				Ascll_64-=Bin[j+2];
				Bstrt=Bstrt+"1";
			}else{
				Bstrt=Bstrt+"0";
			}
		}
	}
	while(Bstrt.size()%8!=0){
		Bstrt=Bstrt.substr(1);
	}
	while(Bkey.size()%8!=0){
		Bkey=Bkey.substr(1);
	}
	for(long long i=0;i<Bstrt.size();i++){
		if(Bkey[i]=='1'){
			if(Bstrt[i]=='1') Bstrt[i]='0';
			else Bstrt[i]='1'; 
		}
	}
	for(long long i=0;i<Bstrt.size();i+=8){
		long long cnt=0;
		for(long long j=0;j<8;j++){
			cnt=cnt+int(Bstrt[i+j]-'0')*Bin[j];
		}
		ans=ans+char(cnt);
	}
	string ansk="";
	for(long long i=1;i<ans.size();i+=2){
		ansk=ansk+ans[i];
	}
	return ansk;
}

string Encryption_Number(long long k,string &key){
	if(!EncryptionLock || !NumberLock){
		ProblemList_One[ProblemNumber].Problem="You haven't opened EecryptionLock or NumberLock.";
		ProblemList_One[ProblemNumber].Types="Error";
		ProblemList_One[ProblemNumber].Source="<Encryption And Decryption "+VERSION+"> : Encryption_Number(long long k,string &key)";
		ProblemList_One[ProblemNumber].data=ProblemNumber++;
		return "";
	}
	k=k<<1;
	string kt="",skey="";
	do{
		kt=kt+char(k%10+'0');
		k/=10;
	}while(k);
	string ansk=Encryption(kt,skey);
	key=skey;
	return ansk;
}

int Decryption_Number(string k,string key){
	if(!DecryptionLock || !NumberLock){
		ProblemList_One[ProblemNumber].Problem="You haven't opened DecryptionLock or NumberLock.";
		ProblemList_One[ProblemNumber].Types="Error";
		ProblemList_One[ProblemNumber].Source="<Encryption And Decryption "+VERSION+"> : Decryption_Number(string k,string key)";
		ProblemList_One[ProblemNumber].data=ProblemNumber++;
		return 0;
	}
	string ansk=Decryption(k,key);
	long long kt=0;
	for(long long i=0;i<ansk.size();i++){
		kt=kt*10+(long long)(ansk[i]-'0');
	}
	kt=kt>>1;
	return kt;
}

如何运用

将头文件命名为 Encryption And Decryption V3.2.2.h，并放在与你的代码的同级目录，在你的代码之前加入 #include"Encryption And Decryption V3.2.2.h"，main 函数内加入 Initialization(true,true,true);，注意这里必须是三个 true。

#include"Encryption And Decryption V3.2.2.h"
using namespace std;
int main(){
	Initialization(true,true,true); 
	
	return 0;
}

内置函数

• $\mathtt{string}\mathtt{Encryption}(\mathtt{string}\mathtt{strk},\mathtt{string}\mathtt{key})$
  加密函数，可加密字符串，其中 strk 为明文，key 为密钥，返回值为密文。
• $\mathtt{string}\mathtt{Decryption}(\mathtt{string}\mathtt{strk},\mathtt{string}\mathtt{key})$
  配套 Decryption 的解密函数，可加密字符串，其中 strk 为密文，key 为密钥，返回值为明文。
• $\mathtt{string}\mathtt{Encryptio}{\mathtt{n}}_{\mathtt{N}}\mathtt{umber}(\mathtt{longlong}\mathtt{k},\mathtt{string}\mathtt{key})$
  专门加密数字的函数，同 Encryption 只是换了一下类型。
• $\mathtt{int}\mathtt{Decryptio}{\mathtt{n}}_{\mathtt{N}}\mathtt{umber}(\mathtt{string}\mathtt{k},\mathtt{string}\mathtt{key})$
  专门解密数字的函数，同 Decryption 只是换了一下类型。

---

这段代码是一个实现简单加密和解密算法的C++程序。

以下是代码的简要解释：

1. 代码以包含必要库和定义一些宏和常量开始。

2. Initialization 函数用于初始化加密锁、解密锁和数字锁。

3. Encryption 函数接受一个字符串 strk 和一个字符串 keyt 的引用作为输入，并对输入字符串进行加密。该函数首先检查加密锁是否打开。如果未打开，则将错误消息添加到问题列表中并返回空字符串。否则，它通过在输入字符串的每个字符之间插入随机字符，并使用XOR运算将每个字符的ASCII值转换为二进制表示。

4. Decryption 函数接受一个字符串 strk 和一个字符串 key 作为输入，并对输入字符串进行解密。该函数首先检查解密锁是否打开。如果未打开，则将错误消息添加到问题列表中并返回空字符串。否则，它通过使用密钥中对应的比特对输入字符串中每个字符的二进制表示进行XOR运算，将二进制表示转换回ASCII值。

5. Encryption_Number 函数接受一个 long long 整数 k 和一个字符串 keyt 的引用作为输入，并对数字进行加密。该函数首先检查加密锁和数字锁是否打开。如果未打开，则将错误消息添加到问题列表中并返回空字符串。否则，它将数字转换为二进制表示，对二进制表示进行加密，并将加密后的密钥赋值给 keyt 字符串。

6. Decryption_Number 函数接受一个字符串 k 和一个字符串 key 作为输入，并对加密的数字进行解密。该函数首先检查解密锁和数字锁是否打开。如果未打开，则将错误消息添加到问题列表中并返回0。否则，它使用提供的密钥对输入字符串进行解密，将解密后的二进制表示转换回数字，并返回结果。

请