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]

typedef class key_word key_word_T;

typedef class key_word_sort key_word_sort_T ;

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]

error message text

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]

found the solution in Meyers, Effective STL item 22

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