GCC 3.3 ?
- friend declrations require class keyword :
     friend Toto;
  has to be
     friend class Toto;
- inline functions have to be implemented. This means you cannot
  include a .h file containing declarations of inline functions
  without including also their definition
- the abs function for doubles is fabs
- take care of the order of calls to constructors in copy constructors.
  Especially, pure abtract interfaces must be called first. If not, you
  get an error of this kind :
    base class `class IValidity' should be explicitly initialized
       in the copy constructor


-----------------------------------------------------------
GCC 3.2


- the package strstream is now deprecated but there is no need to change right
  now to sstream. A warning message will however be displayed by the compiler
  and it could be removed using the -Wno-deprecated option.
- enumerations and long or integers can no longer be mixed (stronger type
  checking). This applies notably to the std::_Ios_Iostate and
  std::_Ios_Fmtflags type which were up to now replaced by longs.
- std::smanip is no more known to the compiler. It was replaced by a whole set
  of new types, namely _Setfill<_CharT>, _Setiosflags, _Resetiosflags, _Setbase,
  _Setprecision and _Setw.
- when a class B inherits from a class A and that a given virtual of A has a
  throw spec (even if empty) and is reimplemented in B, the new implementation
  must have a throw spec too.
- enums have a type. You cannot define two enums, declare that you return a
  value of the first one and actually return one of the second enum. This goes
  along with the fact that you cannot return an int for an enum.
- cerr and cout are defined in <iostream>. You must include this file in order
  to use them
- you should use std::endl instead of endl
- you should not use implicit typenames
  The use of typename is needed to remove ambiguities inherent to the C++
  language. As an ecample, the following declaration is ambiguous :
     int y;
     template <class T> void g(T& v) { T::x(y); }
  "T::x(y)" could be understand as a function call (function x declared in T
  taking an int as argument) or as a variable declaration (variable named y of
  type T::x, with perverse redundant parenthesis around the name of the
  variable). In this case, the correct syntax is :
     template <class T> void g(T& v) { typename T::x(y); }
  The point is that a typename keyword is required whenever a type depends upon
  a template parameter. For example :
     typedef std::vector<TYPE*> Data;
     typedef Data::iterator       iterator;
  is not valid C++. In this case, compiler might be able to determine that
  iterator was the name of a type in every instantiation of vector but the
  compiler is not required to do so. It would be non standard C++.
  gcc is able to deal with this cases but the new version 3.2 tends to be very
  close to the specification and thus delivers a warning whenever the typename
  is needed. Thus you should write :
     typedef std::vector<TYPE*> Data;
     typedef typename Data::iterator       iterator;
- when one defines a vector type, like std::vector<A>, the 2 types A* and
  std::vector<A>::iterator are distincts and cannot be mixed.

- 1 change include <strstream> into include <sstream>
  2 change (o/i)strstream into (o/i)stringstream
  3 remove freeze() calls
  take care to include these changes inside an #ifdef statement to insure
  backward compatibility :
        #if defined (__GNUC__) && ( __GNUC__ >= 3 )
            std::ostringstream s;
        #else
            std::ostrstream s;
        #endif
- remove ".h" from include statements concerning standard headers (there are
  32 of them listed in the C++ standard in section 17.4.1.2 This is compatible
  with gcc 2.95.2, so no need to place a #ifdef
- when defining a macro with parameters, the use of ## is more strict : you
  can no more put it when not necessary. As an example :
    #define IMPLEMENT_SOLID(x) \
      static const SolidFactory<##x##> s_##x##Factory ; \
      const ISolidFactory&##x##Factory = s_##x##Factory ;
  has to be :
    #define IMPLEMENT_SOLID(x) \
      static const SolidFactory<x> s_##x##Factory ; \
      const ISolidFactory& x##Factory = s_##x##Factory ;
- the include file hash_map of gcc 2.95.2 has become ext/hashmap
  On top of that, the type is no more std::hash_map but
  __gcc_cxx::hash_map. One way of dealing with that is to use
  hash_map (without a namespace) and do this for inclusion :
  #ifdef _WIN32
  #include "stl_hash.h"
  using std::hash_map;
  #else
  #if defined (__GNUC__) && ( __GNUC__ <= 2 )
  #include <hash_map>
  using std::hash_map;
  #else
  #include <ext/hash_map>
  using __gnu_cxx::hash_map;
  #endif
  #endif