Hacker News Board Hacker News, browsed like a classic message board
Live data from Hacker News

Iterators: Signs of Weakness in Object-Oriented Languages

home.pipeline.com

Post reply on HN
Print view View original

1–10 of 12 posts

Re: Iterators: Signs of Weakness in Object-Oriented Languages

#3

Post by scott_s »

While C++0x will have proper lamdbas and closures (I've said this how many times in the past few weeks?), I think it's worth noting the "proper" way to emulate a closure in C++ is with a function object. Example:

  struct Summation {
    int& sum;
    Summation(int& s): sum(s) {}
    void operator()(int n)
    {
      sum += n;
    }
  };

  vector numbers;
  int sum = 0;
  // give numbers some interesting values
  for_each(numbers.begin(), numbers.end(), Summation(sum));
  cout
C++0x lambdas will generate code very similar to this. The need to explicitly define a named struct/class and function object is an obvious weakness of this technique.

Although I do agree with his overall point, which is that the need to use iterators for all sequences is a code smell. It forces the programmer to work at a lower level when they often just want to say "Perform this operation on my data."

Re: Iterators: Signs of Weakness in Object-Oriented Languages

#5

Post by lincolnq »

scott_s wrote: post #3

While C++0x will have proper lamdbas and closures (I've said this how many times in the past few weeks?), I think it's worth noting the "proper" way to emulate a closure in C++ is with a function object. Example: struct Summation { int& sum; Summation(int& s): sum(s) {} void operator()(int n) { sum += n; } }; vector numbers; int sum = 0; // give numbers some interesting values for_each(numbers.begin(), numbers.end(),…

Interesting. Your comment about C++0x closures inspired me to look it up on Wikipedia.

The verbosity of the fragment above is greatly reduced. You had to write 'sum' or 's' lots of extra times ('Summation(sum)', 'sum(s)', 'int& sum', and 'int& s'), and you won't have to do that anymore -- according to wikipedia your function will change in C++0x to:

    for_each( numbers.begin(), numbers.end(), [&sum](int n) { sum += n; } );
Which is semantically much less to think about. It also still has the feature / annoyance (?) of having to specifically identify which variables to capture from the environment ('sum', as a reference; it seems you can capture variables by value too).

Fortunately, it seems the C++ people even thought of that annoyance, and allow you to write:

    for_each( numbers.begin(), numbers.end(), [&](int n) { sum += n; } );
capturing references to all variables in the enclosing scope. Neat!

Re: Iterators: Signs of Weakness in Object-Oriented Languages

#6

Post by pcof »

It's worth reading the Abstract Heresies' entry that turned my attention to this paper: http://funcall.blogspot.com/2010/05/c-vs-lisp.html (After giving it a thought I posted this entry to HN too, as I probably should have done in the first place... :))

The date is interesting, 1992 - it would still take years for Java to implement it...wrong.

Re: Iterators: Signs of Weakness in Object-Oriented Languages

#7

Post by scott_s »

lincolnq wrote: post #5
scott_s wrote: post #3

While C++0x will have proper lamdbas and closures (I've said this how many times in the past few weeks?), I think it's worth noting the "proper" way to emulate a closure in C++ is with a function object. Example: struct Summation { int& sum; Summation(int& s): sum(s) {} void operator()(int n) { sum += n; } }; vector numbers; int sum = 0; // give numbers some interesting values for_each(numbers.begin(), numbers.end(),…

Interesting. Your comment about C++0x closures inspired me to look it up on Wikipedia. The verbosity of the fragment above is greatly reduced. You had to write 'sum' or 's' lots of extra times ('Summation(sum)', 'sum(s)', 'int& sum', and 'int& s'), and you won't have to do that anymore -- according to wikipedia your function will change in C++0x to: for_each( numbers.begin(), numbers.end(), [&sum](int n) { sum += n;…

Indeed. I actually use this technique in my own code, and I feel like I'm laying down pipe all over the place to make sure the captured variable gets routed to the function object correctly. Once you do it a few times, it is obviously boiler-plate code and obviously a hindrance to momentum.

Re: Iterators: Signs of Weakness in Object-Oriented Languages

#9

Post by malbs »

Conveniently ignored Smalltalk, which at the time, would have been seeing a lot more use than it does now.

I missed the date of the article at first, it wasn't until I looked at the C code and had to double take it, because it wasn't ANSI C, and my initial reaction was "hang on wait a minute" then checked the date on the article.... yeah.

Post reply on HN