Trying to build a hashtable using linked lists

all your errors seem to stem from using 'LONG' instead of 'long'. C++ is case sensitive. if you really want to use LONG instead of long for some reason you'll have to typedef it.
typedef long LONG

 I suggest you just search and replace LONG for long and recompile.

> I'd start by adding
> typedef long LONG;

I think that won't help the case here.  Sandra-24 is trying to define a structure named LONG.
long is already a predefined type in C++ (long integer).

The solution turned out to be declaring the struct as

typedef struct nodeLong {
      long hash;
        struct nodeLong * next;
      long data;
} nodeLongType;

and replacing all references to LONG with nodeLongType.

in the previous code I was declaring a pointer to LONG in the struct, but of course LONG is only defined as a type after the struct has been defined!

Thanks to all who responded - actually just to VEngineer, who was the only one to read the question carefully enough to spot that LONG was a struct, not a long integer.

Yes shaj, I forgot to mention I also had to ditch the define NULL. Sorry you didn't see my post above, you went to all that work for nothing! Well almost nothing, I'll hand out points for this anyway.

Hi,

*I assume that you are using turbo C for compiling your program because LONG is already typecast as long in VC++ environment
typedef LONG long...
So it is wrong to use LONG -> already defined........
So first thing change LONG to some other name like _LONG

* Second the member variable "data" of   LONG is same as the class name "data" so change their name...
  like

typedef struct {
    long hash;
   _LONG *next;
    long ldata;  // change the name
}_LONG;          

since class data is using _LONG take the structure above class data or forward declare _LONG.

* strHash was not define...... So define it somewhere.... as a function or #define.... like

 #define strHash(str, key) key/2

I just modified your program a little bit......

check it out

//**************************************************************
#include <iostream.h>
#include <string.h>

typedef struct {            // The definition of _LONG is moved up
    long hash;
   _LONG *next;
    long ldata;
}_LONG;     // name modified

#define strHash(str, key) key/2     // strHash defined

class data
{
public:
    data(int hashTableLength);
    ~data();
    // Adds a long integer value to the hash table under the 32bit hash key given
    void Add(const long value, const char * key);

     // Gets a long integer value from the hash table at the given 32 bit hash key
    long GetLong(const char * key);

private:

    _LONG **longs;
    int hashTableLength;
};


//-----------------------------------------------------------------------------------
//DATA.CPP:

#include "data.h"

data::data(int hashTableLength)
{
    longs = new _LONG * [hashTableLength];
    //init all the pointers at NULL (to prevent stray pointer errors)
    for(int i=0; i < hashTableLength; i++)
    {
         longs[i] = NULL;
    }
    //store the length for future usage.
    this->hashTableLength = hashTableLength;
}

data::~data()
{
    //store the data to disk and free all the memory used

}

// Adds a long integer value to the hash table under the 32bit hash key given
void data::Add(const long value, const char * key)
{
    long hash = strHash(key,strlen(key));
    int index = (int)(hash % hashTableLength); //0-49 for a length of 50

    _LONG * entry = longs[index];

    while((entry->next != NULL) && (entry->hash != hash))
    {
         entry = entry->next;
    }

    //so now, this entry->next pointer is either NULL (making it the lest entry)
    //or we've stumbled across an existing entry by this key.
    if(entry->hash == hash)
    {
         entry->ldata = value;
    }
    //else we need to add a new entry to the end
    else
    {
         entry->next = new _LONG; //add a new struct
         entry = entry->next; //set entry to point to the new struct
         entry->next = NULL; //set the next pointer to NULL (we're at the end after all)
         //set the data for this struct
         entry->hash = hash;
         entry->ldata = value;
    }

}


long data::GetLong(const char * key)
{
    long hash = strHash(key,strlen(key));
    int index = (int)(hash % hashTableLength); //0-49 for a length of 50

    _LONG * entry = longs[index];

    while((entry != NULL) && (entry->hash != hash))
    {
         entry = entry->next; //set entry to point to the next _LONG struct
    }

    if(entry == NULL)
         return 0; //not found
    else
         return entry->ldata;
}




Hope this will work.....
Dennis

Good to hear you found a solution.

From what I understand in C++, what you have:

// the classic way you define structs in C

typedef struct nodeLong {
    long hash;
       struct nodeLong * next;
    long data;
} nodeLongType;


should be completely equivalent to:

// the way I've always defined structs in C++

struct nodeLongType {
    long hash;
    nodeLongType * next;
    long data;
};


This being said, classes and structs are the same in C++, except members of a class are private by default and members of a struct are public by default.  Yep, a struct in C++ can have member functions as well as data members.  So defining them is the same and we don't need to fuss with typedefs and using the struct keyword for recursive types like the node you have here :)  Just something to think about.