Programming Forums > Application Development > C++

manannan · May 30th, 2006, 7:09 PM

When using the STL, I'd often want to instantiate an anonymous functor -- something like this:

#include <set>
#include <algorithm>

int main()
{
  std::set<int> s;
  s.insert(1); s.insert(2);

  class
  {
  public:
    bool operator () (int a, int b) { return a < b; }
  } comparer;

  bool test = comparer(1, 2); // Works
  return *( std::max_element(s.begin(), s.end(), comparer) ); // Fails!
}

The problem is, under gcc, this fails with the error

(Toggle Plain Text)

test.cpp:17: error: no matching function for call to �max_element(std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, main()::<anonymous class>&)�

Looking at the <algorithm> header, I say that the error message makes no sense, and the program should compile just fine.
Now it seems that the only way for me to use a functor is to make its class global. But isn't there a way to somehow avoid cluttering the global namespace and keep the code beautiful? Or should I report a bug in the gcc? :-)

The Dark · May 30th, 2006, 8:01 PM

You can't do it in Visual Studio either (I'm not sure why there is this restriction, but there is probably a good reason).

Quote:

illegal use of anonymous local type in template instantiation

You cannot generate a template function (a function from a function template) based on a local type. Types used to instantiate templates must have external linkage.

Even if you give it a name, you get:

Quote:

'name' : illegal use of local type in template instantiation

You cannot generate a template function (a function from a function template) based on a local type. Types used to instantiate templates must have external linkage.

One way to fix this is to use your own namespace. It is a bit uglier as the class has to be outside of your function.

(Toggle Plain Text)

#include <set>
#include <algorithm>

namespace myNamespace
{
  class comparer
  {
  public:
    bool operator () (int a, int b) { return a < b; }
  };
}

int main()
{
  std::set<int> s;
  s.insert(1); s.insert(2);

  myNamespace::comparer comparer;

  bool test = comparer(1, 2); // Works
  return *( std::max_element(s.begin(), s.end(), comparer) ); // Fails!
}

grumpy · May 30th, 2006, 8:48 PM

The reason comes down to how templates are instantiated. In essence, a template can only be instantiated for types that have external linkage (in your context, they cannot be anonymous). If you want to avoid cluttering the global namespace with your algorithms, place them in a namespace of their own.

In this example, as you're using <algorithm> anyway, why not use this?

(Toggle Plain Text)

   return *( std::max_element(s.begin(), s.end(), std::less<int>()) );

manannan · May 30th, 2006, 9:24 PM

Thank you, Dark and Grumpy. When I grow up, I'll weasel my way into the ISO C++ Standards Committee and make them abolish the restriction.
Overloading operator < for my classes seems like a good solution in this case -- though I use functors for more than finding max_element(). Thanks for the idea.

grumpy · May 31st, 2006, 1:25 AM

Quote:

Originally Posted by manannan

Thank you, Dark and Grumpy. When I grow up, I'll weasel my way into the ISO C++ Standards Committee and make them abolish the restriction.

I wish you good hunting, but am prepared to bet you won't succeed. The reason for the restriction is to allow C++ implementations flexibility of how they implement template instantiation behind the scenes. Some implementations use template repositories, and the actual process of template instantiation happens at link time rather than at compile time (that means a smarter linker working with a slightly dumber compiler). The benefit of such schemes is reducing code bloat (eg multiple identical instantiations of a template within a single executable) by allowing the linker to instantiate each template specialisation only once. A side-effect of such schemes is that all template type parameters must have external linkage.

May 30th, 2006, 7:09 PM	#1
manannan Newbie Join Date: May 2006 Posts: 2 Rep Power: 0	Using internal classes in STL functions When using the STL, I'd often want to instantiate an anonymous functor -- something like this: (Toggle Plain Text) #include <set> #include <algorithm> int main() { std::set<int> s; s.insert(1); s.insert(2); class { public: bool operator () (int a, int b) { return a < b; } } comparer; bool test = comparer(1, 2); // Works return ( std::max_element(s.begin(), s.end(), comparer) ); // Fails! } #include <set> #include <algorithm> int main() { std::set<int> s; s.insert(1); s.insert(2); class { public: bool operator () (int a, int b) { return a < b; } } comparer; bool test = comparer(1, 2); // Works return ( std::max_element(s.begin(), s.end(), comparer) ); // Fails! } The problem is, under gcc, this fails with the error (Toggle Plain Text) test.cpp:17: error: no matching function for call to �max_element(std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, main()::<anonymous class>&)� test.cpp:17: error: no matching function for call to �max_element(std::_Rb_tree_const_iterator<int>, std::_Rb_tree_const_iterator<int>, main()::<anonymous class>&)� Looking at the <algorithm> header, I say that the error message makes no sense, and the program should compile just fine. Now it seems that the only way for me to use a functor is to make its class global. But isn't there a way to somehow avoid cluttering the global namespace and keep the code beautiful? Or should I report a bug in the gcc? :-) Last edited by manannan; May 30th, 2006 at 7:34 PM.

May 30th, 2006, 8:48 PM	#3
grumpy Programming Guru Join Date: Jun 2005 Location: Adelaide, South Australia Posts: 1,222 Rep Power: 5	The reason comes down to how templates are instantiated. In essence, a template can only be instantiated for types that have external linkage (in your context, they cannot be anonymous). If you want to avoid cluttering the global namespace with your algorithms, place them in a namespace of their own. In this example, as you're using <algorithm> anyway, why not use this? (Toggle Plain Text) return ( std::max_element(s.begin(), s.end(), std::less<int>()) ); return ( std::max_element(s.begin(), s.end(), std::less<int>()) );

Thread Tools
Show Printable Version Email this Page
Display Modes
Linear Mode Switch to Hybrid Mode Switch to Threaded Mode

May 30th, 2006, 9:24 PM	#4
manannan Newbie Join Date: May 2006 Posts: 2 Rep Power: 0	Thank you, Dark and Grumpy. When I grow up, I'll weasel my way into the ISO C++ Standards Committee and make them abolish the restriction. Overloading operator < for my classes seems like a good solution in this case -- though I use functors for more than finding max_element(). Thanks for the idea.

Currently Active Users Viewing This Thread: 1 (0 members and 1 guests)

Programming Forums > Application Development > C++

Using internal classes in STL functions