prekid programa sa greskom "signal 11"

Code:

template<class A>
int
DecisionTable<A>::add_route(InternalMessage<A> &rtmsg, 
                BGPRouteTable<A> *caller) {
    //find the alternative routes, and the old winner if there was one.
    list<RouteData<A>* > old_winner;  //promenjeno u listu pokazivaca na dati tip. Pre ovoga je bila jedna promenjiva tog tipa
    list<RouteData<A> > alternatives;
    old_winner = find_alternative_routes_new(caller, rtmsg.net(), alternatives); //ova metoda je definisana ispod i vraca listu pokazivaca tipa RouteData 
    RouteData<A> *new_winner = NULL;
    RouteData<A> new_route(rtmsg.route(), rtmsg.attributes(), caller,  //inicijalizacija new_route 
               rtmsg.origin_peer(), rtmsg.genid());
    if (!alternatives.empty()) {       //lista alternatives se formira metodom find_alternative_routes_new (ispod) 
        //add the new route to the pool of possible winners.
    alternatives.push_back(new_route);
    new_winner = find_winner(alternatives); //metoda find_winner vraca pobednika iz liste alternativa 
    } else {  
    //the new route wins by default
    new_winner = &new_route; 
    }
    if (!old_winner.empty()) {                       
       typename list<RouteData<A>* >::iterator it;                                               
       typename list<RouteData<A>* >::iterator j;                                               
       for (it = old_winner.begin(); it != old_winner.end(); it++)     //prolaz kroz listu alternativa                                                               
    if ((*it)->route() == new_winner->route()) {   //program ovde puca (signal 11) iako su oba operanda razlicita od nule (testirano!) 
        //the winner didn't change.
        XLOG_ASSERT(!old_winner.empty());                                                    
            for (j = old_winner.begin(); j != old_winner.end(); j++)                               
          delete *j;                                                                         
        return ADD_UNUSED;
        }        
    }         
//neki irelevantan kod u nastavku

template<class A>
list<RouteData<A>* >                                                            
DecisionTable<A>::find_alternative_routes_new(
    const BGPRouteTable<A> *caller,
    const IPNet<A>& net,
    list <RouteData<A> >& alternatives) const 
{
    list<RouteData<A>* > previous_winner;  //promenjeno u listu pokazivaca na dati tip. Pre ovoga je bila jedna promenjiva tog tipa                                         
    typename map<BGPRouteTable<A>*, PeerTableInfo<A>* >::const_iterator i;
    const SubnetRoute<A>* found_route;
    for (i = _parents.begin();  i != _parents.end();  i++) { 
    //We don't need to lookup the route in the parent that the new
    //route came from - if this route replaced an earlier route
    //from the same parent we'd see it as a replace, not an add
     if (i->first != caller) {
        uint32_t found_genid;
        FPAListRef found_attributes;
        found_route = i->first->lookup_route(net, found_genid,     //metoda definisana ispod 
                         found_attributes); 
        if (found_route != NULL) {
        PeerTableInfo<A> *pti = i->second;
        alternatives.push_back(RouteData<A>(found_route,           //popunjava listu alternativa 
                            found_attributes,
                            pti->route_table(),
                            pti->peer_handler(),
                            found_genid)); 
        if (found_route->is_winner()) {
            previous_winner.push_back(&(alternatives.back()));     //popunjava listu prethodnih pobednika
            }
          }
        }
    }
    return previous_winner;              //..i vraca listu prethodnih pobednika
} 
template<class A>
const SubnetRoute<A>*
DecisionTable<A>::lookup_route(const IPNet<A> &net,
                   uint32_t& genid,
                   FPAListRef& pa_list) const
{
    list <RouteData<A> > alternatives;
    RouteData<A>* winner = find_alternative_routes(NULL, net, alternatives);
    if (winner == NULL) {
    return NULL;
     }
    else { 
    genid = winner->genid();
    pa_list = winner->attributes();
    return winner->route(); 
    }
    XLOG_UNREACHABLE(); 
    return NULL;
}

Code:

list<type *> prvalista
list<type *> drugalista = new list<type>(*prvalista) //ovde kompajler javlja gresku
list<type *> drugalista = new list<type *>(prvalista) //i ovako javlja gresku
//probao sam i list<type *> drugalista (prvalista) medjutim i ovo pravi problem

// ...
delete drugalista   //javlja "expected pointer" a kad stavim delete *drugalista kaze nesto "no match for operator*" 

Code:

    list<RouteData<A>* > old_winner;  
    list<RouteData<A>* > old_winner_clone;    //ovo je nova lista sa kojom zelim da baratam 
    list<RouteData<A> > alternatives; 
    old_winner = find_alternative_routes_new(caller, rtmsg.net(), alternatives);  //dodeljujem list alternativnih ruta old_winner-u 
    debug_msg("there are %d alternatives\n", (int)alternatives.size());
     if (!old_winner.empty()) {   //proveravam listu
         old_winner_clone (old_winner);   // i ovde pokusavam da kopiram listu old_winner u old_winner_clone. 
    } 
    RouteData<A> *new_winner = NULL;
    RouteData<A> new_route(rtmsg.route(), rtmsg.attributes(), caller, 
               rtmsg.origin_peer(), rtmsg.genid());
    if (!alternatives.empty()) {
        //add the new route to the pool of possible winners.
    alternatives.push_back(new_route);
    new_winner = find_winner(alternatives);
    } else {  
    //the new route wins by default
    new_winner = &new_route;     //dobio new_winner 
    }
    if (!old_winner_clone.empty()) {                     //proveravam da li mi je klonirana lista prazna 
       typename list<RouteData<A>* >::iterator it;                                              
    // typename list<RouteData<A>* >::iterator j;               //ovo sam izbacio posto hocu da obrisem celu listu a ne elemente liste                          
       for (it = old_winner_clone.begin(); it != old_winner_clone.end(); it++)           //petlja                                                          
    if ((*it)->route() == new_winner->route()) {                                                // ovde je program "pucao"  ranije
        //the winner didn't change.
           // for (j = old_winner.begin(); j != old_winner.end(); j++)                         //ne elemente ....  
       delete old_winner_clone;                                                                   //vec brisi celu listu. Mada, nisam siguran da je ovo korektno posto je nisam prethodno kreirao sa new!
                                                                               

Code:

    RouteData<A> *new_winner = NULL;
...................
    new_winner = &new_route;     //dobio new_winner 

Code:

    if (!old_winner.empty()) {
       typename list<RouteData<A>* >::iterator it;
       typename list<RouteData<A>* >::iterator j;
       for (it = old_winner.begin(); it != old_winner.end(); it++)     //prolaz kroz listu alternativa
    if ((*it)->route() == new_winner->route()) {   
        //the winner didn't change.
        XLOG_ASSERT(!old_winner.empty());
            for (j = old_winner.begin(); j != old_winner.end(); j++)
          delete *j;
        return ADD_UNUSED;
        }
    }

Code:

   typedef std::list<RouteData<A>* > listType;
   typedef listType::iterator iterlistType;
   listType old_winner;
   for (iterlistType it = old_winner.begin(); it != old_winner.end(); ++it) {
        for (iterlistType j = old_winner.begin(),jend=old_winner.end(); j != jend; ++j) {
            delete *j;
        }
   }

Code:

using namespace std;

Code:

template<class A>
class RouteData {
public:
    RouteData(const SubnetRoute<A>* route, 
          FPAListRef pa_list,
          BGPRouteTable<A>* parent_table,
          const PeerHandler* peer_handler,
          uint32_t genid) 
    : _route(route), _pa_list(pa_list), _parent_table(parent_table), 
      _peer_handler(peer_handler), _genid(genid) {}

    /* main reason for defining operator= is to keep the refcount
       correct on _pa_list */
    RouteData<A>& operator=(const RouteData<A>& him) {
    _route = him._route;
    _pa_list = him._pa_list;
    _parent_table = him._parent_table;
    _peer_handler = him.peer_handler;
    _genid = him._genid;
    }

    void set_is_not_winner() {
    _parent_table->route_used(_route, false);
    _route->set_is_not_winner();
    }
    void set_is_winner(int igp_distance) {
    _parent_table->route_used(_route, true);
    _route->set_is_winner(igp_distance);
    }
    const SubnetRoute<A>* route() const { return _route; }
    const FPAListRef& attributes() const { return _pa_list; }
    const PeerHandler* peer_handler() const { return _peer_handler; }
    BGPRouteTable<A>* parent_table() const { return _parent_table; }
    uint32_t genid() const { return _genid; }
private:
    const SubnetRoute<A>* _route;
    FPAListRef _pa_list;
    BGPRouteTable<A>* _parent_table;
    const PeerHandler* _peer_handler;
    uint32_t _genid;
};

Code:
  if ((*it)->route() == new_winner->route()) { 
         // itd