Despite some harsh words about Visual Studio 11, I’m finding that it makes my heart go pitter-pat every time I use it. Why? Because this early release is finally incorporating a decent set of long-awaited C++11 features. In this article I’ll show you how a little thing like a lambda can make a big difference in your coding style.

Microsoft and C++ – We Have History

Microsoft has a cyclic relationship with C++. In the early MFC days, the love was there big time – you had access to most of the system API using C++. However, around the turn of the millennium, Microsoft came under the Rasputin-like influence of Anders Hejlsberg and his beloved offspring, C#. Now it appears that maybe the pendulum is swinging back a bit, and C++ is no longer viewed as an afterthought. Great news.

Although Visual Studio 11 is a developer’s preview, Microsoft is saying that it is production ready – you can use this to create programs that are ready for release. In addition to touting a complete implementation of the C++11 standard library, an impressive list of language features have been turned on as well. (N.B. the path ahead is still long and arduous.)

Modern C++

Before even using Visual Studio C++ 11 to test a single line of code, I really appreciated reading Welcome Back to C++ (Modern C++), a manifesto that includes the following bullet points:

Modern C++ emphasizes:

• Stack-based scope instead of heap or static global scope.
• Auto type inference instead of explicit type names.
• Smart pointers instead of raw pointers.
• std::string and std::wstring types instead of raw char[] arrays.
• Standard template library (STL) containers—for example, vector, list, and map—instead of raw arrays or custom containers.
• STL algorithms instead of manually coded ones.
• Exceptions, to report and handle error conditions.
• Inline lambda functions instead of small functions implemented separately.

I feel that all of these changes result in safer code that is easier to read and maintain, without giving up the type-safety and efficiency that we love so much. Fully implementing these features either leans heavily on C++11 or requires it outright.

A Simple Example Using Naive C++98

It’s interesting to watch the evolution of code from C++ 98 to C++11 and see how it affects your code. You’ll see that the transformation can make it look like you are literally using a new programming language.

In this simple program, I’m taking a Scrabble rack of tiles and whipping through the Scrabble dictionary to find matches. Since it is a one-time call, I’m not storing the words, just doing a quick online comparison. In C++ 98, my code might have looked like this:

void find_matches( std::string rack, const std::string &filename )
{
    std::sort( rack.begin(), rack.end() );
    std::ifstream sowpods( filename.c_str() );
    std::string word;
    while ( sowpods >> word ) {
        std::string sorted = word;
        std::sort( sorted.begin(), sorted.end() );
        if ( sorted == rack )
            std::cout << word << " ";
    }
}

int main(int argc, char* argv[])
{
    find_matches( "etaionsr", "sowpods.txt" );
    return 0;
}

This works properly and I get what looks like correct output:

anoestri arsonite notaries notarise rosinate senorita

Classes Good, Templates Better

As people started to get more comfortable with templates and iterators, algorithms like this were commonly rewritten to take an range of iterators as input – much as the standard library algorithm functions do. This meant changing the function to a template function, but it did make it a lot more flexible. I could now call the function to operate on data from a file, just as before, but I can also now use any other container, or even an array as input:

template<typename ITERATOR>
void find_matches( std::string rack, ITERATOR ii, ITERATOR jj )
{
    std::sort( rack.begin(), rack.end() );
    for ( ; ii != jj ; ii++ ) {
        std::string sorted = *ii;
        std::sort( sorted.begin(), sorted.end() );
        if ( sorted == rack )
            std::cout << *ii << " ";
    }
}

int main(int argc, char* argv[])
{
    std::ifstream sowpods( "sowpods.txt" );
    find_matches( "etaionsr",
                  std::istream_iterator<std::string>( sowpods ),
                  std::istream_iterator<std::string>() );
    return 0;
}

More or less the same number of lines of code, but it is now generic.

Of course, just like with OOP, you need to take some care with template programming. Generic programming can’t be beat when it makes sense, but programmers have a particularly strong susceptibility to pro-innovation bias.

Using the Algorithms Library

Again, prodded by changing styles in the C++ world, my next step is to use a standard library algorithm to do the work. We’re told over and over that turning to the algorithms library allows you to use code that has been optimized to the n-th degree by the clever library teams.

In order to make this work, I have to call an algorithm with a predicate functor, seen below as class sorted_not_equal. Note also that I can’t use the logical function for this, which would be copy_if(). Why not? The committee forgot to put it in back in 1998, 2003, and 2005, a mistake that was fortunately remedied in C++11. So I have to use the inverse function, remove_copy_if(), and invert the logical sense of my functor:

class sorted_not_equal {
    std::string str;
public :
    sorted_not_equal( const std::string & test )
    {
        str = test;
        sort( str.begin(), str.end() );
    }
    bool operator()( std::string test )
    {
        sort( test.begin(), test.end() );
        return ( str != test );
    }
};

template<typename INPUT_ITERATOR, typename OUTPUT_ITERATOR>
void find_matches( std::string rack,
                   INPUT_ITERATOR ii,
                   INPUT_ITERATOR jj,
                   OUTPUT_ITERATOR kk )
{
    std::sort( rack.begin(), rack.end() );
    std::remove_copy_if( ii, jj, kk, sorted_not_equal( rack ) );
}

int main(int argc, char* argv[])
{
    std::ifstream sowpods( "sowpods.txt" );
    find_matches( "etaionsr",
                  std::istream_iterator<std::string>( sowpods ),
                  std::istream_iterator<std::string>(),
                  std::ostream_iterator<std::string>(std::cout,  "\n" ) );
    return 0;
}

Functors Not So Hot

So this new approach is supposed to soup up my code by taking advantage of the algorithms that come with the standard library. But if you look around at the code people have been writing for the past 10 years, you’ll find that this style is pretty common in textbooks and magazine articles, but no so much in the real world.

Why not? Well, it’s pretty obvious. The generic algorithms in the library need lots of predicate glue to make them useful, and the work to create these predicates is just a pain. My code is almost twice as long, and the functionality that took two lines of code earlier is now bloated into a complete class definition. It pollutes my namespace, takes up a lot of space, and has to be defined somewhere distant from where it is actually used. Not a win.

This is obviously a problem when you look at the history of Linux, C, and C++. An entire family of technologies and infrastructure was developed with the implicit goal of reducing the number of keystrokes programmers had to enter. (I’m kidding, but only somewhat.) Functors are a step in the wrong direction.

Lambda to the Rescue

So it is with much relief that C++11 delivers lambdas, which allow us to write short sweet predicates exactly where we need them, as shown in this C++11 version of the example:

template<typename INPUT_ITERATOR, typename OUTPUT_ITERATOR>
void find_matches( std::string rack,
                   INPUT_ITERATOR ii,
                   INPUT_ITERATOR jj,
                   OUTPUT_ITERATOR kk )
{
    std::sort( rack.begin(), rack.end() );
    std::copy_if( ii, jj, kk,
                  [&rack](std::string str) ->bool
                  {
                      std::sort( str.begin(), str.end() );
                      return rack == str;
                  }
                );
}

int main(int argc, char* argv[])
{
    std::ifstream sowpods( "sowpods.txt" );
    find_matches( "etaionsr",
                  std::istream_iterator<std::string>( sowpods ),
                  std::istream_iterator<std::string>(),
                  std::ostream_iterator<std::string>(std::cout,  "\n" ) );
	return 0;
}

Yes, I now have to get used to a new syntax for writing lambda functions – I think that was unavoidable. But my lambda function is short, it is quite easy to see exactly what it is doing, and it replaces a gangly and awkward functor class.

Best of all, I use the lambda exactly where I need it – as the predicate parameter to an algorithm used in the standard library. Locality rules.

Using Lambdas

Visual C++ 11 provides a great framework for experimenting with lambdas, as they are supporting the 1.1 definition that was ratified as part of the standard. If you want the gory details, I believe the working group’s proposal has essentially the same wording that went into the standard. For a detailed tutorial, Herb Sutter’s talk can’t be beat.

Dr. Dobb’s Portal August, 2006 Article on DDJ site

International standards are good, we all love them, sure. But if you aren’t lucky enough to be employed by a big company or a university, getting your hands on these standards can be a real pain. Typically the standards bodies sell electronic copies of their work for fairly high prices, justifying it as one of the only ways they can subsidize their activities.

Just an example, if you want to buy a hardcopy of the C++ standard, you can end up paying as much as $US 175 for the privilege – which is a killer if you are just doing this for personal use.

This turns into a FAQ in public newsgroups and forums when the uninitiated start operating under the idea that they ought to be able to just find a copy on the web. This thread on comp.compression is a classic example, where Nils Haeck is looking for free copies of some of the JPEG documents.

But oddly enough, later on in the thread Nils sheds a piece of light on the discussion, disclosing a piece of news that I hadn’t heard before. It turns out that the ITU has a program in which individuals can get up to three free electronic copies of their standards documents per year. This is exciting!

I thought I’d give it a try by first signing in at the ITU Bookstore. You’ll note on this page there is a button that says: I wish to REGISTER in order to download up to three (3) Recommendations free of charge. Yes, I certainly do. I selected the button and went to the registration page. The registration, shown below, has a bit of a problem being rather corporate-oriented, so I tried to steer it into the notion that I am an a company of one:

Figure 1 – The registration form

All went well and the ITU blessed me immediately. My email was almost instantaneous, and I was ready to shop.

Figure 2 – The ITU loves me

Just to test the system, I first downloaded a spec I knew I would find handy, JPEG 2000 image coding system: Core coding system. Sure enough, a few minutes later I had my personal copy in hand. Now I just have to decide where to spend my precious remaining two downloads:

• JPEG – Digital compression and coding of continuous-tone still images
• JPEG 2000 image coding system: Reference software
• ITU-T T.81 (JPEG-1)-based still-image coding using an alternative arithmetic coder
• List of definitions for interchange circuits between data terminal equipment (DTE) and data circuit-terminating equipment (DCE) (aka RS-232)
• H.323 – Packet-based multimedia communications systems
• G.722 : 7 kHz audio-coding within 64 kbit/s
• Coding of speech at 8 kbit/s using conjugate-structure algebraic-code-excited linear prediction (CS-ACELP)
• Software tools for speech and audio coding standardization

It’s nice to at least have a choice, isn’t it? Now if we could get the ISO and ANSI to adopt similarly enlightened policies the world would be a much better place.