template <typename T>
struct CallTraits
{
    template <typename U, bool Big> struct CallTraitsImpl;
 
    template <typename U>
    struct CallTraitsImpl<U, true>
    {
        typedef const U& Type;
    };
 
    template <typename U>
    struct CallTraitsImpl<U, false>
    {
        typedef U Type;
    };
 
    typedef typename CallTraitsImpl<T, (sizeof(T) > 8)>::Type ParamType;
};

          template <typename InputIterator, typename OutputIterator, typename Pred>
          OutputIterator copy_if(InputIterator begin, InputIterator end,
                OutputIterator destBegin, Pred p) 
          {
            while (begin != end) {
                if (p(*begin)) *destBegin++ = *begin;
                ++begin;
            }
          }
      

    template <typename InputIter, typename OutputIter, typename UnaryOperation, typename Pred>
    OutputIter transform_if(InputIter first, InputIter last,
            OutputIter result, UnaryOperation op, Pred p) 
    {

#ifdef __GNUC__
        __glibcpp_function_requires(_InputIteratorConcept<InputIter>)
        __glibcpp_function_requires(_OutputIteratorConcept<OutputIter,
                // "the type returned by a UnaryOperation"
                __typeof__(__unary_op(*first))>)
#endif
        for ( ; first != last; ++first) {
          if (p(*first)) *result++ = op(*first);
        }
    }
      

       struct DeleteObject {
    template <typename T>
    void operator()(const T* ptr) const {
        delete ptr;
    }
      

  template <class CONTENEUR> void serialiser(const CONTENEUR& v,char c,std::string& s)
{
    s.clear();
    std::ostringstream flx;
    
    for (typename CONTENEUR::const_iterator p=v.begin(); p!=v.end();++p)
    {
        flx<<*p; 
        if(p!=v.end())
        flx<<c;
    }

    s=flx.str();
    
    if(v.size() > 0) // pour gérer les cas où v est vide
        s.erase(s.size()-1);
}