Función hash en lenguaje c

Hash, generalmente traducido como "hash" o transliterado directamente como "hash", utiliza un algoritmo hash para convertir una entrada de cualquier longitud (también llamada preimagen) en una salida de longitud fija, y la salida es un valor hash. Esta transformación es un mapeo comprimido, es decir, el espacio de los valores hash suele ser mucho más pequeño que el espacio de las entradas, y diferentes entradas pueden convertirse en la misma salida, por lo que es imposible determinar de forma única el valor de entrada a partir del valor hash. En pocas palabras, es la función de comprimir un mensaje de longitud arbitraria en un resumen de mensaje de longitud fija.

Los algoritmos hash se utilizan principalmente como algoritmos de cifrado en el campo de la seguridad de la información. Convierte cierta información de diferentes longitudes en un código confuso de 128 bits, llamado valor hash. En otras palabras, el hashing consiste en encontrar la correlación entre el contenido de los datos y la dirección de almacenamiento de los datos. La aplicación de algoritmos hash en la seguridad de la información se refleja principalmente en los siguientes tres aspectos: verificación de archivos, firmas digitales y protocolos de autenticación.

Implementación del programa

//Descripción: El objetivo de la aplicación de la función hash (es decir, la función Hash) en la programación es asignar un objeto a otro a través de algún mecanismo de conversión.

size_t tipo valor entero (es decir, entero largo sin signo).

//Los principales campos de aplicación de las funciones hash son las tablas hash (ampliamente utilizadas), las contraseñas y otros campos.

//Descripción de la implementación:

//(1), aquí se utilizan objetos de función y tecnología genérica, lo que la hace aplicable a todo tipo de objetos (palabras clave).

//(2), los tipos comúnmente utilizados tienen las especializaciones correspondientes, como cadena, char*, varias formas, etc.

//(3), la versión se puede ampliar. Si existen necesidades especiales para un determinado tipo, la especialización se puede lograr más adelante.

//(4), la siguiente implementación generalmente se coloca en el archivo de encabezado y cualquiera que la incluya puede usar el objeto de función hash.

// - implementar.

# include & ltstring& gt

Usar STD::string;

tamaño en línea _ thash _ str(const char * s)

{

RES largo sin firmar = 0;

for(;*s;++s)

RES = 5 * RES+ *s;

returnsize_t(res);

}

Plantilla y clave de clase lt y gt

Hash de estructura

{

tamaño _ top operator()(const Key & amp; k) constante

};

//Objetos generales, como: vector

Plantilla & lt clase clave & gt

tamaño _ thash & ltKey & gt* operador()(const Key & amp; k) constante

{

size _ tres = 0;

size _ tlen = sizeof(Key);

const char * p = reinterpretar _ cast & lt; const char * & gt(& ampk

mientras (len -)

{

RES =(RES & lt;& lt1)^ *p++;

}

Devolver res

}

//Especialización

Plantilla& lt& gt

tamaño _ thash & lt string & gt* operator() (cadena constante & ampstr) constante

{

Devuelve hash _ str(str . c _ str());

}

typedef char * PChar

plantilla & lt& gt

tamaño _ thash & ltPChar & gt* operador()(const PChar & s)constante

{

Devuelve una cadena hash;

}

typedef const char * PCChar

template & lt& gt

tamaño _ thash & ltPCChar & gt* operador()(const PCChar & s) constante

{

Devuelve cadena hash;

}

Plantilla & lt& gtsize _ t hash & ltchar & gt* operator()(const char & amp; x)const { return x;}

Plantilla & lt& gtsize _ t hash & lt unsigned char & gt* operador() (const unsigned char & ampx) const { return x }

Plantilla & lt& gtsize _ t hash & lt firmado char & gt* operador()(const char firmado & amp; const { return x }

Plantilla & lt& gtsize _ t hash & ltshort & gt* operator()(const short & amp; x)const { return x;}

Plantilla & lt& gtsize _ t hash & lt unsigned short

gt* operador()(const unsigned short & ampx)const { return x;}

Plantilla & lt& gtsize _ t hash & ltint & gt* operator()(const int & amp;x)const { return x;}

Plantilla <& gtsize_t hash <unsigned int>* operator()(const unsigned int &x)const { return x;}

Plantilla & lt& gtsize _ t hash & ltlong & gt* operator()(const long & amp; x)const { return x }

Plantilla & lt& gtsize _ t hash & lt unsigned long Entero & gt* operator()(const unsigned long & amp; x)const { return x }

//Instrucciones de uso:

//

>(1), en primer lugar, debido a que es un tipo genérico, se debe agregar el tipo de palabra clave.

//

//(2) En segundo lugar, debe haber un objeto de función, que puede ser temporal, local o global, siempre que esté dentro del alcance.

//

//(3), aplica el objeto de función al objeto del tipo correspondiente.

// - Ejemplo de uso de una función hash.

# include & ltiostream & gt

# include & ltvector & gt

# include & ltstring& gt

Usar espacio de nombres std

int main()

{

Vector & lt cadena & gtvstr⑵

vstr[0]= " sjw ";

vstr[1]= " sun INF ";

Hash& ltString& gtstrhash//Objeto de función local

cout & lt& lt Valor hash: "& lt& ltstrhash(vstr [0])& lt;& ltendl

cout & lt& ltHash valor: "& lt& ltstrhash(vstr[1])& lt;& ltendl

cout<<Hash valor:"<<Hash<Vector<String>>( )(vstr)<<endl

cout<& ltHash value: "<<Hash<int>()(100)<<endl//Hash<int>() objeto de función temporal

Devuelve 0;

p>

}