C++ Code Audit Diary 1: STL implementation difference

STL supports value semantics. There is no support for the reference semantics in C++ STL. Even then few STL function template supports pass-by-reference. There is a difference between this supports in MSVC and GCC.

I take an example from the “C++ Standard Library: A Tutorial and Reference”.

// fo/genera2.cpp

#include <iostream>
#include <list>
#include <algorithm>
#include <iterator>

/* PRINT_ELEMENTS()
* – prints optional C-string optcstr followed by
* – all elements of the collection coll
* – separated by spaces
*/
template <class T>
inline void PRINT_ELEMENTS (const T& coll, const char* optcstr=””)
{
    typename T::const_iterator pos;

    std::cout << optcstr;
    for (pos=coll.begin(); pos!=coll.end(); ++pos) {
        std::cout << *pos << ‘ ‘;
    }
    std::cout << std::endl;
}

using namespace std;

class IntSequence {
  private:
    int value;
  public:
    //constructor
    IntSequence (int initialValue)   : value(initialValue) {
    }

     //”function call”
    int operator() () {
        return value++;
    }
};

int main()
{
    list<int> coll;
    IntSequence seq(1);             //integral sequence starting with 1

    //insert values from 1 to 4
    // – pass function object by reference
    //so that it will continue with 5
    generate_n<back_insert_iterator<list<int> >,  int, IntSequence&>(back_inserter(coll), 4, seq); 
    PRINT_ELEMENTS(coll);

    //insert values from 42 to 45
    generate_n (back_inserter(coll),      //start
                4,                        //number of elements
               IntSequence (42))   ;      //generates values
    PRINT_ELEMENTS(coll);

    //continue with first sequence
    // – pass function object by value
    //so that it will continue with 5 again
    generate_n (back_inserter(coll),      //start
                4,                        //number of elements
               seq) ;                     //generates values
    PRINT_ELEMENTS(coll);

    //continue with first sequence again
    generate_n (back_inserter(coll),          //start
                4,                            //number of elements
                seq);                         //generates values
    PRINT_ELEMENTS(coll);
}

If you build it using MSVC, you will get this output:
D:\C++\Programs>functionobjectreferencemsvc.exe
1 2 3 4
1 2 3 4 42 43 44 45
1 2 3 4 42 43 44 45
1 2 3 4
1 2 3 4 42 43 44 45 1 2 3 4 1 2 3 4

If you build it using g++, you will get this output:
$ g++ functionobjectreference.cc -o functionobjectreferencegcc.exe
$ functionobjectreferencegcc.exe
1 2 3 4
1 2 3 4 42 43 44 45
1 2 3 4 42 43 44 45
5 6 7 8
1 2 3 4 42 43 44 45 5 6 7 8 5 6 7 8

Time to learn the similar differences between STL implementations.

There is a similar discussion under this link. http://www.wilmott.com/messageview.cfm?catid=10&threadid=71397

Advertisements
This entry was posted in C/C++, Code review experiance, SDLC, Windows VC++ and tagged , . Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s