-3

下面是我
创建哈希表的代码，其中键为 Char*，值作为函数指针

// hash1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"


#include <iostream> 
#include <cstdlib> 
#include <cstring> 
#include <iomanip> 
#define SIZE_KEY       16 
#define SIZE_VALUE1    64 
#define SIZE_VALUE2    16 
#define DEFAULT_TABLESIZE    101 
using namespace std; 
typedef void (*FunctionPtr)(); 
typedef void (*FunctionPtr1)(); 
void (*FunctionPtr2)(); 

  void ping(){
    cout<<"hello";
  }
  void refresh(){
    cout<<"refresh";
  }

typedef struct NODE 
{ 
   NODE(char* Key1,FunctionPtr func_ptr) 
   { 


      strcpy_s(Key,Key1);
      FunctionPtr1 func_ptr1;
      func_ptr1=func_ptr;

      next = NULL; 
   } 
   NODE(){
   }
    char Key[SIZE_KEY]; 
    FunctionPtr1 func_ptr1[SIZE_VALUE1]; 
    NODE *next; 
}; 

class Hashtable 
{ 
   private: 
      int table_size; 
      NODE** table; 
      int size; 
      long hashString(char* Key);
      NODE* find(char* Key); 
      NODE* current_entry; 
   public: 
      int current_index; 
      Hashtable(int T = DEFAULT_TABLESIZE);//constructor 
      virtual ~Hashtable();//destructor 
      bool put(NODE *); 
      bool get(NODE *); 
      bool contains(char* Key); 
      void removeAll(); 
      int getSize(); 
      void initIterator(); 
      bool hasNext(); 
      void getNextKey(char* Key); 
      friend void disp(NODE *); 
}; 

Hashtable::Hashtable(int T) 
{ 
   size = 0; 
   table_size = T; 
   table = new NODE*[table_size]; 
   for(int i=0; i<table_size; i++) 
   { 
      table[i] = NULL; 
   } 
} 

Hashtable::~Hashtable() 
{ 
   removeAll(); 
   delete[] table; 
} 

bool Hashtable::put(NODE *N) 
{//start put 
   if(find(N->Key) != NULL) 
   { 
      return false; 
   } 
   //NODE* entry = new NODE( N->Key ,*(FunctionPtr *)N->func_ptr1 );
   NODE* entry = new NODE( N->Key ,*(FunctionPtr *)N->func_ptr1 );
   int bucket = hashString(N->Key); 
   entry->next = table[bucket]; 
   table[bucket] = entry; 
   size++; 
   return true; 
}//end put 


bool Hashtable::get(NODE* N) 
{//start get 
   NODE* temp = find(N->Key); 
   if(temp == NULL) 
   { 
       *(FunctionPtr *)N->func_ptr1 = refresh; 
      return false; 
   } 
   else
   { 
    *(FunctionPtr *)N->func_ptr1= *(FunctionPtr *)temp->func_ptr1;

      return true; 
   } 
}//end get 

bool Hashtable::contains(char* Key) 
{//start contains 
   if(find(Key) == NULL) 
   { 
      return false; 
   } 
   else
   { 
      return true; 
   } 
}//end contains 





void Hashtable::removeAll() 
{//start removeAll 
   for(int i=0; i<table_size; i++) 
   { 
      NODE* temp = table[i]; 
      while(temp != NULL) 
      { 
         NODE* next = temp->next; 
         disp(temp); 
         delete temp; 
         temp = next; 
      } 
   } 
   size = 0; 
}//end removeAll 

int Hashtable::getSize() 
{ 
   return size; 
} 

NODE* Hashtable::find(char* Key) 
{ //start find 
   int bucket = hashString(Key); 
   NODE* temp = table[bucket]; 
   while(temp != NULL) 
   { 
      if(strcmp(Key, temp->Key) == 0) 
      { 
         return temp; 
      } 
      temp = temp->next; 
   } 
   return NULL; 
}//end find 

long Hashtable::hashString(char* Key) 
{//start hashString 
   int n = strlen(Key); 
   long h = 0; 
   for(int i=0; i<n; i++) 
   { 
      //To get almost fair distributions of NODEs over the array 
      h = (h << 3) ^ Key[i]; 
   } 
    return abs(h % table_size ); 
}//end hashString 

void Hashtable::initIterator() 
{//start initIterator 
   current_entry = NULL; 
   current_index = table_size; 
   for(int i=0; i<table_size; i++) 
   { 
      if(table[i] == NULL) 
      { 
          continue; 
      } 
      else
      { 
         current_entry = table[i]; 
         current_index = i; 
         break; 
      } 
   } 
}//end initIterator 

bool Hashtable::hasNext() 
{ 
   if(current_entry == NULL) 
   { 
      return false; 
   } 
   else
   { 
      return true; 
   } 
} 
void Hashtable::getNextKey(char* Key) 
{ 
   if(current_entry == NULL) 
   { 
      Key[0] = '\0'; 
      return; 
   } 
   strcpy(Key, current_entry->Key); 
   if(current_entry->next != NULL) 
   { 
      current_entry = current_entry->next; 
   } 
   else
   { 
     for(int i=current_index+1; i<table_size; i++) 
     { 
        if(table[i] == NULL) 
        { 
           continue; 
        } 
        current_entry = table[i]; 
        current_index = i; 
        return; 
     } 
     current_entry = NULL; 
     current_index = table_size; 
   } 
} 

void dispAll(Hashtable* hashtable); 

int main() 
{ 
   char temp1[SIZE_KEY]; 
   Hashtable* hashtable = new Hashtable(); 

   NODE N1("1",ping); 
   if(!hashtable->contains(N1.Key)) 
   { 
      cout << "\nAdding NODE:  "; 
      disp(&N1); 
      hashtable->put(&N1); 
   } 
 //  dispAll(hashtable);


   strcpy(N1.Key, "314"); 
    *(FunctionPtr *) N1.func_ptr1=refresh;

   if(!hashtable->contains(N1.Key)) 
   { 
      cout << "\nAdding NODE:  "; 
      disp(&N1); 
      hashtable->put(&N1); 
   } 

 /*  strcpy(N1.Key, "320"); 
    *(FunctionPtr *) N1.func_ptr1= ping; 


   if(!hashtable->contains(N1.Key)) 
   { 
      cout << "\nAdding NODE:  "; 
      disp(&N1); 
      hashtable->put(&N1); 
   } 

   strcpy(N1.Key, "768"); 
   *(FunctionPtr *)N1.func_ptr1= refresh; 
   if(!hashtable->contains(N1.Key)) 
   { 
      cout << "\nAdding node:  "; 
      disp(&N1); 
      hashtable->put(&N1); 
   } 

   strcpy(N1.Key, "756"); 
 *(FunctionPtr *) N1.func_ptr1= refresh;

   if(!hashtable->contains(N1.Key)) 
   { 
      cout << "\nAdding node:  "; 
      disp(&N1); 
      hashtable->put(&N1); 
   } */

   dispAll(hashtable); 

   // strcpy(temp1,"314"); 
  // hashtable->remove(temp1); 
  // cout << "\n\nAfter removing 314:" << endl; 
 //  dispAll(hashtable); 
   cout << "\n\nDestroying hashtable:" << endl; 
   delete hashtable; 
   return 0; 
} 


void disp(NODE *N1) 
{ 
 cout << "\nKey:      " << N1->Key << "\nFunction "
      << N1->func_ptr1 << endl; 
// FunctionPtr2();
} 



void dispAll(Hashtable *hashtable) 
{ 
    NODE N1; 
    cout << "\n\nCurrent nodes in hashtable:" << endl; 
    hashtable->initIterator(); 
    while(hashtable->hasNext()) 
    { 
        //cout<<"Current Index === "<<hashtable->current_index;
        hashtable->getNextKey(N1.Key); 
        hashtable->get(&N1); 
        disp(&N1); 
    } 
}

每次将数据写入哈希表 VALUE 包含相同的地址 :( 我想要我将发送的特定函数的地址..

4

1 回答 1

0

有些问题可能在struct NODE. 

typedef struct NODE 
{ 
   NODE(char* Key1,FunctionPtr func_ptr) 
   { 
      strcpy_s(Key,Key1);
      FunctionPtr1 func_ptr1; // <-- Problem may be here
      func_ptr1=func_ptr;

      next = NULL; 
   } 
   NODE(){
   }

   char Key[SIZE_KEY]; 
   FunctionPtr1 func_ptr1[SIZE_VALUE1];  // <-- And here
   NODE *next; 
};

您声明了一个本地func_ptr1in NODE::NODE(char*, FunctionPtr)，并将参数分配func_ptr给func_ptr1. 因此，func_ptr被分配给一个局部变量，而不是一个成员变量。而且，一旦构造函数返回，函数指针就不会被记住。
另一个问题：为什么是NODE::func_ptr1一个数组FunctionPtr1？我不认为您打算在一个NODE实例中存储多个函数指针。

于 2012-09-27T16:44:55.550 回答