how can I reference a member function using a SET itor

[jfwfmt]

Please pardon my ignorance. I'm writing a C++ STL program after not writing code for 7 years, I'm trying to invoke key_word.inc() using an iterator for a set containing key_word_T. The following is a pared down version.

#include <cstdlib>
#include <set>
#include <string>
using namespace std;
 
class key_word
{
public:
  string word  (void) const         { return (wordX);     }
  void   inc   (void)               { ++countX;           }
private:
  string wordX;
  int countX;
}; /* class key_word */
 
typedef class key_word key_word_T;
 
class key_word_sort
{
public:
  bool operator () (const key_word_T& leftA, const key_word_T& rightA) const
  {
    return (leftA.word() < rightA.word());
  } /* operator () */
}; /* class key_word_sort */
 
typedef class key_word_sort key_word_sort_T;
 
set <key_word_T, key_word_sort_T> global_keys; // all keywords
set <key_word_T, key_word_sort_T> local_keys;  // this document's keywords
pair<set<key_word_T, key_word_sort_T>::iterator, bool> global_result;
pair<set<key_word_T, key_word_sort_T>::iterator, bool>  local_result;
set<key_word_T, key_word_sort_T>::iterator global_itor;
set<key_word_T, key_word_sort_T>::iterator  local_itor;
 
string one_word;
 
int main (int, char**)
{
  one_word = "$FOOBAR";
 
  global_result = global_keys.insert (one_word); // compiles in full code, not in example
  key_word_T local_key(*global_result.first); 
  local_result =  local_keys.insert (local_key);
  global_itor = global_result.first;
  (*global_itor).inc();  // want to invoke key_word.inc() on global_keys copy
 
 
  return (EXIT_SUCCESS);
} /* main () */

[Banfa]

@jfwfmt
Your typedefs are unnecessary in C++ you can use the class name as the type name without the class keyword (same goes for structs unions and enums) so you can declare your variables as

set <key_word, key_word_sort> global_keys; // all keywords
set <key_word, key_word_sort> local_keys;  // this document's keywords
pair<set<key_word, key_word_sort>::iterator, bool> global_result;
pair<set<key_word, key_word_sort>::iterator, bool>  local_result;
set<key_word, key_word_sort>::iterator global_itor;
set<key_word, key_word_sort>::iterator  local_itor;
 

Talking of variables that is an awful lot of global variables you have there, I would consider that bad practice in C let alone C++.

(*global_itor). inc(); // want to invoke key_word.inc() on global_keys copy

The iterator is a pointer to your type so this should work although I would write it as

global_itor->inc(); // want to invoke key_word.inc() on global_keys copy

but the 2 syntaxes have the same meaning.

Did it produce any compiler diagnostics?

[jfwfmt]

Thanks for the style suggestions

global_itor->inc();

and

(*global_itor).inc();

produce the identical error message (g++)

error:passing 'const key_word' as 'this' argument of 'void key_word::inc() ' discards qualifiers

[newb16]

It looks like dereferenced iterator is a const reference, so you can call only 'const' members with it as 'this'. I could not find proof of it in online references, but it is easily explained - if you could modify set members in some other way then insertion/deletion, it may violate their order, make them non-unique, etc.

[jfwfmt]

Thanks, your hint about const ness was the clue. It turns out that STL implementations differ on the const of set objects. GNU makes them const.

Meyers shows a workaround for non-key data members of the objects in the set, using a cast to alter the const ness of the reference

const_cast<key_word_T&>(*global_itor).inc();

is the fix

/s/ Jim WIlliams