自学教程：C++ HashString函数代码示例

void JStringServer::ExtractStrings(){    FILE* fp = fopen( "strings.txt", "wt" );    if (!fp)    {        return;    }    m_Dictionary.clear();    //  extract text strings    JObjectIterator it( JCore::s_pInstance );    JString val, hash;    while (it)    {        JObject* pObj = *it;        if (pObj->HasName( "system" ))        {            it.breadth_next();            continue;        }        ++it;        bool bRes = pObj->GetProperty( "text", val );        if (!bRes || val.size() == 0 || val[0] == '#')        {            continue;        }        if (!HasCyrillics( val.c_str() ))        {            continue;        }        HashString( val.c_str(), hash );        JStringDictionary::iterator location = m_Dictionary.find( hash );        JString taggedHash = "#";        taggedHash += hash;        pObj->SetProperty( "text", taggedHash.c_str() );        if (location != m_Dictionary.end())        {            if (val == (*location).second)            {                continue;            }            assert( false );        }        fprintf( fp, "%s %s/n", hash.c_str(), val.c_str() );        m_Dictionary[hash] = val;    }    fclose( fp );    //  save scripts    g_pPersistServer->SaveScripts();}

// Static functionuint CElement::GetTypeHashFromString ( const SString& strTypeName ){    // Standard types use unique index upto EElementType::UNKNOWN    EElementType elementType;    if ( StringToEnum ( strTypeName, elementType ) )        return elementType;    // Custom types use name hash.  TODO: Make it use a unique index instead    uint uiTypeHash = HashString ( strTypeName );    uiTypeHash = ( uiTypeHash % 0xFFFFFF00 ) + CElement::UNKNOWN + 1;    return uiTypeHash;}

//*****************************************************************************////*****************************************************************************void Translate_Dump(const char *string, bool dump){	if(dump)	{		FILE * fh = fopen( "hash.txt", "a" );		if(fh)		{			fprintf( fh,  "%08x,%s/n", HashString(string), string );			fclose(fh);		}	}}

BUrlContext::BUrlContext()	: 	fCookieJar(),	fAuthenticationMap(NULL){	fAuthenticationMap = new(std::nothrow) BHttpAuthenticationMap();	// This is the default authentication, used when nothing else is found.	// The empty string used as a key will match all the domain strings, once	// we have removed all components.	fAuthenticationMap->Put(HashString("", 0), new BHttpAuthentication());}

static voidRebuildLiteralTable(    register LiteralTable *tablePtr)				/* Local or global table to enlarge. */{    LiteralEntry **oldBuckets;    register LiteralEntry **oldChainPtr, **newChainPtr;    register LiteralEntry *entryPtr;    LiteralEntry **bucketPtr;    const char *bytes;    int oldSize, count, index, length;    oldSize = tablePtr->numBuckets;    oldBuckets = tablePtr->buckets;    /*     * Allocate and initialize the new bucket array, and set up hashing     * constants for new array size.     */    tablePtr->numBuckets *= 4;    tablePtr->buckets = ckalloc(tablePtr->numBuckets * sizeof(LiteralEntry*));    for (count=tablePtr->numBuckets, newChainPtr=tablePtr->buckets;	    count>0 ; count--, newChainPtr++) {	*newChainPtr = NULL;    }    tablePtr->rebuildSize *= 4;    tablePtr->mask = (tablePtr->mask << 2) + 3;    /*     * Rehash all of the existing entries into the new bucket array.     */    for (oldChainPtr=oldBuckets ; oldSize>0 ; oldSize--,oldChainPtr++) {	for (entryPtr=*oldChainPtr ; entryPtr!=NULL ; entryPtr=*oldChainPtr) {	    bytes = TclGetStringFromObj(entryPtr->objPtr, &length);	    index = (HashString(bytes, length) & tablePtr->mask);	    *oldChainPtr = entryPtr->nextPtr;	    bucketPtr = &tablePtr->buckets[index];	    entryPtr->nextPtr = *bucketPtr;	    *bucketPtr = entryPtr;	}    }    /*     * Free up the old bucket array, if it was dynamically allocated.     */    if (oldBuckets != tablePtr->staticBuckets) {	ckfree(oldBuckets);    }}

//---------------------------- PRIVATE          -----------------------------//void *wxServerConnectionThread::Entry(){	bool valid = true;	// It's ok to block this thread waiting for data.	mSocket->SetFlags(wxSOCKET_WAITALL);	try	{		// If we pass the check, but return false, it means we got hit by the		// site requesting a host check.		if(false == Cities3DCheck())		{            static const wxString stReceivedAHostCheck = _("Received a host check from the site.");    			wxRuleEvent event(shNetworkRuleSystemMessage, 				DataObject(stReceivedAHostCheck, wxDateTime::Now()));			mHandler->AddPendingEvent(event);			valid = false;			goto error;		}		VersionCheck();		ReceiveSpectator();		SendSpectators();		SendGame();		SendRNG();	}	catch(const std::exception &e)	{		valid = false;		wxLogDebug(HashString(e.what()).wx_str());	}error:	if(true == valid)	{		// This socket is complete and ready for data.		mSocket->mIsComplete = true;	}	else	{		mSocket->Destroy();		mSocket = NULL;	}	return NULL;}

	const uint32 ConvertGameRulesToHash(const char* gameRules)	{		if (gameRules && (strlen(gameRules) < 32))		{			char lowerRulesName[32];			NameCRCHelper::MakeLowercase(lowerRulesName, gameRules);			return HashString(lowerRulesName);		}		else		{			return 0;		}	}

unsigned long StringHash::Hashed(string lpszString){ 	//不同的字符串三次hash还会碰撞的几率无限接近于不可能	unsigned long nHash = HashString(lpszString, HASH_OFFSET); 	unsigned long nHashA = HashString(lpszString, HASH_A); 	unsigned long nHashB = HashString(lpszString, HASH_B); 	unsigned long nHashStart = nHash % m_tablelength, 	nHashPos = nHashStart;	while ( m_HashIndexTable[nHashPos].bExists) 	{ 	if (m_HashIndexTable[nHashPos].nHashA == nHashA && m_HashIndexTable[nHashPos].nHashB == nHashB)		return nHashPos; 	else 		nHashPos = (nHashPos + 1) % m_tablelength;	if (nHashPos == nHashStart) 		break; 	}	return -1; //没有找到 }

	const uint32 ConvertMapToHash(const char* mapName)	{		if (mapName && (strlen(mapName) < 128))		{			char lowerMapName[128];			NameCRCHelper::MakeLowercase(lowerMapName, mapName);			return HashString(lowerMapName);		}		else		{			return 0;		}	}

DWORD FusionBind::Hash(){    DWORD hash = 0;    // Normalize representation    if (!m_fParsed)        ParseName();    // Hash fields.    if (m_pAssemblyName)        hash ^= HashStringA(m_pAssemblyName);    hash = _rotl(hash, 4);    hash ^= HashBytes(m_pbPublicKeyOrToken, m_cbPublicKeyOrToken);    hash = _rotl(hash, 4);            hash ^= m_dwFlags;    hash = _rotl(hash, 4);    if (m_CodeInfo.m_pszCodeBase)        hash ^= HashString(m_CodeInfo.m_pszCodeBase);    hash = _rotl(hash, 4);    hash ^= m_context.usMajorVersion;    hash = _rotl(hash, 8);    if (m_context.usMajorVersion != (USHORT) -1) {        hash ^= m_context.usMinorVersion;        hash = _rotl(hash, 8);                if (m_context.usMinorVersion != (USHORT) -1) {            hash ^= m_context.usBuildNumber;            hash = _rotl(hash, 8);                    if (m_context.usBuildNumber != (USHORT) -1) {                hash ^= m_context.usRevisionNumber;                hash = _rotl(hash, 8);            }        }    }    if (m_context.szLocale)        hash ^= HashStringA(m_context.szLocale);    hash = _rotl(hash, 4);    hash ^= m_CodeInfo.m_fLoadFromParent;    return hash;}

bool StringHash::Hash(string lpszString){  	const unsigned long HASH_OFFSET = 0, HASH_A = 1, HASH_B = 2;  	unsigned long nHash = HashString(lpszString, HASH_OFFSET);  	unsigned long nHashA = HashString(lpszString, HASH_A);  	unsigned long nHashB = HashString(lpszString, HASH_B);  	unsigned long nHashStart = nHash % m_tablelength, 		nHashPos = nHashStart;  	while ( m_HashIndexTable[nHashPos].bExists)  	{   		nHashPos = (nHashPos + 1) % m_tablelength;  		if (nHashPos == nHashStart)  		{  			return false;   		}  	}  	m_HashIndexTable[nHashPos].bExists = true;  	m_HashIndexTable[nHashPos].nHashA = nHashA;  	m_HashIndexTable[nHashPos].nHashB = nHashB;  	return true;  }  

uint32 Block::fileKey(const string &fileName, const BlockTableEntry &blockTableEntry){	if (fileName.empty())		throw std::logic_error(_("Never try to get file keys of empty filenames."));	// Hash the name to get the base key	uint32 nFileKey = HashString(Mpq::cryptTable(), fileName.c_str(), HashType::FileKey);	// Offset-adjust the key if necessary	if (blockTableEntry.flags & Flags::UsesEncryptionKey)		nFileKey = (nFileKey + blockTableEntry.blockOffset) ^ blockTableEntry.fileSize;	return nFileKey;}

HRESULT CeeSectionString::getEmittedStringRef(__in_z LPWSTR target, StringRef *ref){    TESTANDRETURN(ref!=NULL, E_POINTER);    ULONG hashId = HashString(target) % MaxVirtualEntries;    ULONG bucketIndex = hashId / MaxRealEntries;    StringTableEntry *entry;    entry = findStringInsert(stringTable[bucketIndex], target, hashId);    if (! entry)        return E_OUTOFMEMORY;    *ref = entry->m_offset;    return S_OK;}

static void resolveTypePrototypes( void ) {/*****************************************//* adds required protoypes to the protoype section */    statement   *finger;    statement   *rc;    long        len;    char        *name;    char        *libname;    if( !SRU.type_sec ) {        return;    }    finger = SRU.forward_prots;    /* loop through the chain of prototypes and add them if necessary */    while( finger ) {        name = finger->data.sp.name;        len = strlen( name );        /* check in hash table for function name */        if( !FindHashEntry(SRU.type_prots, HashString(name, len), name, len) ) {            /* add to prototype section */            rc = insertTypePrototype( finger, SRU.type_sec );            rc->link = SRU.cpp_prots;            SRU.cpp_prots = rc;            rc->keep = TRUE;            InsertHashValue( SRU.type_prots, rc->data.sp.name,                             strlen( rc->data.sp.name ), rc );        }        finger = finger->link;    }    /* generate constructors and destructor prototypes if necessary */    libname = GetLibName();    len = max( sizeof( DES_DECL_TEMPLATE ) + strlen( SRU.des_name ),               sizeof( CONS_DECL_TEMPLATE ) + strlen( SRU.con_name ) );    name = alloca( len + strlen( libname ) + 1 );    if( !( SRU.flags & DESTRUCTOR_DEFINED ) ) {        sprintf( name, DES_DECL_TEMPLATE, SRU.des_name, libname );        insertStatement( SRU.type_sec, name );    }    if( !( SRU.flags & CONSTRUCTOR_DEFINED ) ) {        sprintf( name, CONS_DECL_TEMPLATE, SRU.con_name, libname );        insertStatement( SRU.type_sec, name );    }}

/////////////////////////////////////////////////////////////function: 插入新的元素进入hash表//parameter://author: wuxiaoqi//time: 2016-3-23///////////////////////////////////////////////////////////int Ins3Hashmg(hashtable * HashMg, const char *pmkey, const char * pidkey, int fqv){	int ln;	const unsigned long HASH_OFFSET = 0, HASH_A = 1, HASH_B = 2;	unsigned long nHash = HashString(pmkey, HASH_OFFSET);	unsigned long nHashA = HashString(pmkey, HASH_A);	unsigned long nHashB = HashString(pmkey, HASH_B);	unsigned long nHashStart = nHash%DCHASH_SIZE, nHashPos = nHashStart;	while(((*HashMg)+nHashPos)->bExists)	{		nHashPos = (nHashPos + 1)%DCHASH_SIZE;		if (nHashPos == nHashStart)			return 0;	}	((*HashMg)+nHashPos)->bExists = 1;	((*HashMg)+nHashPos)->nHashA = nHashA;	((*HashMg)+nHashPos)->nHashB = nHashB;    if(pmkey != NULL && *pmkey != 0)	{		ln = strlen(pmkey);		((*HashMg)+nHashPos)->pentityname = (char *)malloc(ln+1);		strncpy(((*HashMg)+nHashPos)->pentityname, pmkey, ln);		*(((*HashMg)+nHashPos)->pentityname + ln) = 0;	 	}	((*HashMg)+nHashPos)->fqval = fqv;    ((*HashMg)+nHashPos)->score = 0.0001;	if(pidkey != NULL && *pidkey != 0)	{		ln = strlen(pidkey);		((*HashMg)+nHashPos)->pidcode = (char *)malloc(ln+1);		strncpy(((*HashMg)+nHashPos)->pidcode, pidkey, ln);		*(((*HashMg)+nHashPos)->pidcode + ln) = 0;	 	}	return 1;}

    uint64_t BSA::CalcHash(std::string path, std::string ext) {        uint64_t hash1 = 0;        uint32_t hash2 = 0;        uint32_t hash3 = 0;        const size_t len = path.length();        if (!path.empty()) {            hash1 = (uint64_t)(                    ((uint8_t)path[len - 1])                    + (len << 16)                    + ((uint8_t)path[0] << 24)                );            if (len > 2) {                hash1 += ((uint8_t)path[len - 2] << 8);                if (len > 3)                    hash2 = HashString(path.substr(1, len - 3));            }        }        if (!ext.empty()) {            if (ext == ".kf")                hash1 += 0x80;            else if (ext == ".nif")                hash1 += 0x8000;            else if (ext == ".dds")                hash1 += 0x8080;            else if (ext == ".wav")                hash1 += 0x80000000;            hash3 = HashString(ext);        }        hash2 = hash2 + hash3;        return ((uint64_t)hash2 << 32) + hash1;    }

int GetHashTablePos_easy( har *lpszString, SOMESTRUCTURE *lpTable ) //lpszString要在Hash表中查找的字符串，lpTable为存储字符串Hash值的Hash表。{     int nHash = HashString(lpszString);  //调用上述函数二，返回要查找字符串lpszString的Hash值。    int nHashPos = nHash % nTableSize;     if ( lpTable[nHashPos].bExists  &&  !strcmp( lpTable[nHashPos].pString, lpszString ) ) 		//如果找到的Hash值在表中存在，且要查找的字符串与表中对应位置的字符串相同    {          return nHashPos;    //则返回上述调用函数二后，找到的Hash值    }     else    {        return -1;      } }

void AddSymbol(char *Name, int Value){	Symbol sym;	int hash = HashString(Name);	if (InSymbolList(hash))		Error("Symbol '%s' already exists", Name);	sym.Hash = hash;	sym.Name = Name;	sym.Value = Value;	Symbols.push_back(sym);}

	virtual void Execute(const DataObject &object)	{		// The current player is now in a blocking action.        RULE.Execute(shRuleBeginBlockingAction, DataObject(current()));		wxASSERT(1 <= object.numItems());		//retrieve the text to put in the MessageUI		DataObject input(0), output;				const HashString& state = gameData<HashString>(shState);		if(false == DecideHash(state, input, output))		{			wxLogError(				wxString::Format(wxT("Programmer Error: No State %s in ")				wxT("RuleRequestInitialRoadSeafarers"), state.cwx_str()));			return;		}		wxASSERT(3 == output.numItems());		wxString text1 = output.read<wxString>();		wxString text2 = output.read<wxString>(1);		HashString logic = HashString::Format(shLogicStringFormat.c_str(),			output.read<HashString>(2).c_str());		HashString rule = HashString::Format(shRuleStringFormat.c_str(),			output.read<HashString>(2).c_str());		//if this involves ships, do some crazy mojo		if(TRUE == gameData<wxInt32>(shInitialShip))		{			text1 = stPlaceAShip;			text2 = stWaitingPlaceAShip;			wxInt32 index = logic.find(shRoad);			wxASSERT(-1 != index);			logic.replace(index, 4, shShip);            logic = HashString(logic.c_str());		}		RULE.Execute(shRuleUpdateMessageUI, 			DataObject(text1, text2));						RULE.Execute(shRuleLocateInitialRoad, DataObject(			object.read<wxInt32>(), logic, rule));	}

bool PacaReader::GetResource( const std::string& resourcePath, void* outBuffer, uint32_t outBufferSize ){    bool result = false;    uint32_t pathHash = HashString( resourcePath );    if ( m_HeaderInfo.find( pathHash ) != m_HeaderInfo.end() )    {        const ResoureMetaData& resourceMetaData = m_HeaderInfo.at( pathHash );        if ( resourceMetaData.ByteSize <= outBufferSize )        {            m_InStream.seekg( resourceMetaData.StartIndex );            m_InStream.read( static_cast<char*>( outBuffer ), resourceMetaData.ByteSize );            result = true;        }    }    return result;}

CElement::CElement ( CElement* pParent, CXMLNode* pNode ){    // Allocate us an unique ID    m_ID = CElementIDs::PopUniqueID ( this );    // Init    m_pParent = pParent;    m_pXMLNode = pNode;    m_pElementGroup = NULL;    m_iType = CElement::UNKNOWN;    m_strName = "";    m_strTypeName = "unknown";    m_bIsBeingDeleted = false;    m_usDimension = 0;    m_ucSyncTimeContext = 1;    m_ucInterior = 0;    m_bMapCreated = false;    // Store the line    if ( m_pXMLNode )    {        m_uiLine = m_pXMLNode->GetLine ();    }    else    {        m_uiLine = 0;    }    // Add us to our parent's list    if ( pParent )    {        pParent->m_Children.push_back ( this );    }    m_uiTypeHash = HashString ( m_strTypeName.c_str () );    if ( m_pParent )        CElement::AddEntityFromRoot ( m_uiTypeHash, this );    // Make an event manager for us    m_pEventManager = new CMapEventManager;    m_pCustomData = new CCustomData;    m_pAttachedTo = NULL;    m_szAttachToID [ 0 ] = 0;}

const char* resGetNamefromData(const char* type, const void *data){	RES_TYPE	*psT;	RES_DATA	*psRes;	UDWORD   HashedType;	if (type == NULL || data == NULL)	{		return "";	}	// Find the correct type	HashedType = HashString(type);	// Find the resource table for the given type	for (psT = psResTypes; psT != NULL; psT = psT->psNext)	{		if (psT->HashedType == HashedType)		{			break;		}	}	if (psT == NULL)	{		ASSERT( false, "resGetHashfromData: Unknown type: %x", HashedType );		return "";	}	// Find the resource in the resource table	for(psRes = psT->psRes; psRes; psRes = psRes->psNext)	{		if (psRes->pData == data)		{			break;		}	}	if (psRes == NULL)	{		ASSERT( false, "resGetHashfromData:: couldn't find data for type %x/n", HashedType );		return "";	}	return psRes->aID;}

/*----------------------------------------------------------------------------- Function: Cvar_FindVar -Return cvar;  Parameters: var_name -[in] Name of cvar to lookup.  Returns: NULL if cvar not found, otherwise returns the cvar.  Notes: -----------------------------------------------------------------------------*/cvar_t *Cvar_FindVar( const char *var_name ){	cvar_t	*var;	int hashid;	hashid = HashString( var_name );		for( var = cvar_vars ; var ; var = var->next )	{		if( hashid == var->hashid && !strcasecmp( var_name, var->name ) )		{			return var;		}	}	return NULL;}

void CWedDoc::SaveRedo(){	CString droot; int hhh = HashString(GetPathName());	droot.Format("%sdata//%x.rdo", dataroot, hhh);	//P2N("Save Redo To: %s/r/n", droot); 	CFile cf;	if( cf.Open(droot, CFile::modeCreate | CFile::modeWrite ))		{		CArchive ar( &cf, CArchive::store);		redo.Serialize(ar);		}	else		{		//P2N("Cannot create redo file: %s/r/n", droot);		}}

BHttpAuthentication&BUrlContext::GetAuthentication(const BUrl& url){	BString domain = url.Host();	domain += url.Path();	BHttpAuthentication* authentication = NULL;	do {		authentication = fAuthenticationMap->Get( HashString(domain.String(),			domain.Length()));		domain.Truncate(domain.FindLast('/'));	} while(authentication == NULL);	return *authentication;}

void CElement::FindAllChildrenByType ( const char* szType, lua_State* pLua ){    assert ( szType );    assert ( pLua );    // Add all children of the given type to the table    unsigned int uiIndex = 0;    unsigned int uiTypeHash = HashString ( szType );    if ( this == g_pGame->GetMapManager ()->GetRootElement () )    {        GetEntitiesFromRoot ( uiTypeHash, pLua );    }    else    {        FindAllChildrenByTypeIndex ( uiTypeHash, pLua, uiIndex );    }}