涛行
涛行

AES详细加解密步骤以及AES-128的C++实现

文章目录

    • 用到的矩阵
      • S盒
      • S盒的逆
      • 轮常量矩阵
      • 列混合矩阵
      • 列混合矩阵的逆
  • 加密步骤
    • 对密钥的处理（密钥扩展）
    • 对明文的处理
      • 字节替换
      • 行移位
        • GF(2^8^)上的乘法
      • 列混合
      • 轮密钥加
  • 解密步骤
  • 代码实现
    • 源代码
    • 运行结果
      • 加密
      • 解密

本文详细阐述了AES-128的基本加解密步骤，AES-192与AES-256加解密方式与AES-128一样，只是AES-128运算10轮，AES-192与AES-256分别运算12轮和14轮。

文中用到的示例：

明文：32 43 F6 A8 88 5A 30 8D 31 31 98 A2 E0 37 07 34
密钥：2B 7E 15 16 28 AE D2 A6 AB F7 15 88 09 CF 4F 3C
密文：39 25 84 1D 02 DC 09 FB DC 11 85 97 19 6A 0B 32

用到的矩阵

S盒

/****    0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
		/*0*/{ "63", "7C", "77", "7B", "F2", "6B", "6F", "C5", "30", "01", "67", "2B", "FE", "D7", "AB", "76" },
		/*1*/{ "CA", "82", "C9", "7D", "FA", "59", "47", "F0", "AD", "D4", "A2", "AF", "9C", "A4", "72", "C0" },
		/*2*/{ "B7", "FD", "93", "26", "36", "3F", "F7", "CC", "34", "A5", "E5", "F1", "71", "D8", "31", "15" },
		/*3*/{ "04", "C7", "23", "C3", "18", "96", "05", "9A", "07", "12", "80", "E2", "EB", "27", "B2", "75" },
		/*4*/{ "09", "83", "2C", "1A", "1B", "6E", "5A", "A0", "52", "3B", "D6", "B3", "29", "E3", "2F", "84" },
		/*5*/{ "53", "D1", "00", "ED", "20", "FC", "B1", "5B", "6A", "CB", "BE", "39", "4A", "4C", "58", "CF" },
		/*6*/{ "D0", "EF", "AA", "FB", "43", "4D", "33", "85", "45", "F9", "02", "7F", "50", "3C", "9F", "A8" },
		/*7*/{ "51", "A3", "40", "8F", "92", "9D", "38", "F5", "BC", "B6", "DA", "21", "10", "FF", "F3", "D2" },
		/*8*/{ "CD", "0C", "13", "EC", "5F", "97", "44", "17", "C4", "A7", "7E", "3D", "64", "5D", "19", "73" },
		/*9*/{ "60", "81", "4F", "DC", "22", "2A", "90", "88", "46", "EE", "B8", "14", "DE", "5E", "0B", "DB" },
		/*a*/{ "E0", "32", "3A", "0A", "49", "06", "24", "5C", "C2", "D3", "AC", "62", "91", "95", "E4", "79" },
		/*b*/{ "E7", "C8", "37", "6D", "8D", "D5", "4E", "A9", "6C", "56", "F4", "EA", "65", "7A", "AE", "08" },
		/*c*/{ "BA", "78", "25", "2E", "1C", "A6", "B4", "C6", "E8", "DD", "74", "1F", "4B", "BD", "8B", "8A" },
		/*d*/{ "70", "3E", "B5", "66", "48", "03", "F6", "0E", "61", "35", "57", "B9", "86", "C1", "1D", "9E" },
		/*e*/{ "E1", "F8", "98", "11", "69", "D9", "8E", "94", "9B", "1E", "87", "E9", "CE", "55", "28", "DF" },
		/*f*/{ "8C", "A1", "89", "0D", "BF", "E6", "42", "68", "41", "99", "2D", "0F", "B0", "54", "BB", "16" }

S盒的逆

/****   0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
		/*0*/{"52", "09", "6A", "D5", "30", "36", "A5", "38", "BF", "40", "A3", "9E", "81", "F3", "D7", "FB"},
		/*1*/{"7C", "E3", "39", "82", "9B", "2F", "FF", "87", "34", "8E", "43", "44", "C4", "DE", "E9", "CB"},
		/*2*/{"54", "7B", "94", "32", "A6", "C2", "23", "3D", "EE", "4C", "95", "0B", "42", "FA", "C3", "4E"},
		/*3*/{"08", "2E", "A1", "66", "28", "D9", "24", "B2", "76", "5B", "A2", "49", "6D", "8B", "D1", "25"},
		/*4*/{"72", "F8", "F6", "64", "86", "68", "98", "16", "D4", "A4", "5C", "CC", "5D", "65", "B6", "92"},
		/*5*/{"6C", "70", "48", "50", "FD", "ED", "B9", "DA", "5E", "15", "46", "57", "A7", "8D", "9D", "84"},
		/*6*/{"90", "D8", "AB", "00", "8C", "BC", "D3", "0A", "F7", "E4", "58", "05", "B8", "B3", "45", "06"},
		/*7*/{"D0", "2C", "1E", "8F", "CA", "3F", "0F", "02", "C1", "AF", "BD", "03", "01", "13", "8A", "6B"},
		/*8*/{"3A", "91", "11", "41", "4F", "67", "DC", "EA", "97", "F2", "CF", "CE", "F0", "B4", "E6", "73"},
		/*9*/{"96", "AC", "74", "22", "E7", "AD", "35", "85", "E2", "F9", "37", "E8", "1C", "75", "DF", "6E"},
		/*a*/{"47", "F1", "1A", "71", "1D", "29", "C5", "89", "6F", "B7", "62", "0E", "AA", "18", "BE", "1B"},
		/*b*/{"FC", "56", "3E", "4B", "C6", "D2", "79", "20", "9A", "DB", "C0", "FE", "78", "CD", "5A", "F4"},
		/*c*/{"1F", "DD", "A8", "33", "88", "07", "C7", "31", "B1", "12", "10", "59", "27", "80", "EC", "5F"},
		/*d*/{"60", "51", "7F", "A9", "19", "B5", "4A", "0D", "2D", "E5", "7A", "9F", "93", "C9", "9C", "EF"},
		/*e*/{"A0", "E0", "3B", "4D", "AE", "2A", "F5", "B0", "C8", "EB", "BB", "3C", "83", "53", "99", "61"},
		/*f*/{"17", "2B", "04", "7E", "BA", "77", "D6", "26", "E1", "69", "14", "63", "55", "21", "0C", "7D"}

轮常量矩阵

	{"01", "00", "00", "00"},
	{"02", "00", "00", "00"},
	{"04", "00", "00", "00"},
	{"08", "00", "00", "00"},
	{"10", "00", "00", "00"},
	{"20", "00", "00", "00"},
	{"40", "00", "00", "00"},
	{"80", "00", "00", "00"},
	{"1B", "00", "00", "00"},
	{"36", "00", "00", "00"}

列混合矩阵

AES详细加解密步骤以及AES-128的C++实现_第1张图片

列混合矩阵的逆

AES详细加解密步骤以及AES-128的C++实现_第2张图片

加密步骤

对密钥的处理（密钥扩展）

将密钥K按列优先读取到一个4×4的矩阵中，然后按列分组，将前四列分别命名为k[0] - k[3]，然后向后扩展k[4]、k[5]直至k[43]，接下来就是计算扩展密钥：当k[i]的i不是4的倍数的时候，k[i] = k[i - 1]⨁k[i - 1]，如果i是4的倍数，则需要先将k[i - 1]列进行一轮字循环，然后进行字节替代，得到的结果与k[i - 1]和轮常量矩阵相应轮数的那一列进行抑或，得到的结果就是k[i]，如此反复，得到一个4×44的扩展秘钥矩阵，然后按照4×4一组，划分为K0 - K10共11个矩阵，加密解密均用此矩阵。
例如：前文所述的密钥读到矩阵（K0）之中为：

k[0] k[1] k[2] k[3]
2B 28 AB 09
7E AE F7 CF
15 D2 15 4F
16 A6 88 3C

i为4的倍数以k[4]为例：
由于4是4的倍数，因此计算较麻烦，k[i-1]是k[3]为{09，CF，4F，3C}，左移一位，结果为{CF，4F，3C，09} 1 ◯ \textcircled{1} 1◯，然后根据S盒进行变换得到{8A，84，EB，01} 2 ◯ \textcircled{2} 2◯，最后取轮常量矩阵的第i%4=1列{01，00，00，00} 3 ◯ \textcircled{3} 3◯，将 1 ◯ \textcircled{1} 1◯ 2 ◯ \textcircled{2} 2◯ 3 ◯ \textcircled{3} 3◯抑或得到k[4] = {A0,FA,FE,17}。k[8]、k[12]等等k[4i]同理

i不是4的倍数以k[5]为例：
完整的密钥矩阵为：由于5不是4的倍数，因此直接计算k[i-1] + ◯ \textcircled{+} +◯​k[i-4]，即{A0,FA,FE,17} + ◯ \textcircled{+} +◯​{28,AE,D2,A6} = {88,54,2C,B1}，其他的同理。

最终得到的扩展密钥矩阵如下：

k[0] k[1] k[2] k[3] k[4] k[5] k[6] k[7] k[8] k[9] k[10] k[11] k[12] k[13] k[14] k[15] k[16] k[17] k[18] k[19] k[20] k[21] k[22] k[23] k[24] k[25] k[26] k[27] k[28] k[29] k[30] k[31] k[32] k[33] k[34] k[35] k[36] k[37] k[38] k[39] k[40] k[41] k[42] k[43]
2B 28 AB 09 A0 88 23 2A F2 7A 59 73 3D 47 1E 6D EF A8 B6 DB D4 7C CA 11 6D 11 DB CA 4E 5F 84 4E EA B5 31 7F AC 19 28 57 D0 C9 E1 B6
7E AE F7 CF FA 54 A3 6C C2 96 35 59 80 16 23 7A 44 52 71 0B D1 83 F2 F9 88 0B F9 00 54 5F A6 A6 D2 8D 2B 8D 77 FA D1 5C 14 EE 3F 63
15 D2 15 4F FE 2C 39 76 95 B9 80 F6 47 FE 7E 88 A5 5B 25 AD C6 9D B8 15 A3 3E 86 93 F7 C9 4F DC 73 BA F5 29 66 DC 29 00 F9 25 0C 0C
16 A6 88 3C 17 B1 39 05 F2 43 7A 7F 7D 3E 44 3B 41 7F 3B 00 F8 87 BC BC 7A FD 41 FD 0E F3 B2 4F 21 D2 60 2F F3 21 41 6E A8 89 C8 A6

其中K0为k[0]-k[3]，K1为k[4]-k[7]，以此类推

对明文的处理

首先将明文按列优先保存至4×4的矩阵P中，然后进行初始变换，然后进行9轮循环运算，最后进行一轮最终轮运算之后得到密文。
初始变换：将明文矩阵与K0整体进行抑或（解密过程为与K10抑或）
AES详细加解密步骤以及AES-128的C++实现_第3张图片
例如：将明文读入到矩阵中：

32 88 31 E0
43 5A 31 37
F6 30 98 07
A8 8D A2 34

初始变换的结果为P + ◯ \textcircled{+} +◯​K0

19 A0 9A E9
3D F4 C6 F8
E3 E2 8D 48
BE 2B 2A 08

9轮循环运算：加密过程中为：按顺序进行字节代换、行移位、列混合以及轮密钥加
解密过程中为：按顺序进行列混合、行移位、字节替换以及轮密钥加
最终轮运算：加密过程中为：按顺序进行字节代换、行移位以及轮密钥加
解密过程中为：按顺序进行行移位，字节代换以及轮密钥加

字节替换

对输入矩阵的每一字中的两位，第一位作为行号，第二位作为列号，到S盒（加密用S盒，解密用S盒的逆）中寻找相应的字并替换成新的。
例如：在加密的第一轮过程中，输入的矩阵第一个字为“19”，到S盒中寻找行号为1，列号为9的的字为D4，因此将19替换为D4，第一轮替换的结果为：
AES详细加解密步骤以及AES-128的C++实现_第4张图片

行移位

加密过程中，将第输入矩阵的第2,3,4行分别左移1,2,3位，解密过程中改为右移。
例如：加密第一轮过程中行移位之后的结果为：
AES详细加解密步骤以及AES-128的C++实现_第5张图片

GF(28)上的乘法

A = a0a1a2a3a4a5a6a7a8
01×A = A
02×A：若a0=0，直接左移一位，右侧补0，即 =a1a2a3a4a5a6a7a80
若a0≠0，则左移一位右侧补0后与1B(00011011)抑或
其他乘法可由以上两式推导出来，譬如03(00000011)×A即为(01(00000001) + ◯ \textcircled{+} +◯​ 02(00000010)) ×A = (01×A) + ◯ \textcircled{+} +◯​ (02×A)，04(00000100) = 02×02，09(00001001) = 08 + ◯ \textcircled{+} +◯​ 01，0B(00001011)=08 + ◯ \textcircled{+} +◯​ 02 + ◯ \textcircled{+} +◯​ 01，以此类推

列混合

将输入的矩阵左乘列混合矩阵（解密过程中为左乘列混合矩阵的逆），运算过程中乘法为GF(28)上的乘法，加法为按位异或
例如，第一轮加密过程中列混合后的矩阵为：
AES详细加解密步骤以及AES-128的C++实现_第6张图片

轮密钥加

第i轮就将输入矩阵与Ki矩阵逐字抑或（加解密一样）
例如：加密过程中第一轮，输入矩阵为：
AES详细加解密步骤以及AES-128的C++实现_第7张图片
K1为：
AES详细加解密步骤以及AES-128的C++实现_第8张图片
抑或结果为：

AES详细加解密步骤以及AES-128的C++实现_第9张图片
第二轮至第十轮的运算结果分别为：
AES详细加解密步骤以及AES-128的C++实现_第10张图片
AES详细加解密步骤以及AES-128的C++实现_第11张图片

解密步骤

将密文按列优先读进4×4矩阵，然后进行初始变换，然后进行一轮最终轮运算，最后进行9轮循环运算之后得到密文。

代码实现

源代码

/******************************************************************************************
 * Name: AES.cpp
 * Author: kongtaoxing
 * Time: 2022/10/08
 * Tips: All algebraic operations in this project are performed in the GF(2^8) finite field
 ******************************************************************************************/

#include
#include
#include
#include
using namespace std;

char Sbox[16][16][3] = {
	    /****    0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
		/*0*/{ "63", "7C", "77", "7B", "F2", "6B", "6F", "C5", "30", "01", "67", "2B", "FE", "D7", "AB", "76" },
		/*1*/{ "CA", "82", "C9", "7D", "FA", "59", "47", "F0", "AD", "D4", "A2", "AF", "9C", "A4", "72", "C0" },
		/*2*/{ "B7", "FD", "93", "26", "36", "3F", "F7", "CC", "34", "A5", "E5", "F1", "71", "D8", "31", "15" },
		/*3*/{ "04", "C7", "23", "C3", "18", "96", "05", "9A", "07", "12", "80", "E2", "EB", "27", "B2", "75" },
		/*4*/{ "09", "83", "2C", "1A", "1B", "6E", "5A", "A0", "52", "3B", "D6", "B3", "29", "E3", "2F", "84" },
		/*5*/{ "53", "D1", "00", "ED", "20", "FC", "B1", "5B", "6A", "CB", "BE", "39", "4A", "4C", "58", "CF" },
		/*6*/{ "D0", "EF", "AA", "FB", "43", "4D", "33", "85", "45", "F9", "02", "7F", "50", "3C", "9F", "A8" },
		/*7*/{ "51", "A3", "40", "8F", "92", "9D", "38", "F5", "BC", "B6", "DA", "21", "10", "FF", "F3", "D2" },
		/*8*/{ "CD", "0C", "13", "EC", "5F", "97", "44", "17", "C4", "A7", "7E", "3D", "64", "5D", "19", "73" },
		/*9*/{ "60", "81", "4F", "DC", "22", "2A", "90", "88", "46", "EE", "B8", "14", "DE", "5E", "0B", "DB" },
		/*a*/{ "E0", "32", "3A", "0A", "49", "06", "24", "5C", "C2", "D3", "AC", "62", "91", "95", "E4", "79" },
		/*b*/{ "E7", "C8", "37", "6D", "8D", "D5", "4E", "A9", "6C", "56", "F4", "EA", "65", "7A", "AE", "08" },
		/*c*/{ "BA", "78", "25", "2E", "1C", "A6", "B4", "C6", "E8", "DD", "74", "1F", "4B", "BD", "8B", "8A" },
		/*d*/{ "70", "3E", "B5", "66", "48", "03", "F6", "0E", "61", "35", "57", "B9", "86", "C1", "1D", "9E" },
		/*e*/{ "E1", "F8", "98", "11", "69", "D9", "8E", "94", "9B", "1E", "87", "E9", "CE", "55", "28", "DF" },
		/*f*/{ "8C", "A1", "89", "0D", "BF", "E6", "42", "68", "41", "99", "2D", "0F", "B0", "54", "BB", "16" }
	};// S盒
    
char Sboxni[16][16][3] = {
		/****   0     1     2     3     4     5     6     7     8     9     a     b     c     d     e     f */
		/*0*/{"52", "09", "6A", "D5", "30", "36", "A5", "38", "BF", "40", "A3", "9E", "81", "F3", "D7", "FB"},
		/*1*/{"7C", "E3", "39", "82", "9B", "2F", "FF", "87", "34", "8E", "43", "44", "C4", "DE", "E9", "CB"},
		/*2*/{"54", "7B", "94", "32", "A6", "C2", "23", "3D", "EE", "4C", "95", "0B", "42", "FA", "C3", "4E"},
		/*3*/{"08", "2E", "A1", "66", "28", "D9", "24", "B2", "76", "5B", "A2", "49", "6D", "8B", "D1", "25"},
		/*4*/{"72", "F8", "F6", "64", "86", "68", "98", "16", "D4", "A4", "5C", "CC", "5D", "65", "B6", "92"},
		/*5*/{"6C", "70", "48", "50", "FD", "ED", "B9", "DA", "5E", "15", "46", "57", "A7", "8D", "9D", "84"},
		/*6*/{"90", "D8", "AB", "00", "8C", "BC", "D3", "0A", "F7", "E4", "58", "05", "B8", "B3", "45", "06"},
		/*7*/{"D0", "2C", "1E", "8F", "CA", "3F", "0F", "02", "C1", "AF", "BD", "03", "01", "13", "8A", "6B"},
		/*8*/{"3A", "91", "11", "41", "4F", "67", "DC", "EA", "97", "F2", "CF", "CE", "F0", "B4", "E6", "73"},
		/*9*/{"96", "AC", "74", "22", "E7", "AD", "35", "85", "E2", "F9", "37", "E8", "1C", "75", "DF", "6E"},
		/*a*/{"47", "F1", "1A", "71", "1D", "29", "C5", "89", "6F", "B7", "62", "0E", "AA", "18", "BE", "1B"},
		/*b*/{"FC", "56", "3E", "4B", "C6", "D2", "79", "20", "9A", "DB", "C0", "FE", "78", "CD", "5A", "F4"},
		/*c*/{"1F", "DD", "A8", "33", "88", "07", "C7", "31", "B1", "12", "10", "59", "27", "80", "EC", "5F"},
		/*d*/{"60", "51", "7F", "A9", "19", "B5", "4A", "0D", "2D", "E5", "7A", "9F", "93", "C9", "9C", "EF"},
		/*e*/{"A0", "E0", "3B", "4D", "AE", "2A", "F5", "B0", "C8", "EB", "BB", "3C", "83", "53", "99", "61"},
		/*f*/{"17", "2B", "04", "7E", "BA", "77", "D6", "26", "E1", "69", "14", "63", "55", "21", "0C", "7D"}
	};	// S盒的逆

char Rcon[10][4][3] = {
	{"01", "00", "00", "00"},
	{"02", "00", "00", "00"},
	{"04", "00", "00", "00"},
	{"08", "00", "00", "00"},
	{"10", "00", "00", "00"},
	{"20", "00", "00", "00"},
	{"40", "00", "00", "00"},
	{"80", "00", "00", "00"},
	{"1B", "00", "00", "00"},
	{"36", "00", "00", "00"}
};  // 轮常量矩阵

static int flag_e = 00; //加密循环轮数
static int flag_d = 10; //解密循环轮数

vector<string> MixC = {"02", "01", "01", "03"};
vector<string> MixCni = {"0E", "09", "0D", "0B"};

string encrypt(string p, string k);
string decrypt(string c, string k);
string LowToUpper(string low);  //小写字母转大写字母
string HextoBin(string Hex);  //十六进制转二进制
string BintoHex(string Bin);  //二进制转十六进制
int HexToDec(char Hex);   //十六进制字符转10进制数字
vector<vector<string>> nineRounds(vector<vector<string>> P, vector<vector<string>> K, char ed);   //9轮变换
vector<vector<string>> finalRounds(vector<vector<string>> P, vector<vector<string>> K, char ed);   //最终轮变换
vector<vector<string>> subBytes(vector<vector<string>> P, char ed); // 字节代换
vector<vector<string>> ShiftRows(vector<vector<string>> P);   // 行移位
vector<vector<string>> invShiftRows(vector<vector<string>> P);   // 逆行移位
vector<vector<string>> MixColumns(vector<vector<string>> p, vector<string> MisC);   //列混合
vector<vector<string>> AddRoundKey(vector<vector<string>> P, vector<vector<string>> K, char ed);  //轮密钥加
vector<vector<string>> subKey(vector<vector<string>> k);  //密钥扩展
string hexXor(string a, string b); //16进制抑或
string hexTimes(string a, string b);  //16进制乘法，a为列混合矩阵元素,只取01,02,03
vector<vector<string>> transMatrix(vector<vector<string>> K);   // 转置矩阵

string encrypt(string p, string k) {
	vector<vector<string>> P(4, vector<string>(4, "00"));
	vector<vector<string>> Key(44, vector<string>(4, "00"));
	string ans = "";
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			for(int kk = 0; kk < 2; kk++) {
				P[i][j][kk] = p[(i * 4 + j) * 3 + kk];   //丢弃掉中间的空格，将字符串转换为矩阵
			}
		}
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			for(int kk = 0; kk < 2; kk++) {
				Key[i][j][kk] = k[(i * 4 + j) * 3 + kk];   //丢弃掉中间的空格，将字符串转换为矩阵
			}
		}
	}
	Key = subKey(Key);
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			P[i][j] = hexXor(P[i][j], Key[i][j]);   //初始变换(Initial round)
		}
	}
	P = transMatrix(P);   // 明文矩阵是竖着读进去的，但是需要横着用
	P = nineRounds(P, Key, 'e');   //9轮循环运算
	P = finalRounds(P, Key, 'e');  //最终轮运算
	P = transMatrix(P);  //还原回去
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			ans += P[i][j];
			ans += " ";
		}
	}
	return ans;    // 得到密文
}

string decrypt(string c, string k) {
	vector<vector<string>> C(4, vector<string>(4, "00"));
	vector<vector<string>> Key(44, vector<string>(4, "00"));
	string ans = "";
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			for(int kk = 0; kk < 2; kk++) {
				C[i][j][kk] = c[(i * 4 + j) * 3 + kk];   //丢弃掉中间的空格，将字符串转换为矩阵
			}
		}
	}
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			for(int kk = 0; kk < 2; kk++) {
				Key[i][j][kk] = k[(i * 4 + j) * 3 + kk];   //丢弃掉中间的空格，将字符串转换为矩阵
			}
		}
	}
	Key = subKey(Key);
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			C[i][j] = hexXor(C[i][j], Key[40 + i][j]);   //逆初始变换(Initial round)
		}
	}
	C = transMatrix(C);   // 密文矩阵是竖着读进去的，但是需要横着用
	C = finalRounds(C, Key, 'd');  //最终轮运算
	C = nineRounds(C, Key, 'd');   //9轮循环运算
	C = transMatrix(C); //还原回去
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			ans += C[i][j];
			ans += " ";
		}
	}
	return ans;    // 得到密文
}

vector<vector<string>> subKey(vector<vector<string>> K) {  //密钥扩展
	vector<vector<string>> sKey(44, vector<string>(4, "00"));
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < 4; j++) {
			sKey[i][j] = K[i][j];
		}
	}
	for (int i = 4; i < 44; i++) {
		if (i % 4 != 0) {
			for (int j = 0; j < 4; j++) {
				sKey[i][j] = hexXor(sKey[i - 4][j], sKey[i - 1][j]);
			}
		}
		else {
			vector<string> tempK = sKey[i - 1];  //字循环
			string temp = tempK[0];
			for (int j = 0; j < 3; j++) {
				tempK[j] = tempK[j + 1];
			}
			tempK[3] = temp;
			vector<string> SK = tempK;           //S盒
			for (int j = 0; j < 4; j++) {
				SK[j] = Sbox[HexToDec(tempK[j][0])][HexToDec(tempK[j][1])];
				sKey[i][j] = hexXor(hexXor(sKey[i - 4][j], SK[j]), Rcon[i / 4 - 1][j]);
			}
		}
	}
	return sKey;
}

vector<vector<string>> subBytes(vector<vector<string>> P, char ed) { // 字节代换
	vector<vector<string>> SP(4, vector<string>(4, "00"));
	if (ed == 'e') {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				SP[i][j] = Sbox[HexToDec(P[i][j][0])][HexToDec(P[i][j][1])];  //字节代换(SubBytes)
			}
		}
	}
	else {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				SP[i][j] = Sboxni[HexToDec(P[i][j][0])][HexToDec(P[i][j][1])];  //字节代换(SubBytes)
		}
		}
	}
	return SP;
}

vector<vector<string>> ShiftRows(vector<vector<string>> P) {  // 行移位(ShiftRows)
	for (int i = 1; i < 4; i++) {
		vector<string> temp;
		for (int j = 0; j < i; j++) {
			temp.push_back(P[i][j]);
		}
		for (int j = i; j < 4; j++) {
			P[i][j - i] = P[i][j];
		}
		for (int j = 4 - i; j < 4; j++) {
			P[i][j] = temp[j - (4 - i)];
		}
	}
	return P;
}

vector<vector<string>> invShiftRows(vector<vector<string>> P) {   // 逆行移位
	for (int i = 1; i < 4; i++) {
		vector<string> temp;
		for (int j = 4 - i; j < 4; j++) {
			temp.push_back(P[i][j]);
		}
		for (int j = 3; j >= i; j--) {
			P[i][j] = P[i][j - i];
		}
		for (int j = 0; j < i; j++) {
			P[i][j] = temp[j];
		}
	}
	return P;
}

vector<vector<string>> MixColumns(vector<vector<string>> p, vector<string> A) {   //列混合
	p = transMatrix(p);  //将列转化为行，方便计算
	vector<vector<string>> SP(4, vector<string>(4, "00"));	
	for (int i = 0; i < 4; i++) {  // GF(2^8)上的矩阵乘法
			SP[i][0] = hexXor(hexXor(hexTimes(A[0], p[i][0]), hexTimes(A[3], p[i][1])), hexXor(hexTimes(A[2], p[i][2]), hexTimes(A[1], p[i][3])));
			SP[i][1] = hexXor(hexXor(hexTimes(A[1], p[i][0]), hexTimes(A[0], p[i][1])), hexXor(hexTimes(A[3], p[i][2]), hexTimes(A[2], p[i][3])));
			SP[i][2] = hexXor(hexXor(hexTimes(A[2], p[i][0]), hexTimes(A[1], p[i][1])), hexXor(hexTimes(A[0], p[i][2]), hexTimes(A[3], p[i][3])));
			SP[i][3] = hexXor(hexXor(hexTimes(A[3], p[i][0]), hexTimes(A[2], p[i][1])), hexXor(hexTimes(A[1], p[i][2]), hexTimes(A[0], p[i][3])));
	}
	SP = transMatrix(SP);  //再转化回去
	return SP;
}

vector<vector<string>> AddRoundKey(vector<vector<string>> P, vector<vector<string>> K, char ed) {  //轮密钥加
	P = transMatrix(P);   //轮密钥加要用列，先翻转一下
	vector<vector<string>> ARK(4, vector<string>(4, "00"));
	if (ed == 'e') {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				ARK[i][j] = hexXor(P[i][j], K[flag_e * 4 + i][j]);
			}
		}
	}
	else {
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < 4; j++) {
				ARK[i][j] = hexXor(P[i][j], K[flag_d * 4 + i][j]);
			}
		}
	}
	ARK = transMatrix(ARK);   //再给他翻转回去
	return ARK;
}

vector<vector<string>> nineRounds(vector<vector<string>> P, vector<vector<string>> K, char ed) {  // 9轮变换
	if (ed == 'e') {
		for (int i = 0; i < 9; i++) {
			flag_e++;
			P = subBytes(P, 'e');
			P = ShiftRows(P);
			P = MixColumns(P, MixC);
			P = AddRoundKey(P, K, 'e');
		}
	}
	else {
		for (int i = 0; i < 9; i++) {
			flag_d--;
			P = MixColumns(P, MixCni);
			P = invShiftRows(P);
			P = subBytes(P, 'd');
			P = AddRoundKey(P, K, 'd');
		}
	}
	return P;
}

vector<vector<string>> finalRounds(vector<vector<string>> P, vector<vector<string>> K, char ed) {   //最终轮变换
	if (ed == 'e') {
		flag_e++;
		P = subBytes(P, 'e');
		P = ShiftRows(P);
		P = AddRoundKey(P, K, 'e');
	}
	else {
		flag_d--;
		P = invShiftRows(P);
		P = subBytes(P, 'd');
		P = AddRoundKey(P, K, 'd');
	}
	return P;
}

string HextoBin(string Hex) {
    string Bin = "";
    for(int i = 0; i < Hex.length(); i++) {
        if(Hex[i] == '0') Bin += "0000";
        else if(Hex[i] == '1') Bin += "0001";
        else if(Hex[i] == '2') Bin += "0010";
        else if(Hex[i] == '3') Bin += "0011";
        else if(Hex[i] == '4') Bin += "0100";
        else if(Hex[i] == '5') Bin += "0101";
        else if(Hex[i] == '6') Bin += "0110";
        else if(Hex[i] == '7') Bin += "0111";
        else if(Hex[i] == '8') Bin += "1000";
        else if(Hex[i] == '9') Bin += "1001";
        else if(Hex[i] == 'A') Bin += "1010";
        else if(Hex[i] == 'B') Bin += "1011";
        else if(Hex[i] == 'C') Bin += "1100";
        else if(Hex[i] == 'D') Bin += "1101";
        else if(Hex[i] == 'E') Bin += "1110";
        else Bin += "1111";
    }
    return Bin;
}

string BintoHex(string Bin) {
    string Hex = "";
    for(int i = 0; i < Bin.length() / 4; i++) {
        int num = (Bin[4 * i] - '0') * 8 + (Bin[4 * i + 1] - '0') * 4 + (Bin[4 * i + 2] - '0') * 2 + (Bin[4 * i + 3] - '0');
        if(0 <= num && num <= 9) Hex += (num + '0');
        else if(num == 10) Hex += "A";
        else if(num == 11) Hex += "B";
        else if(num == 12) Hex += "C";
        else if(num == 13) Hex += "D";
        else if(num == 14) Hex += "E";
        else Hex += "F";
    }
    return Hex;
}

string LowToUpper(string low) {
    for(int i = 0; i < low.length(); i++) {
        if(low[i] >= 'a' && low[i] <= 'z') {
            low[i] -= 32;
        }
    }
    return low;
}

int HexToDec(char Hex) {
	if(Hex >= '0' && Hex <= '9')
		return Hex - '0';
	else 
		return Hex - 55;
}

string hexXor(string a, string b) {
	string A = HextoBin(a);
	string B = HextoBin(b);
	string x(A.length(), '0');
	for (int i = 0; i < A.length(); i++) {
		x[i] = (A[i] - '0') ^ (B[i] - '0') + '0';
	}
	return BintoHex(x);
}

string hexTimes(string a, string b) {
	string A = HextoBin(a);
	string B = HextoBin(b);
	string ans(8, '0');
	if (a == "01") {
		return b;
	}
	else if (a == "02") {
		for (int i = 0; i < 7; i++) {
			ans[i] = B[i + 1];
		}
		if (B[0] == '0') {
			return BintoHex(ans);
		}
		else {
			return hexXor(BintoHex(ans), "1B");
		}
	}
	else if (a == "03") {
		return hexXor(hexTimes("02", b), b);
	}
	else if (a == "04") {
		return hexTimes("02", hexTimes("02", b));
	}
    else if (a == "08") {
        return hexTimes("02", hexTimes("04", b));
    }
    else if (a == "09") {
        return hexXor(b, hexTimes("08", b));
    }
    else if (a == "0E") {
        return hexXor(hexTimes("08", b), hexXor(hexTimes("04", b), hexTimes("02", b)));
    }
    else if (a == "0D") {
        return hexXor(hexTimes("09", b), hexTimes("04", b));
    }
    else if (a == "0B") {
        return hexXor(hexTimes("09", b), hexTimes("02", b));
    }
	else {
		cout << "列混合步骤出错，用到了不支持的矩阵乘法，请检查列混合矩阵！" << endl;
		system("pause");
		return 0;
	}
}

vector<vector<string>> transMatrix(vector<vector<string>> K) {
	vector<vector<string>> TK(K[0].size(), vector<string>(K.size(), "00"));
	for (int i =0; i < K.size(); i++) {
		for (int j = 0; j < K[0].size(); j++) {
			TK[j][i] = K[i][j];
		}
	}
	return TK;
}

int main() {
	string PATH;
    string p, c, k;   //明文、密文、密钥
	cout << "-------------------AES-128加/解密工具--------------------" << endl << endl;
    cout << "请输入你想加密还是解密，加密为e，解密为d：";
    string ed;
    cin >> ed;
	cout << "\n请输入文件路径：";
	cin >> PATH;
	fstream File(PATH, ios::out|ios::in);   // 以读取和覆盖的方式打开文件
	if(!File.is_open()){
        cout << "\n打开或创建文件失败，请检查文件是否被占用！\n" << endl;
        system("pause");
        return 0;
    }
	vector<string> textBox;
	while(!File.eof()) {
		string temp;
		getline(File, temp, '\n');
		textBox.push_back(temp);
	}
	File.seekg(0, ios::beg);  // 回到文件头
	if (textBox.size() == 2) {   // 文件中只有明文和密钥
		p = textBox[0];
		k = textBox[1];
		textBox.push_back("");
	}
	else {                       // 文件中有明文、密钥和密文
		p = textBox[0];
		k = textBox[1];
		c = textBox[2];
	}
	k = LowToUpper(k);
	p = LowToUpper(p);
	c = LowToUpper(c);  // 将读入字符全部变为大写，增加健壮性
	if (ed == "e" || ed == "E") {
		c = encrypt(p, k);
		textBox[2] = c;
		for (int i = 0; i < textBox.size(); i++) {
			File << textBox[i];
			if (i != textBox.size() - 1) {
				File << endl;
			}
		}
		cout << "加密成功，密文已保存至源文件最后一行，请到源文件查看！" << endl;
		File.close();   // 及时关闭文件，防止内存泄露
	}
	else if (ed == "d" || ed == "D") {
		p = decrypt(c, k);
		textBox[0] = p;
		for (int i = 0; i < textBox.size(); i++) {
			File << textBox[i];
			if (i != textBox.size() - 1) {
				File << endl;
			}
		}
		cout << "解密成功，明文已保存至源文件第一行，请到源文件查看！" << endl;
		File.close();
	}
	else {
		cout << "参数错误！\n" << endl;
		File.close();  // Close the file
		system("pause");
		return 0;
	}
	system("pause");
	return 0;
}

运行结果

加密

加密前（第一行明文，第二行密钥，第三行密文）：
AES详细加解密步骤以及AES-128的C++实现_第12张图片
加密过程：
AES详细加解密步骤以及AES-128的C++实现_第13张图片
结果：
AES详细加解密步骤以及AES-128的C++实现_第14张图片
3D 71 F7 44 18 02 79 6D 5B 55 21 66 AB 74 DF EF
A4 32 E2 2D 8B BA 53 62 D5 57 19 35 32 5A D1 32
B5 86 4C 93 73 EF D6 CB 89 E8 12 5F 33 E0 7D E6

解密

解密前：
AES详细加解密步骤以及AES-128的C++实现_第15张图片
解密中：
AES详细加解密步骤以及AES-128的C++实现_第16张图片
解密结果：
AES详细加解密步骤以及AES-128的C++实现_第17张图片
与加密对照之后发现一样，程序运行无误

你可能感兴趣的:(密码学,c++,算法)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 高端密码学院笔记285 柚子_b4b4
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
    ?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • Python算法L5：贪心算法 小熊同学哦 Python算法算法python贪心算法
    Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码） mmz1207 c++csp
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • 20个新手学习c++必会的程序 输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
    示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】 汉子萌萌哒 CCFnoi算法数据结构c++
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南c++数据结构stl
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • 继之前的线程循环加到窗口中运行 3213213333332132 javathreadJFrameJPanel
    之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
  • linux 常用命令 BlueSkator linux命令
    1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。 但之前总是习惯于使用 （grep -n 关键字 文件名 ）查出关键字以及该关键字所在的行数，然后再用 （sed -n  '100,200p' 文件名），去查出该关键字之后的日志内容。 但其实还有更简便的办法，就是用（grep  -B n、-A n、-C n 关键
  • php heredoc原文档和nowdoc语法 dcj3sjt126com PHPheredocnowdoc
    <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
  • overflow的属性 周华华 JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • 《我所了解的Java》——总体目录 g21121 java
            准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。         在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。    &n
  • [简单]docx4j常用方法小结 53873039oycg docx
            本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下:         import java.io.File; import java.io.FileInputStream; import ja
  • Spring配置学习 云端月影 spring配置
    首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
  • Java新手入门的30个基本概念三 aijuans java新手java 入门
    17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
  • 《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理IBM活动
    我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
  • PL/SQL的过程编程,异常,声明变量,PL/SQL块 百合不是茶 PL/SQL的过程编程异常PL/SQL块声明变量
    PL/SQL;    过程; 符号; 变量; PL/SQL块; 输出; 异常;     PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
  • Mockito(三)--完整功能介绍 bijian1013 持续集成mockito单元测试
            mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。 一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
  • 精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle数据库plsql
    /* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
  • 【Linux常用命令一】grep命令 bit1129 Linux常用命令
    grep命令格式   grep [option] pattern [file-list]     grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。   pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
  • mybatis3入门学习笔记 白糖_ sqlibatisqqjdbc配置管理
    MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。  MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。   以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
  • Linux 命令神器：lsof 入门 ronin47 lsof
           lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。 有趣的是，lsof也是有着最多
  • java实现两个大数相加，可能存在溢出。 bylijinnan java实现
    import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
  • Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
    Kettle学习资料分享   Kettle 3.2 使用说明书 目录 概述..........................................................................................................................................7 1.Kettle 资源库管
  • [货币与金融]钢之炼金术士 comsci 金融
           自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的        那么随着人类在理论物理和工程物理上面取得的一些突破性进展......        炼金术这个古老
  • Toast原来也可以多样化 dai_lm androidtoast
    Style 1： 默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2： 顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
  • java数据计算的几种解决方法3 datamachine javahadoopibatisr-languer
    4、iBatis     简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。     复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
  • 向网页中插入透明Flash的方法和技巧 dcj3sjt126com htmlWebFlash
    将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。 　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制： 　　注意wmode="transparent"是控制Flash是否透明
  • ios UICollectionView的使用 dcj3sjt126com
    UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。 个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
  • Eos平台java公共逻辑 蕃薯耀 Eos平台java公共逻辑Eos平台java公共逻辑
     Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
  • SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
    与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。   applicationContext-MvcConfig.xml <!-- 启用注解，并定义组件查找规则 ，mvc层只负责扫描@Controller --> <
  • 解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
       使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码， 因此必须综合判断，编写一个工具类：      /** * * @Title: pro
  • 挥洒泪水的青春 lampcy 编程生活程序员
    2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！ 这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
  • 稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
       对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？    笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。    我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
  • 动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScriptiframecontentDocument高度自适应局部刷新
    如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。 但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。 对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
  • 用Rapael做图表 tntxia rap
    function drawReport(paper,attr,data){          var width = attr.width;     var height = attr.height;          var max = 0;   &nbs
  • HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5bootstrap
    <!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他