Función hash en lenguaje C

Hash, generalmente traducido como "hash", también transliterado directamente como "hash", consiste en transformar la entrada de cualquier longitud (también llamada pre-mapeo, pre-imagen) a través de un algoritmo hash en un valor fijo. -salida de longitud, que es el valor hash. Esta conversión es un mapeo de compresión, es decir, el espacio de los valores hash suele ser mucho más pequeño que el espacio de las entradas. Diferentes entradas pueden generar la misma salida y es imposible determinar de forma única el valor de entrada a partir del valor hash. . En pocas palabras, es una función que comprime un mensaje de cualquier longitud en un resumen de mensaje de una determinada longitud fija.

HASH se utiliza principalmente como algoritmo de cifrado en el campo de la seguridad de la información. Convierte información de diferentes longitudes en un código desordenado de 128 bits, llamado valor HASH. encontrar un tipo de contenido de datos y la relación de mapeo entre direcciones de almacenamiento de datos. La aplicación del algoritmo Hash en la seguridad de la información se refleja principalmente en los siguientes tres aspectos: verificación de archivos, firma digital y protocolo de autenticación

Implementación del programa

// Descripción: Función Hash La aplicación Objetivo de (es decir, función hash) en la programación------corresponder un objeto a un valor entero de tipo

//size_t (es decir, largo sin firmar) a través de algún mecanismo de conversión.

// Las principales áreas donde se aplican las funciones Hash son las tablas hash (muy utilizadas), las contraseñas y otros campos.

// Instrucciones de implementación:

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

// ⑵. Los tipos comunes tienen especializaciones parciales correspondientes, como cuerda, char *, varios plásticos, etc.

// (3) La versión es extensible. Si tienes necesidades especiales para un determinado tipo, puedes especializarlo más adelante.

// ⑷ La siguiente implementación generalmente se coloca en el archivo de encabezado y cualquier cosa que la contenga puede usar el objeto de función hash.

//------------------------------------Implementación---- -----------------------------------------

#include

usando std::string;

inlinesize_thash_str(const char* s)

{

unsigned long res = 0;

for (; *s; ++s)

res = 5 * res + *s;

returnsize_t(res );

}

plantilla

estructura hash

{

size_toperator () ( const Key& k ) const;

};

// Los objetos generales, como: los objetos vectoriales >; p>plantilla < clave de clase >>p>

size_thash::operator () (const Key& k) const

{

size_tres = 0;

size_tlen = sizeof(Key);

const char* p = reinterpret_cast(&k);

mientras (len--)

{

res = (res<<1)^*p++;

}

devuelve res;

}

// Especialización parcial

plantilla<>

size_thash< string >::operator () (const string& str) const

{

return hash_str(str.c_str());

}

typedef char* PChar;

plantilla<>

size_thash::operator () (const PChar& s) const

{

return hash_str(s);

}

typedef const char* PCChar;

plantilla<>

size_thash::operator () (const PCChar& s) const

{

return hash_str(s);

}

plantilla<> size_t hash::operator () (const char& x) const { return x; }

plantilla<> size_t hash::operator () (const unsigned c

har& x) const { return x }

plantilla<> size_t hash::operator () (const signed char& x) const { return x }

plantilla <> size_t hash::operator () (const short& x) const { return x }

plantilla<> size_t hash::operator () (const unsigned short& x) const { return x }

plantilla<> size_t hash::operator () (const int& x) const { return x }

plantilla<> size_t hash< unsigned int>::operator () (const unsigned int& x) const { return x }

plantilla<> size_t hash::operator () (const long& x) const { return x; }

plantilla<> size_t hash::operator () (const unsigned long& x) const { return x }

// Instrucciones de uso:

//

// ⑴ Al usarlo, en primer lugar, debido a que es un tipo genérico, se debe agregar el tipo de palabra clave.

//

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

//

// ⑶. Aplicar objetos de función a objetos de tipos correspondientes.

//----------------------- Ejemplo de uso de la función hash------------- - -----------

#include

#include

#include

usando el espacio de nombres std;

int main()

{

vector vstr⑵;

vstr[ 0 ] = "sjw";

vstr[1] = "suninf";

hash strhash // Objeto de función local

cout < < " Valor hash: " << strhash(vstr[0]) << endl;

cout << " Valor hash: " << strhash(vstr[1]) << endl;

cout << " Valor hash: " << hash< vector >() (vstr) << endl;

cout << " Valor hash: " << hash () (100) << endl; // hash() objeto de función temporal

return 0;

}