struct versatile_deleter
{
  template<class T> void operator()(T* p) const { delete p; }
};
.....
for_each(v.begin(),v.end(),versatile_deleter());

    Foo *t, *u;
    u = new Foo();

    t = u;  // OK

    delete u;

    t = u;  // Undefined behavior

#include <cstddef>

void* buffer;

struct POD
{
    void* operator new(std::size_t)
    {
        return buffer;
    }
    void operator delete(void*) {}
};

int main()
{
    buffer = operator new(sizeof(POD));

    POD* ptr = new POD;
    operator delete(ptr);

    operator delete(buffer);
}

    std::list< Foo* >        lst;

    lst.push_back( new Foo );

    std::for_each(
            lst.begin(),
            lst.end(),
            static_cast< void(__cdecl*)(void*) >( ::operator delete )
        );

S>    std::list< Foo* >        lst;

S>    lst.push_back( new Foo );

S>    std::for_each(
S>            lst.begin(),
S>            lst.end(),
S>            static_cast< void(__cdecl*)(void*) >( ::operator delete )
S>        );

S>>>    std::list< Foo* >        lst;

S>>>    lst.push_back( new Foo );

S>>>    std::for_each(
S>>>            lst.begin(),
S>>>            lst.end(),
S>>>            static_cast< void(__cdecl*)(void*) >( ::operator delete )
S>>>        );

//....
    std::for_each(
            lst.begin(),
            lst.end(),
            static_cast< void(__cdecl*)(void*) >( ::operator delete )
        );

// Assignable ?

    *lst.begin() = 0;
    assert( !*lst.begin() );

lst.clear();

E>>    Foo *t, *u;
E>>    u = new Foo();

E>>    t = u;  // OK

E>>    delete u;

E>>    t = u;  // Undefined behavior

К>struct versatile_deleter
К>{
К>  template<class T> void operator()(T* p) const { delete p; }
К>};
К>.....
К>for_each(v.begin(),v.end(),versatile_deleter());
К>

namespace
{ 
template< typename T>
void destroy_all_x168( T *p )
{
    delete p;
}
};

template <class T>
struct SafePOD
 {
  T object;
  
  SafePOD() {}
  
  SafePOD(const SafePOD<T> &x) 
   { 
    memcpy(&object,&x.object,sizeof (T)); 
   }
  
  SafePOD<T> & operator = (const SafePOD<T> &x)
   {
    //if( this==&x ) return *this; // hack
    
    memcpy(&object,&x.object,sizeof (T)); 
    
    return *this;
   }
 };

Ш>    //if( this==&x ) return *this; // hack
    
Ш>    memcpy(&object,&x.object,sizeof (T));

312. "use" of invalid pointer value not defined
Section: 3.7.3.2 basic.stc.dynamic.deallocation Status: open Submitter: Martin von Loewis Date: 20 Sep 2001

3.7.3.2 basic.stc.dynamic.deallocation paragraph 4 mentions that the effect of using an invalid pointer value is undefined. However, the standard never says what it means to 'use' a value.

There are a number of possible interpretations, but it appears that each of them leads to undesired conclusions:

A value is 'used' in a program if a variable holding this value appears in an expression that is evaluated. This interpretation would render the sequence

 
   int *x = new int(0);
   delete x;
   x = 0;

into undefined behaviour. As this is a common idiom, this is clearly undesirable.
A value is 'used' if an expression evaluates to that value. This would render the sequence

   
   int *x = new int(0);
   delete x;
   x->~int();

into undefined behaviour; according to 5.2.4 expr.pseudo, the variable x is 'evaluated' as part of evaluating the pseudo destructor call. This, in turn, would mean that all containers (23 lib.containers) of pointers show undefined behaviour, e.g. 23.2.2.3 lib.list.modifiers requires to invoke the destructor as part of the clear() method of the container.
If any other meaning was intended for 'using an expression', that meaning should be stated explicitly.

int * p = new int();
delete p;
p; //UB

vector<int> v;
bool found = find(v.begin(), v.end(), SomeFunctor(args)) != v.end(); //well-formed?

PC>int * p = new int();
PC>delete p;
PC>p; //UB

PC>vector<int> v;
PC>bool found = find(v.begin(), v.end(), SomeFunctor(args)) != v.end(); //well-formed?

PC>Там же тоже никакого объекта не находится? Но UB почему-то нет...