1.txt

写一个对文本文件加密的程序和一个解密的程序。密码规则是：对于小写字母

#ifndef __MATRIX_DOT_H__ 
#define __MATRIX_DOT_H__ 

template <class T> 
void Swap(T& a, T& b) 
{ 
T temp; 

temp = a; 
a = b; 
b = temp; 
} 

class CMatrix 
{ 
static double ZERO;//极小值 
public: 
CMatrix(int row = 3, int col = 3); // 
CMatrix(const CMatrix& right); //拷贝构造函数 
~CMatrix(); 
void Show(const char* pre = NULL)const; //输出矩阵 
void Free(); 
int Resize(int row, int col); //重新定义矩阵大小 
int GetRow()const{ return m_iRow; } //返回矩阵行数 
int GetCol()const{ return m_iCol; } //返回矩阵列数 
int RowSwap(int x, int y); //行交换,成功返回1，否则0 
int ColSwap(int x, int y); //列交换 
static void SetZero(double z); //设定ZERO的值,所有CMatrix实例精度都将改变 

const CMatrix Transpose()const; //返回转置矩阵 
const CMatrix Adjoint()const; //伴随矩阵 
const CMatrix Residue(int row, int col)const;//求对应元素的余子式 
const CMatrix Contrary()const;//逆矩阵 
const CMatrix Gauss_Jordan(double* pDet = NULL)const;//逆矩阵(高斯-约旦法),pDet为行列式, 
//此法精度较低,但效率较高 
double Residue_a(int row, int col)const;//求对应元素的代数余子式 
double Determinant()const; //返回方阵的行列式 
double Det_Recursion()const; //返回方阵的行列式(递归) 

int IsZero()const; //判断元素是否全为0(零矩阵) 
int IsPhalanx()const; //判断是否为方阵 
int IsReverse()const; //判断矩阵是否可逆 
int IsNonfunnyPhalanx()const; //判断是否非奇异方阵 

double* operator[](int i)const; //操作单个元素 
CMatrix& operator=(const CMatrix& right); 
CMatrix& operator=(const double* pRight); 
CMatrix& operator=(const double** ppRight); 
const CMatrix& operator+()const; //一元操作符 
const CMatrix operator-()const; //一元操作符 
const CMatrix operator+(const CMatrix& right)const; 
const CMatrix operator-(const CMatrix& right)const; 
const CMatrix operator*(const CMatrix& right)const; 
const CMatrix operator*(const double& right)const; 
const CMatrix operator/(const double& right)const; 
CMatrix& operator+=(const CMatrix& right); 
CMatrix& operator-=(const CMatrix& right); 
CMatrix& operator*=(const CMatrix& right); 
CMatrix& operator*=(const double& right); 
CMatrix& operator/=(const double& right); 
int operator==(const CMatrix& right)const; 
int operator!=(const CMatrix& right)const; 

private: 
int m_iRow; //行数 
int m_iCol; //列数 
double** m_ppData; //数据 
}; 

#endif //__MATRIX_DOT_H__ 

//matrix.cpp 
// 

#include <windows.h> 
#include <stdio.h> 
#include <math.h> 
#include <string.h> 
#include <assert.h> 
#include "matrix.h" 

double CMatrix::ZERO = 1e-10; 

CMatrix::CMatrix(int row/*=3*/, int col/*=3*/) 
{ 
m_ppData = NULL; 
Resize(row, col); 
} 

//拷贝构造函数 
CMatrix::CMatrix(const CMatrix& right) 
{ 
m_ppData = NULL;//一定要加这句初始化(一个对象不会同时调用构造函数和拷贝构造函数) 

Resize(right.GetRow(), right.GetCol()); 
for(int i = 0; i < right.GetRow(); i++) 
{ 
for(int j = 0; j < right.GetCol(); j++) 
m_ppData[i][j] = right[i][j]; 
} 
} 

CMatrix::~CMatrix() 
{ 
Free(); 
} 

void CMatrix::Free() 
{ 
if(m_ppData != NULL){ 
for(int i = 0; i < m_iRow; i++) 
{ 
if(m_ppData[i] != NULL) 
delete[] m_ppData[i]; 
m_ppData[i] = NULL; 
} 
m_ppData = NULL; 
} 
} 

int CMatrix::Resize(int row, int col) 
{ 
assert(row > 0 && col > 0); 

//释放空间 
Free(); 

//申请空间 
m_iRow = row; 
m_iCol = col; 
m_ppData = new double*[m_iRow]; 
assert(m_ppData != NULL); 
for(int i = 0; i < m_iRow; i++) 
{ 
m_ppData[i] = new double[m_iCol]; 
assert(m_ppData[i] != NULL); 
} 

//初始化 
for(i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_ppData[i][j] = 0; 
} 
return 1; 
} 

//zero 
void CMatrix::SetZero(double z) 
{ 
double zero = fabs(z); 
if(zero > 1.0f) return; 

ZERO = zero; 
} 

//show 
void CMatrix::Show(const char* pre/*=NULL*/)const 
{ 
int i, j; 
#ifdef _WINDOWS 
if(m_iRow > 10 || m_iCol > 10) 
MessageBox(NULL, "矩阵数据量太大，不能输出", "警告", MB_OK); 

char buf[4096]; 
char temp[256]; 

strcpy(buf, ""); 
if(pre != NULL) 
{ 
strcpy(buf, pre); 
strcat(buf, "\n"); 
} 

for(i = 0; i < m_iRow; i++) 
{ 
for(j = 0; j < m_iCol; j++) 
{ 
sprintf(temp, "%.3f\t", m_ppData[i][j]); 
strcat(buf, temp); 
} 
strcat(buf, "\n"); 
} 
MessageBox(NULL, buf, "提示信息", MB_OK); 
#else 
if(pre != NULL) 
puts(pre); 
for(i = 0; i < m_iRow; i++) 
{ 
for(j = 0; j < m_iCol; j++) 
printf("%f\t", m_ppData[i][j]); 
printf("\n"); 
} 
#endif //_WINDOWS 
} 

///////////////////////////////////////计算////////////////////////////////////// 

//行交换 
int CMatrix::RowSwap(int x, int y) 
{ 
if(x < 0 || x >= m_iRow || y < 0 || y >= m_iRow) 
return 0; 
if(x == y) 
return 1; 
for(int i = 0; i < m_iCol; i++) 
{ 
Swap(m_ppData[x][i], m_ppData[y][i]); 
} 
return 1; 
} 

//列交换 
int CMatrix::ColSwap(int x, int y) 
{ 
if(x < 0 || x >= m_iCol || y < 0 || y >= m_iCol) 
return 0; 
if(x == y) 
return 1; 
for(int i = 0; i < m_iRow; i++) 
{ 
Swap(m_ppData[i][x], m_ppData[i][y]); 
} 
return 1; 
} 

//转置 
const CMatrix CMatrix::Transpose()const 
{ 
CMatrix tr(m_iCol, m_iRow); 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
tr[j][i] = m_ppData[i][j]; 
} 
return tr; 
} 

//计算方阵的行列式(精度不高) 
double CMatrix::Determinant()const 
{ 
assert(m_iRow == m_iCol); 

CMatrix temp = *this; 
int i,j,m,n,s,t,k=1; 
double f=1,c,x,sn; 

for (i=0,j=0; i<m_iRow&&j<m_iRow; i++,j++) 
{ 
if (temp[i][j]==0) 
{ 
for (m = i;m < m_iRow; m++) 
{ 
if(fabs(temp[m][j]) > ZERO)//0 
break; 
} 

if (m == m_iRow) 
{ 
return 0; 
} 
else 
for (n = j; n < m_iRow; n++) 
{ 
c = temp[i][n]; 
temp[i][n] = temp[m][n]; 
temp[m][n] = c; 
} 
k *= (-1); 
} 
for (s = m_iRow-1; s>i; s--) 
{ 
x = temp[s][j]; 
for (t = j; t < m_iRow; t++) 
temp[s][t] -= temp[i][t] * (x/temp[i][j]); 
} 
} 
for (i = 0; i < m_iRow; i++) 
f *= temp[i][i]; 
sn = k * f; 

return sn; 
} 

//行列式(递归，精度较高) 
double CMatrix::Det_Recursion()const 
{ 
assert(m_iRow == m_iCol); 

CMatrix temp; 
double ans = 0; 

if(m_iRow == 1) 
{ 
return m_ppData[0][0]; 
} 
else if(m_iRow == 2) 
{ 
return m_ppData[0][0]*m_ppData[1][1] - m_ppData[1][0]*m_ppData[0][1]; 
} 
else 
{ 
for(int i = 0; i < m_iRow; i++) 
{ 
temp = Residue(i, 0);//this->Residue(i, 0) 
ans += temp.Det_Recursion()*m_ppData[i][0]*pow(-1, i); 
} 
} 

return ans; 
} 

//计算方阵的余子式 
const CMatrix CMatrix::Residue(int row, int col)const 
{ 
CMatrix re; 
int index = 0; 

assert(m_iRow == m_iCol); 
assert(m_iRow >= 2); 
assert(row < m_iRow && col < m_iCol); 
assert(row >= 0 && col >= 0); 
double* pData = NULL; 
pData = new double[(m_iRow-1)*(m_iCol-1)]; 
assert(pData != NULL); 
re.Resize(m_iRow-1, m_iCol-1); 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
if(i != row && j != col) 
pData[index++] = m_ppData[i][j]; 
} 
re = pData; 

delete[] pData; 
pData = NULL; 
return re; 
} 

//计算方阵的代数余子式 
double CMatrix::Residue_a(int row, int col)const 
{ 
return (Residue(row, col)).Det_Recursion()*pow(-1, row+col); 
} 

//伴随矩阵 
const CMatrix CMatrix::Adjoint()const 
{ 
CMatrix ad(m_iRow, m_iCol); 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
ad[j][i] = Residue_a(i, j); 
} 
return ad; 
} 

//逆矩阵 
const CMatrix CMatrix::Contrary()const 
{ 
assert(IsReverse()); 

CMatrix co(m_iRow, m_iCol); 
co = Adjoint();//this 
co /= Det_Recursion();//this 

return co; 
} 

//高斯-约旦法求逆矩阵(全选主元), pDet为原方阵的行列式 
const CMatrix CMatrix::Gauss_Jordan(double* pDet/*=NULL*/)const 
{ 
assert(IsReverse()); 

double fDet = 1.0f; 
int flag = 1; 
int k = 0, i = 0, j = 0; 
CMatrix out(m_iRow, m_iCol);//逆 
CMatrix m = *this;//原 
CMatrix rhs(2, m_iRow);//保存主元素位置,0 i, 1 j; 

for(k = 0; k < m_iRow; k++) 
{ 
//第一步：全选主元 
double fMax = 0.0f; 
for(i = 0; i < m_iRow; i++) 
{ 
for(j = 0; j < m_iCol; j++) 
{ 
const double f = fabs(m[i][j]); 
if(f > fMax) 
{ 
fMax = f; 
rhs[0][k] = i; 
rhs[1][k] = j; 
} 
} 
} 
//if(fMax < 0.00001)//元素全为0 
//{ 
// fDet = 0.0f; 
// return out; 
//} 
if((int)rhs[0][k] != k) 
{ 
flag = -flag; 
m.RowSwap((int)rhs[0][k], k); 
} 
if((int)rhs[1][k] != k) 
{ 
flag = -flag; 
m.ColSwap((int)rhs[1][k], k); 
} 

//计算行列值 
fDet *= m[k][k]; 

//计算逆矩阵 
//第二步 
m[k][k] = 1.0f/m[k][k]; 

//第三步 
for(j = 0; j < m_iCol; j++) 
{ 
if(j != k) 
m[k][j] *= m[k][k]; 
} 

//第四步 
for(i = 0; i < m_iRow; i++) 
{ 
if(i != k) 
{ 
for(j = 0; j < m_iCol; j++) 
{ 
if(j != k) 
m[i][j] = m[i][j] - m[i][k]*m[k][j]; 
} 
} 
} 

//第五步 
for(i = 0; i < m_iRow; i++) 
{ 
if(i != k) 
{ 
m[i][k] *= -m[k][k]; 
} 
} 
}//end for(k); 

for(k = m_iRow-1; k >= 0; k--) 
{ 
if((int)rhs[1][k] != k) 
{ 
m.RowSwap((int)rhs[1][k], k); 
} 
if((int)rhs[0][k] != k) 
{ 
m.ColSwap((int)rhs[0][k], k); 
} 
} 

fDet *= flag; 
if(pDet != NULL) 
*pDet = fDet; 

return m; 
} 

///////////////////////////////////////判断////////////////////////////////////// 

//零矩阵 
int CMatrix::IsZero()const 
{ 
for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
if(fabs(m_ppData[i][j]) > ZERO) 
return 0; 
} 
return 1; 
} 

//方阵 
int CMatrix::IsPhalanx()const 
{ 
return (m_iRow == m_iCol); 
} 

//非奇异方阵 
int CMatrix::IsNonfunnyPhalanx()const 
{ 
return (IsPhalanx() && fabs(Det_Recursion()) > ZERO); 
} 

//可逆矩阵 
int CMatrix::IsReverse()const 
{ 
return IsNonfunnyPhalanx(); 
} 

///////////////////////////////////////操作符重载////////////////////////////////////// 

// [] 
double* CMatrix::operator [](int i)const 
{ 
assert(i >= 0 && i < m_iRow); 

return m_ppData[i]; 
} 

// = 
CMatrix& CMatrix::operator =(const CMatrix& right) 
{ 
if(this == &right) return *this; 

if((m_iRow != right.GetRow()) 
|| (m_iCol != right.GetCol()))// 添加于 2005-11-09 
{ 
Resize(right.GetRow(), right.GetCol()); 
} 
for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_ppData[i][j] = right[i][j]; 
} 

return *this; 
} 

// = 
CMatrix& CMatrix::operator =(const double* pRight) 
{ 
assert(pRight != NULL); 
for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_ppData[i][j] = pRight[m_iCol*i + j]; 
} 
return *this; 
} 

// = 
CMatrix& CMatrix::operator =(const double** ppRight) 
{ 
assert(ppRight != NULL); 
for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_ppData[i][j] = ppRight[i][j]; 
} 
return *this; 
} 

// 一元操作符+ 
const CMatrix& CMatrix::operator +()const 
{ 
return *this; 
} 

// 一元操作符- 
const CMatrix CMatrix::operator -()const 
{ 
CMatrix temp(m_iRow, m_iCol); 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
temp[i][j] = -m_ppData[i][j]; 
} 
return temp; 
} 

// + 
const CMatrix CMatrix::operator +(const CMatrix& right)const 
{ 
CMatrix temp(m_iRow, m_iCol); 

if(m_iRow == right.GetRow() 
&& m_iCol == right.GetCol()) 
{ 
for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
temp[i][j] = m_ppData[i][j] + right[i][j]; 
} 
} 
return temp; 
} 

// - 
const CMatrix CMatrix::operator -(const CMatrix& right)const 
{ 
CMatrix m_temp(m_iRow, m_iCol); 

if(m_iRow == right.GetRow() 
&& m_iCol == right.GetCol()) 
{ 
for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_temp[i][j] = m_ppData[i][j] - right[i][j]; 
} 
} 
return m_temp; 
} 

// * 
const CMatrix CMatrix::operator *(const CMatrix& right)const 
{ 
double temp = 0; 

CMatrix m_temp(m_iRow, right.GetCol()); 

if(m_iCol != right.GetRow()) 
return m_temp; 

for(int i = 0; i < m_temp.GetRow(); i++) 
{ 
for(int j = 0; j < m_temp.GetCol(); j++) 
{ 
temp = 0; 
for(int k = 0; k < right.GetRow(); k++) 
temp += m_ppData[i][k] * right[k][j]; 
m_temp[i][j] = temp; 
} 
} 
return m_temp; 
} 

// * 
const CMatrix CMatrix::operator *(const double& right)const 
{ 
CMatrix m_temp(m_iRow, m_iCol); 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_temp[i][j] = m_ppData[i][j] * right; 
} 
return m_temp; 
} 

// / 
const CMatrix CMatrix::operator /(const double& right)const 
{ 
CMatrix m_temp(m_iRow, m_iCol); 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
m_temp[i][j] = m_ppData[i][j] / right; 
} 
return m_temp; 
} 

// += 
CMatrix& CMatrix::operator +=(const CMatrix& right) 
{ 
*this = (*this) + right; 
return *this; 
} 

// -= 
CMatrix& CMatrix::operator -=(const CMatrix& right) 
{ 
*this = (*this) - right; 
return *this; 
} 

// *= 
CMatrix& CMatrix::operator *=(const CMatrix& right) 
{ 
*this = (*this) * right; 
return *this; 
} 

// *= 
CMatrix& CMatrix::operator *=(const double& right) 
{ 
*this = (*this) * right; 
return *this; 
} 

// /= 
CMatrix& CMatrix::operator /=(const double& right) 
{ 
*this = (*this) / right; 
return *this; 
} 

// == 
int CMatrix::operator ==(const CMatrix& right)const 
{ 
if(this == &right) return 1; 

if((m_iRow != right.GetRow()) 
|| (m_iCol != right.GetCol())) 
{ 
return 0; 
} 

for(int i = 0; i < m_iRow; i++) 
{ 
for(int j = 0; j < m_iCol; j++) 
if(fabs(m_ppData[i][j] - right[i][j]) > ZERO)//0 
return 0; 
} 

return 1; 
} 

// != 
int CMatrix::operator !=(const CMatrix& right)const 
{ 
return !(*this == right); 
}