Thread: stl::vector pass by reference

I noticed that I had to pass by reference in order to change the actual vector object I used. But curious as to why for the print_table, I don't have to pass by reference, BUT for the trivial clear_table function I need to (otherwise Frank doesn't get removed from the list).

I'm just building trivial open addressing hash table using double hashing.

Code:

//FNV string hash fcn (src:http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx)
//Helper fcn used in open_address_insert/remove/search operations
unsigned int fnv_hash(const void* key, int len)
{
   const unsigned char* p = static_cast<const unsigned char*>(key);
   unsigned int h = 2166136261;
   
   for (int i = 0; i < len; i++)
     h = (h * 16777619) ^ p[i];
   
   return h;
}

//note: no duplicates, no values (very simplified double hashing method of open addressing)
void insert_via_double_hashing(vector<string>& list, const string& key)
{
    size_t size = list.size();
    size_t cur_bucket = fnv_hash(key.c_str(), key.size() ) % size;
    size_t second_hash_fcn = (fnv_hash(key.c_str(), key.size() ) % (size - 1) ) + 1;//NB: 2nd hash fcn is a step size
    
    for ( size_t i = 0; i < list.size(); ++cur_bucket )
    {    
        if ( list[cur_bucket] == "deleted" || list[cur_bucket] == "" )
        {
            list[cur_bucket] = key;
            // cout << list[cur_bucket] << endl;
            cout << "SUCCESS. Key:[" << key << "] inserted @:[" << cur_bucket << "]." << endl;
            return;
        }
        
        cur_bucket = (cur_bucket + second_hash_fcn) % size;
    }
}


void print_table(vector<string> v)
{
    cout << "PRINTING TABLE..." << endl;
    
    for ( size_t i = 0; i < v.size(); ++i )
        cout << v.at(i) << ", ";
    cout << endl;
}

//NB:redundant, but to hide details
void clear_table(vector<string>& v)
{
    v.assign(10,"");
}

int main()
{
  vector<string> namebook;
    namebook.assign(10,"");

    namebook[2] = "Frank";
    
    for ( size_t i = 0; i < namebook.size(); ++i )
        cout << namebook.at(i) << ", ";
    cout << endl;
    
    clear_table(namebook);
    
    insert_via_double_hashing(namebook, "joe");
  
  return 0;
}

EDIT: or I shouldn't worry since I didn't build the vector class and so the details of how it knows is part of compiler and library writer's job?

I understand what pass by value, by reference, by address all mean. What I forgot and you're post reminded me was that we can pass an entire object by value (so instance of a class, struct) which is inefficient b/c of size (so copy all members etc as you said). That was the part I didn't know for why we can just pass by value for print_table, I forgot I was dealing w/ an object, since I am so used to using arrays (not the STL containers array, just plain old array) as in:

Code:

void print_list(string* list, size_t size)//need to pass array by address in this case
{
  for ( size_t i = 0; i < size; ++i )
   cout << list[i] << ", ";
  cout << endl;
}

int main()
{ 
  string list[10] = {""};
  size_t size = sizeof(list)/sizeof(list[0]);
  print_list(&list[0], size);

 return 0;
}

So you notice how for this print list, I need to pass by address. Appreciate it.

On a side note your print table should actually use a const reference since it does not modify the object and to avoid the unecessary copy. Likewise nothing is gained by using at() in print_ table as opposed to a simple index since the number of iterations is determined by vector::size() which ensures that all indices within the loop will be within range of the vector. Nothing is lost however by using at() but I thought I would mention it.

Also, the at member function will throw an exception if you access out of bounds indexes. This may come in handy sometimes.
The index operator will yield undefined behavior if you do out-of-bounds access. However, most compilers (at least the ones I know) will break in debug mode if you do, in order to help you debug.