[c++] problemi con puntatori e liste

[atomico]

ciao a tutti.
devo fare una funzione che date 2 liste contenenti dei polinomi mi crei una terza lista con la somma dei polinomi.

io l'ho pensata così...

nodo * crea(){
    nodo *head=new nodo;
    head->link=NULL;
    return head;
}
void polinomiosomma(nodo * head1, nodo * head2, nodo * head3){
    if ((head1==NULL) && (head2==NULL)){
        return;
    }
    else
    {
        head3->link=crea();
        if ((head1->esp>head2->esp) || (head2==NULL))
        {
            head3->esp=head1->esp;
            head3->coef=head1->coef;
            return polinomiosomma(head1->link,head2,head3->link);
        }
        if ((head1->esp<head2->esp) || (head1==NULL))
        {
            head3->esp=head2->esp;
            head3->coef=head2->coef;
            return polinomiosomma(head1,head2->link,head3->link);
        }
        if (head1->esp==head2->esp){
            head3->esp=head1->esp;
            head3->coef=(head1->coef+head2->coef);
            return polinomiosomma(head1->link,head2->link,head3->link);
        }
    }
} 

la logica funziona.. il problema che trovo però è che facendo così lui mi crea un nodo successivo di head3 anche se poi magari non ci vado a scrivere. come posso fixarlo secondo voi?

sperando di essermi spiegato bene

grazie

[YuYevon]

Potresti provare a modificare il caso base così:

    if ((head1==NULL) && (head2==NULL)){
        delete head3;
        head3 = NULL;
        return;
    }

cioè in pratica deallochi ciò che allochi prima della chiamata ricorsiva e di cui poi non ti servi. Questo ovviamente sempre se ho capito bene come opera la funzione... quindi tu che ne conosci sicuramente meglio la logica controlla se può andare bene (ma mi sembra di sì comunque...)

In ogni caso, visto che la tua è una void function, ti consiglio di evitare scritture tipo

return polinomiosomma(head1->link,head2,head3->link);

perché equivale a dire: "restituisci alla funzione chiamante il valore restituito da polinomiosomma chiamato con questi argomenti"... ma polinomiosomma, essendo dichiarato come void function (cioè come procedura) non restituirà mai nulla...
Ti basta semplicemente scrivere

polinomiosomma(head1->link,head2,head3->link);

in maniera tale da attivare ricorsivamente la funzione ma senza restituzioni di valori (che non esistono!)

[atomico]

per il return non lo sapevo... o meglio non ci avevo mai pensato visto che non mi dava errori, quindi grazie

per la tua idea ci avevo pensato ma non funziona come dovrebbe, quando poi vado a stampare il link del nodo non punta + a NULL e quindi va in loop..

quindi riassumendo.. se non metto quello che hai scritto, quando stampo la nuova lista mi esce sempre di n nodi + 1 un nodo aggiuntivo.

se invece faccio come hai detto, (non trova + null) e quindi va in loop..

[YuYevon]

Originariamente inviato da atomico
per il return non lo sapevo... o meglio non ci avevo mai pensato visto che non mi dava errori, quindi grazie

Occhio comunque che ti dicevo che è "meglio evitare", non che è sbagliato... cioè in pratica scrivere return con una funzione che non restituisce nulla equivale proprio a scrivere "return;" come ad esempio fai nel caso base, solo che nel caso base l'istruzione return; ti serve per restituire il flusso di controllo alla funzione chiamante (e non far eseguire il codice successivo) mentre invece nel caso generale quelle istruzioni return sono inutili perché nel momento in cui c'è una chiamata ricorsiva ad una funzione il flusso di controllo passa a questa automaticamente, quindi l'istruzione return diventa solo un'inutile istruzione in più :]

per la tua idea ci avevo pensato ma non funziona come dovrebbe, quando poi vado a stampare il link del nodo non punta + a NULL e quindi va in loop..

quindi riassumendo.. se non metto quello che hai scritto, quando stampo la nuova lista mi esce sempre di n nodi + 1 un nodo aggiuntivo.

se invece faccio come hai detto, (non trova + null) e quindi va in loop..

Scusa ma cosa "non trova più null" ? La funzione di stampa forse? Non capisco perché francamente... ti riferisci alla procedura di stampa della lista risultante dalla somma delle altre due? Come hai definito questa funzione?

In ogni caso, pur non avendo colto il problema di cui dici ora, forse una soluzione più "pulita" potrebbe essere quella di fare un controllo anticipato nel caso generale della funzione prima di procedere con l'allocazione di un nuovo nodo... in questo modo:

if ( head1 -> link == NULL && head2 -> link == NULL )
   head3->link=crea();

e il resto rimarrebbe invariato (quindi va rimossa anche la modifica che suggerivo prima).

Se nemmeno così va bene, fammi capire meglio il problema qual è

[YuYevon]

No scusa a proposito di quelle return ho detto una "bischerata"

Se non ce le metti, una volta conclusa una chiamata ricorsiva alla funzione verrebbero testate anche le condizioni successive e questo potrebbe darti problemi... si potrebbero evitare solo se si strutturasse quella sequenza di if con dei costrutti if then else if then else... come in genere faccio io in questi casi.

[atomico]

ahhh perfetto.. funziona solo che hai invertito

if (( head1 -> link != NULL) && (head2 -> link != NULL ))              head3->link=crea(); 

se è diverso crea

grazie mille eppure avevo pensato ad una soluzione del genere.. poi non so xchè l'ho scartata..

[YuYevon]

Originariamente inviato da atomico
ahhh perfetto.. funziona solo che hai invertito

Eh già... stasera funziono poco ;D

Comunque a proposito di inversione... direi che a questo punto l'operatore logico && sia da sostituire con ||, perché basta che anche uno solo dei due puntatori sia non nullo per rendere necessaria la creazione di un nuovo nodo. Con && invece diciamo che devono essere entrambi diversi da NULL, il che non è vero...

Stavolta credo di averci azzeccato, altrimenti che io sia bannato a furor di popolo ç_ç

[atomico]

ahah ecco xchè non mi trovavo se una lista era + lunga dell'altra

dai ci hai azzeccato

una domanda

se io faccio un or || del tipo

if ((head1->esp>head2->esp) || (head2==NULL))

se head2 è = a null lui controlla lo stesso e quindi va in errore oppure il secondo or esclude la verifica della prima?

da verifiche sul campo sembra che la seconda esclude la prima, infatti funziona, ma volevo sapere se era una cosa ufficiale o magari era il dev che si prendeva libertà

[YuYevon]

Non ho ben compreso il problema (di nuovo! o_o") ma comunque quando ci sono due condizioni legate in OR la politica è questa:

viene controllata la prima condizione;
se è vera, viene eseguito direttamente il corpo dell'if senza testare la seconda condizione (infatti in questo caso il valore della seconda condizione è irrilevante visto che sia 1 OR 0 che 1 OR 1 valgono 1);
se è falsa, si passa al controllo della seconda;
se questa è vera ( 0 || 1 = 1 ) viene eseguito il corpo dell'if;
se è falsa ( 0 || 0 = 0 ), il corpo dell'if viene saltato.

Sono riuscito a risolvere il dubbio, sebbene involontariamente?

[atomico]

mmm non proprio.. come dici tu nell'esempio di prima..

if ((head1->esp>head2->esp) || (head2==NULL))

se head2==null non dovrebbe esplodere (error) visto che head2->esp non esiste?

invece funziona come se la condizione head2==NULL annullasse la prima