boost::pool_allocator: can't find my errors

[varnie]

hell-o !~

i faced weird problem during usage boost::pool_allocator.
after i've changed:

typedef boost::shared_ptr< param > ParamPtr;
typedef std::vector< ParamPtr > ParamPtrVector;
 

with:

typedef boost::shared_ptr< param > ParamPtr;
typedef std::vector< ParamPtr, boost::pool_allocator<ParamPtr> > ParamPtrVector;
 

smth goes wrong:

Segmentation fault: 11 (core dumped)

before that i didn't get any sever errors...

i've found out where it breaks in my code:

class UsersFunction : public Function {
    boost::shared_ptr< Statement > _pStmtPtr; //body of function   
public:
    UsersFunction(const Function::FunctionHeader &header, const boost::shared_ptr< Statement > &pStmtPtr = boost::shared_ptr<Statement>())
            : Function(header),
            _pStmtPtr(pStmtPtr) {} HERE !!!
    //...
};
 
//parent class
class Function {
    Value _result;
public:
    struct FunctionHeader {
        std::string _name;
        Value::E_TYPE _returnType;
        std::size_t _argsCount;
        ParamPtrVector _params;
        FunctionHeader(const std::string &name, const Value::E_TYPE returnType, const std::size_t argsCount, const ParamPtrVector &params)
                :_name(name), _returnType(returnType), _argsCount(argsCount), _params(params) {}
 
        //...
    };
protected:
    FunctionHeader _header;
protected:
    Function(const FunctionHeader &header)
            :_header(header),
            _result(header.getType()) {}
    ~Function() {}
    Function &operator=(const Function &other) {
        if (this != &other) {
            _header = other._header;
        }
        return *this;
    }
public:
 
    //...
};
 

smth goes wrong in boost simple_segregated_storage.hpp function:

//boost/simple_segregated_storage.hpp file
template <typename SizeType>
void * simple_segregated_storage<SizeType>::segregate(
    void * const block,
    const size_type sz,
    const size_type partition_sz,
    void * const end)
{
  // Get pointer to last valid chunk, preventing overflow on size calculations
  //  The division followed by the multiplication just makes sure that
  //    old == block + partition_sz * i, for some integer i, even if the
  //    block size (sz) is not a multiple of the partition size.
  char * old = static_cast<char *>(block)
      + ((sz - partition_sz) / partition_sz) * partition_sz;
 
  // Set it to point to the end
  nextof(old) = end;
 
  // Handle border case where sz == partition_sz (i.e., we're handling an array
  //  of 1 element)
  if (old == block)
    return block;
 
  // Iterate backwards, building a singly-linked list of pointers
  for (char * iter = old - partition_sz; iter != block;
      old = iter, iter -= partition_sz)
    nextof(iter) = old;   HERE !!!
 
  // Point the first pointer, too
  nextof(block) = old;
 
  return block;
}
 

here is my stack on this moment:

iter = 0x282ffff8 <error reading address 0x282ffff8: Bad address>
0x0805b0f8 boost::simple_segregated_storage<unsigned int>::segregate
0x0805b158 boost::simple_segregated_storage<unsigned int>::add_block
0x0805b352 boost::simple_segregated_storage<unsigned int>::add_ordered_block
0x0805b3cc boost::simple_segregated_storage<unsigned int>::ordered_free_n
0x0805b443 boost::pool<boost::default_user_allocator_new_dele te>::ordered_free
0x0807c04c boost::singleton_pool<boost::pool_allocator_tag,8, boost::default_user_allocator_new_delete,boost::de tail::pool::pthred_mutex,32>::ordered_free
0x0807c078 boost::pool_allocator<boost::shared_ptr<param>,boo st::default_user_allocator_new_delete,boost::detai ls::pool:pthread_mutex,32::deallocate
0x0807c09e std::_Vector_base<boost::shared_ptr<param>,boost:: pool_allocator<boost::shared_ptr<param>,boost::def ault_user_allocator_new_delete,boost::details::poo l::pthread_mutex,32> >::_M_deallocate
0x0807c3a6 ~_Vector_base
0x0807c562 ~vector
0x0807c5a5 ~FunctionHeader
0x0806f170 Syntaxer::FunctionsDeclarations
0x0806fe17 Syntaxer::run
0x0804a796 main

what is wrong with my code and where's my fault? thanks.