Hashwert aus std::string



  • Hallo!

    Ich suche eine einfache Funktion mit der ich aus einem string einen einzigartigen Hashwert erzeugen kann, sie sollte also wie folgt aussehen und dabei noch schnell sein wenns geht:

    int GetHashFromString(const std::string &Value);
    

    Hat jemand sowas parat?
    Danke KaPtainCugel



  • versuche mal boost::crc

    int GetHashFromString(const std::string &Value)
    {
        return boost::crc( Value.c_str(), Value.size() );
    }
    


  • cHash hash;
    
    hash.computeHash (thisIsAString);
    cout << "the hash is: " << hash.getHash ();
    

    Ist das einfach genug?
    Wenn ja kannst du mir mailen, ich schick dir die Klasse gerne zu 🙂



  • Hi,

    Headhunters Klasse kann ich nur empfehlen. 🙂

    Wenn du willst, kannst du auch meine Version davon haben. 😉

    ChrisM



  • Könnt ihr bitte die Klasse hier posten? đŸ€Ą



  • ChrisM: Deine Version? Was hast du verĂ€ndert?

    Ok, poste ich den Code halt hier 🙂
    (die Klasse gibts noch als cFileHash, wenn du die haben willst bitte auch melden

    hash.hpp

    #ifndef HASH_HPP
    #define HASH_HPP
    
    #include <iostream>
    
    using namespace std;
    
    // generates crc checksum, code borrowed from the cherokee web server
    
    //
    typedef unsigned int HASH;
    
    //
    class cHash
    {
    public:
    
    	//
    	cHash ();
    
    	// compute the hash of this string
    	void computeHash (const string& what);
    
    	//
    	HASH getHash () const;
    
    protected:
    
    	//
    	void computeHash (HASH& hash, char c) const;
    
    	// needed to compute the hash
    	static const HASH _crc32tab[256];
    
    private:
    
    	// set by computeHash
    	HASH _hash;
    
    };
    
    #endif // HASH_HPP
    

    hash.cpp

    #include "hash.hpp"
    
    const HASH cHash::_crc32tab[256] = {
            0x00000000, 0x77073096, 0xee0e612c, 0x990951ba,
            0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
            0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
            0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
            0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
            0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
            0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec,
            0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5,
            0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
            0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
            0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940,
            0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
            0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116,
            0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f,
            0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
            0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d,
            0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a,
            0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
            0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818,
            0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
            0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
            0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457,
            0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c,
            0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
            0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
            0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
            0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
            0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9,
            0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086,
            0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
            0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4,
            0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
            0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
            0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683,
            0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
            0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
            0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe,
            0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7,
            0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
            0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
            0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252,
            0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
            0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60,
            0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
            0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
            0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f,
            0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04,
            0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
            0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a,
            0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
            0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
            0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
            0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e,
            0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
            0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
            0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
            0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
            0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db,
            0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0,
            0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
            0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6,
            0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf,
            0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
            0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d,
    };
    
    //
    cHash::cHash ()
    {
    	_hash = 0;
    }
    
    //
    void cHash::computeHash (HASH& hash, char c) const
    {
    	hash = ( (hash >> 8) ^ _crc32tab[ (hash  ^ (c)) & 0xff ] );
    }
    
    //
    void cHash::computeHash (const string& what)
    {
    	_hash = ~0;
    
    	//
            for (int l=0;l<what.size();l++)
                    computeHash(_hash, what[l]);
    
    	//
    	_hash = ~_hash;
    }
    
    //
    HASH cHash::getHash () const
    {
    	return _hash;
    }
    


  • Danke die werde ich gleich mal ausprobieren 👍. Ich habe nĂ€mlich gestern eine Stunde meinen Fehler gesucht und es lag einfach daran, dass meine (zugegeben absolut dĂ€mliche) Hashfunktion öfter das gleiche Ergebnis hatte bei unterschiedlichen Strings...

    EDIT: Klappt wunderbar! 🙂



  • Danke die werde ich gleich mal ausprobieren . Ich habe nĂ€mlich gestern eine Stunde meinen Fehler gesucht und es lag einfach daran, dass meine (zugegeben absolut dĂ€mliche) Hashfunktion öfter das gleiche Ergebnis hatte bei unterschiedlichen Strings...

    Das lÀsst sich wohl kaum vermeiden. Es wird immer Strings geben, die den selben Hashwert zugewiesen bekommen.



  • Hi,

    @Headhunter: Meine Version ist etwas sauberer programmiert 😃

    class Hash
    {
    public:
    	Hash(void);
    
    	void hashData(const char* pcData, unsigned long lLength);
    
    	unsigned long getHash(void) const { return m_lHash; }
    
    private:
    	unsigned long m_lHash;
    	static const unsigned long m_lCRC32Table[256];
    };
    
    class FileHash
    {
    public:
    	FileHash(const std::string& sFile);
    
    	unsigned long getHash(void) const { return m_hash.getHash(); }
    
    private:
    	Hash m_hash;
    };
    
    #include "../Shared/Global.hpp"
    #include <fstream>
    #include "Exception.hpp"
    #include "Hash.hpp"
    
    using namespace GalacticBlast;
    
    // Static CRC32 table
    const unsigned long Hash::m_lCRC32Table[256] =
    {
    	0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
    	0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
    	0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
    	0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
    	0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
    	0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
    	0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
    	0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
    	0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
    	0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
    	0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
    	0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
    	0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
    	0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
    	0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
    	0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
    	0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
    	0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
    	0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
    	0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
    	0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
    	0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
    	0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
    	0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
    	0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
    	0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
    	0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
    	0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
    	0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
    	0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
    	0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
    	0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
    	0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
    	0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
    	0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
    	0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
    	0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
    	0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
    	0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
    	0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
    	0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
    	0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
    	0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
    	0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
    	0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
    	0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
    	0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
    	0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
    	0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
    	0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
    	0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
    	0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
    	0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
    	0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
    	0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
    	0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
    	0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
    	0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
    	0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
    	0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
    	0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
    	0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
    	0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
    	0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
    };
    
    Hash::Hash(void) :
    m_lHash(0)
    {}
    
    void Hash::hashData(const char* pcData, unsigned long lLength)
    {
    	GUARD;
    
    	// Set all bits of the hash value to 1
    	m_lHash = 0xFFFFFFFF;
    
    	// Loop over all bytes of the data and update the hash value with this character
    	for (unsigned long i = 0; i < lLength; ++i)
    		m_lHash = (m_lHash >> 8) ^ m_lCRC32Table[(pcData[i] ^ m_lHash) & 0xFF];
    
    	// Inverse hash value
    	m_lHash = ~m_lHash;
    
    	UNGUARD;
    }
    
    FileHash::FileHash(const std::string& sFilename)
    {
    	GUARD;
    
    	// Open file
    	std::ifstream file(sFilename.c_str(), std::ios::in | std::ios::binary);
    	if (file.fail())
    		GB_THROW("File " + sFilename + " not found!");
    
    	// Calculate file length
    	file.seekg(0, std::ios::end);
    	unsigned long lFileSize = file.tellg();
    	file.seekg(0, std::ios::beg);
    
    	// Read the hole file in a buffer and close it
    	char* pBuffer = new char[lFileSize];
    	file.read(pBuffer, lFileSize);
    	file.close();
    
    	// Hash the buffer
    	m_hash.hashData(pBuffer, lFileSize);
    
    	// Delete buffer
    	delete[] pBuffer;
    
    	UNGUARD;
    }
    

    ChrisM



  • Was heißt der Operator "^"???



  • Helium schrieb:

    Das lÀsst sich wohl kaum vermeiden. Es wird immer Strings geben, die den selben Hashwert zugewiesen bekommen.

    Ja das ist wohl wahr, allerdings sollte es nicht 20 doppelte bei grade mal 160 strings geben...



  • Hi,

    flyingCoder schrieb:

    Was heißt der Operator "^"???

    exklusives Oder:
    0 ^ 0 = 0
    1 ^ 0 = 1
    0 ^ 1 = 1
    1 ^ 1 = 0

    ChrisM



  • Headhunter schrieb:

    cHash hash;
    
    hash.computeHash (thisIsAString);
    cout << "the hash is: " << hash.getHash ();
    

    designtechnische frage: warum eine klasse dafĂŒr? der rĂŒckgabewert ist ja ein 32bit integer also kann man glaub ich gut sicherstellen eine geeigneten datentyp zu haben. warum also nicht einfach ein funktion?
    die funktion könnte man sogar fĂŒr char* und std::string etc ĂŒberladen...



  • Hi,

    eine Klasse hat schon einige Vorteile, z.B. kann man spĂ€ter dann Hash einfach abstrakt machen und davon mehrere verschiedene Hashverfahren ableiten. Dann kann man Hashklasse einfach an Funktionen ĂŒbergeben und die können hashen und den genauen Typ des Hashalgorithmus zu kennen.

    ChrisM



  • designtechnische frage: warum eine klasse dafĂŒr [..]

    Was wÀre denn die Alternative?
    Eine Funktion, die einen kompletten String berechnet, die lookup table
    vielleicht noch statisch in der Funktion oder in der .hpp Datei, damit sie
    keiner sieht?
    Und dann wĂ€re die computeHash Funktion wieder ein StĂŒckchen lĂ€nger, unĂŒbersichtlicher
    irgendwie blöder zu verwenden.
    Außerdem finde ich den Code so viel mehr Idiotensicher. Wenn man nur mit den
    typedefs arbeitet, mh, die Versuch _hash = -1 o.Ă€. zu machen ist doch einfach zu groß.
    Oder _hash = -2. O.À., und dann hat man auf einmal kompaktibilitÀtsprobleme mit
    schon nur einem StĂŒck Code.
    Du wirst vielleicht lachen, aber wie ich in der .hpp geschrieben habe, ist der
    Quellcode teilweise vom Cherokee Webserver ĂŒbernommen, und da war's vorher ne simple
    Funktion. War aber doof zu verwenden.
    Und char*'s mag ich eh nich, von daher ist std::string schon fein. Wenn ich dann doch
    unbedingt mal char's will, kann ich meinen string immer noch schön casten.

    Lange Rede kurzer Sinn: Ich mag C++ 🙂



  • ob die tabelle jetzt statisch in der funktion oder statisch in der klasse ist spielt ja wohl nicht so eine rolle (fĂŒr mich nicht).

    Außerdem finde ich den Code so viel mehr Idiotensicher. Wenn man nur mit den
    typedefs arbeitet, mh, die Versuch _hash = -1 o.Ă€. zu machen ist doch einfach zu groß.
    Oder _hash = -2. O.À., und dann hat man auf einmal kompaktibilitÀtsprobleme mit
    schon nur einem StĂŒck Code.

    ich weiss ehrlich gesagt nicht was du damit meinst? was ist in deiner vorstellung die variable _hash? und das du char* nicht gerne hast. ist ja schön und gut. aber was ist wenn ich mal nicht strings sondern sonst irgendwelche daten habe. die will ich vielleicht auch per crc ĂŒberprĂŒfen obs die richtige datei ist. castest du die dann auch auf string?

    nur weil man c++ programmiert muss man nicht alles in klassen verpacken.
    im wesentlichen hast du um eine funktion und ihren rĂŒckgabewert eine klasse herumgebastelt... konsequenterweise mĂŒsste man dann ja fĂŒr alles eine klasse benutzen:

    class isDigit {
    public:
       void checkIsdigit(char c)
       {
          /*was isdigit halt so macht*/
          isdigit_ = result;
       }   
       bool isdigit()
       { return isdigit_; }
    private:
       bool isdigit_;
    }
    

    diese isdigit klasse ist offensichtlich blödsinn. aber ich sehe nicht warum soetwas bei einer hashfunktion sinn machen sollte.



  • ich schließe mich Japro an.

    Hash hash;
    hash.compute("hallo");
    cout<<hash.get();

    sieht doof aus. Denn die Zeile Hash hash mach doch garnix...

    Zu den Argumenten:

    Eine Funktion, die einen kompletten String berechnet, die lookup table
    vielleicht noch statisch in der Funktion oder in der .hpp Datei, damit sie
    keiner sieht?

    nein, ein unnamed namespace 🙂

    Und dann wĂ€re die computeHash Funktion wieder ein StĂŒckchen lĂ€nger, unĂŒbersichtlicher
    irgendwie blöder zu verwenden.

    LĂ€nger? wieso? sogar kĂŒrzer, denn die Klassendefinition fĂ€llt weg - aber das ist ja egal. Die grĂ¶ĂŸen unterschiede sind uninteressant, weil viel zu gering.

    Und blöder zu verwenden?

    Hash hash;
    hash.compute("hallo");
    cout<<hash.getHash();
    
    //versus
    cout<<hashString("hallo");
    

    wo ist da etwas blöder?

    Außerdem finde ich den Code so viel mehr Idiotensicher. Wenn man nur mit den
    typedefs arbeitet, mh, die Versuch _hash = -1 o.Ă€. zu machen ist doch einfach zu groß.

    verstehe ich nicht. wieso sollte man _hash beeinflussen können? _hash ist ja nicht frei zugÀnglich...

    Du wirst vielleicht lachen, aber wie ich in der .hpp geschrieben habe, ist der
    Quellcode teilweise vom Cherokee Webserver ĂŒbernommen, und da war's vorher ne simple
    Funktion. War aber doof zu verwenden.

    Zeig mal her wie man die verwendet hat.

    Und char*'s mag ich eh nich, von daher ist std::string schon fein. Wenn ich dann doch
    unbedingt mal char's will, kann ich meinen string immer noch schön casten.

    warum nicht eine template version die mit iteratoren arbeitet? 🙂 das wĂ€re mal cool.

    eine Klasse hat schon einige Vorteile, z.B. kann man spĂ€ter dann Hash einfach abstrakt machen und davon mehrere verschiedene Hashverfahren ableiten. Dann kann man Hashklasse einfach an Funktionen ĂŒbergeben und die können hashen und den genauen Typ des Hashalgorithmus zu kennen.

    Oh, und das ohne virtuelle Funktionen - ich bin begeistert...



  • Ok, dann werde ich mal zu meiner Verteidigungsrede ansetzen. Ich geh einfach von oben nach unten
    die Argumente durch und hoffe, dass ich nicht allzuviel ĂŒbersehe 😉

    [..]
    im wesentlichen hast du um eine funktion und ihren rĂŒckgabewert eine klasse herumgebastelt... konsequenterweise mĂŒsste man dann ja fĂŒr alles eine klasse benutzen: (class isDigit) [..]

    Nein.
    Ich versuche durch Klassen "ist ein" Beziehungen darzustellen (quasi wie bei der Vererbung):

    cHash hash sagt mir, dass hash ein cHash ist (ist in diesem Beispiel nicht wirklich sinnvoll, geht eher ums Prinzip)
    whereas ich die Klasse isDigit eher komplett statisch machen wĂŒrde:
    if (isDigit::check ("23")) { ..}
    Find ich persönlich sinnvoller.

    ich schließe mich Japro an.

    Hash hash;
    hash.compute("hallo");
    cout<<hash.get();

    sieht doof aus. Denn die Zeile Hash hash mach doch garnix... [..]

    Doch. Nicht in dem Beispiel, aber die Klasse cHash ist auch nicht zum Einsatz
    in int main () gedacht, sondern eher als Klassenvariable z.b. in einem VFS o.Ă€.
    Und dann hab ich folgenden Code:

    [cpp]
    class cVfs
    {
    public:
    [..]
    private:

    cHash _hash;
    };

    Find ich auch deshalb schöner, weil nun Leute mit Intellisense in ihrer Ide direkt
    sehen welche Memberfunktionen _hash hat. Alle anderen können ganz einfach in ihren
    .h / .hpp Dateien nach cHash greppen.

    [..]Außerdem finde ich den Code so viel mehr Idiotensicher. Wenn man nur mit den
    typedefs arbeitet, mh, die Versuch _hash = -1 o.Ă€. zu machen ist doch einfach zu groß.

    verstehe ich nicht. wieso sollte man _hash beeinflussen können? _hash ist ja nicht frei zugÀnglich...
    [..]

    Einfach. Wenn man mit einer Klasse arbeitet, ist es fĂŒr den unbedarften User nicht möglich den Hash
    ohne weiteres zu verÀndern. Tut man nur mit typedefs arbeiten und man möchte den Hash in einer Klasse
    speichern, hat man ne Membervariable die durch eine unbedachte Verwendung des operator= zerschossen wird.
    Es geht mir bei meinen Source darum, dass sie so einfach und vor allem idiotensicher wie möglich sind,
    was diese typedef Variante fĂŒr mich nicht ist.

    [cpp]
    [..]
    warum nicht eine template version die mit iteratoren arbeitet? das wÀre mal cool.
    [..]
    [/cpp]
    Wow.. es bissel viel fĂŒr ne Simple Hashklasse 😼
    Templates fallen schonmal als Option weg, da fĂŒr die Berechnung des Hashs nötig ist dass die zu berechnende
    Variable ein char ist, inklusive "wrapping around".
    Und iteratoren.. mh, mir krausen sich schon immer die FußnĂ€gel wenn ich schon durch ne std::list iterieren
    möchte.. soviele Doppelpunkte und Sternchen, Klammern etc.. wo's durch ne (for int l=0;l<liste.size();l++) Schleife
    doch viel intuitiver gewesen wÀre.

    Den Orginalquellcode kann ich dir leider nicht anbieten, die cherokee Seite scheint down zu sein.
    Vielleicht klappts ja spÀter wieder, dann kannst du hier schauen:
    http://www.alobbs.com/modules.php?op=modload&name=cherokee&file=index
    Ich glaube die relevate Datei hieß crc32.h bzw crc32.c

    So, um meine Rede kurz zusammenzufassen:
    Der Sinn einer *Klasse* cHash ist es, die Erstellung von hashes fĂŒr den User so einfach und idiotensicher
    wie möglich zu machen.
    Ein Hash ist ein konkretes Objekt, man kann es sehen, man kann damit arbeiten, es verÀndern etc, von daher
    halte ich es nur logisch das durch eine Klasse darzustellen (auch wenn dies sicherlich nicht der Orginalsinn
    einer Klasse im OOP ist).

    Was haltet ihr davon?



  • wenn sowas gehen wĂŒrde wĂ€re es doch ganz praktisch. Hash<CRC32>, Hash<MD5> ....



  • Headhunter schrieb:

    Ein Hash ist ein konkretes Objekt, man kann es sehen, man kann damit arbeiten, es verÀndern etc, von daher
    halte ich es nur logisch das durch eine Klasse darzustellen.

    Was haltet ihr davon?

    Ehrlich gesagt nichts.

    Ein Hash mag ein konktretes Objekt sein, man legt dort nÀmlich Daten indiziert ab und zwar indiziert nach einer Hash-Funktion. Und nur diese betrachtest Du hier. Und weil es sich hier um eine Hashfunktion handelt sehe ich nicht, warum sie keine Funktion sein sollte, oder auch ein Funktions-template.
    Aber wenn man diese Funktion auch anfassen kann, dann fasse bitte auch mal die Funktion cos(x) und die Wurzel an.

    MfG Jester


Log in to reply