RESTITUZIONE DI PUNTATORE A STRUCT

di il
35 risposte

35 Risposte - Pagina 3

  • Re: RESTITUZIONE DI PUNTATORE A STRUCT

    Weierstrass ha scritto:


    Zack909 ha scritto:


    Weierstrass ha scritto:



    E grazie, volete la recursione e contemporaneamente il puntatore come return type...

    Consegnate in bianco allora
    Ah guarda stiamo diventando scemi, ma non si può fare senza puntatore?
    Si può fare questo che funziona una volta sola, ma per me è cattiva programmazione
    
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static unsigned int step = 0;
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j])
                {
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
        
        if(ret == NULL)
        {   
            ret = (insieme *)malloc(sizeof(insieme));
                
            ret->l = step;
            if(step){
                ret->a = (double *)malloc(step*sizeof(double));  
                while(step--)
                    ret->a[step] = i1.a[step];       
            }
            else
                ret->a = NULL;
    
            return ret;    
    
        }
    }
    
    Ottimo!! Funziona!! Ma in che senso una volta sola?
  • Re: RESTITUZIONE DI PUNTATORE A STRUCT

    Zack909 ha scritto:


    Weierstrass ha scritto:


    Zack909 ha scritto:




    Ah guarda stiamo diventando scemi, ma non si può fare senza puntatore?
    Si può fare questo che funziona una volta sola, ma per me è cattiva programmazione
    
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static unsigned int step = 0;
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j])
                {
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
        
        if(ret == NULL)
        {   
            ret = (insieme *)malloc(sizeof(insieme));
                
            ret->l = step;
            if(step){
                ret->a = (double *)malloc(step*sizeof(double));  
                while(step--)
                    ret->a[step] = i1.a[step];       
            }
            else
                ret->a = NULL;
    
            return ret;    
    
        }
    }
    
    Ottimo!! Funziona!! Ma in che senso una volta sola?
    Che le variabili static hanno un valore sbagliato la seconda volta che tenti di fare l'intersezione di due insiemi, quindi la funzione si può usare una volta sola.

    Secondo me "return intersezione" è una chiamata ricorsiva e automaticamente deve esserci un punto di uscita dalla ricorsione, quindi il return vero. Probabilmente il professore intendeva di non mettere altri return value a caso oltre al minimo necessario. Si possono fare barbatrucchi come quello mostrato sopra, ma perché? Se scrivete una funzione così al lavoro vi licenziano
  • Re: RESTITUZIONE DI PUNTATORE A STRUCT

    Weierstrass ha scritto:


    Zack909 ha scritto:


    Weierstrass ha scritto:




    Si può fare questo che funziona una volta sola, ma per me è cattiva programmazione
    
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static unsigned int step = 0;
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j])
                {
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
        
        if(ret == NULL)
        {   
            ret = (insieme *)malloc(sizeof(insieme));
                
            ret->l = step;
            if(step){
                ret->a = (double *)malloc(step*sizeof(double));  
                while(step--)
                    ret->a[step] = i1.a[step];       
            }
            else
                ret->a = NULL;
    
            return ret;    
    
        }
    }
    
    Ottimo!! Funziona!! Ma in che senso una volta sola?
    Che le variabili static hanno un valore sbagliato la seconda volta che tenti di fare l'intersezione di due insiemi, quindi la funzione si può usare una volta sola.

    Secondo me "return intersezione" è una chiamata ricorsiva e automaticamente deve esserci un punto di uscita dalla ricorsione, quindi il return vero. Probabilmente il professore intendeva di non mettere altri return value a caso oltre al minimo necessario. Si possono fare barbatrucchi come quello mostrato sopra, ma perché? Se scrivete una funzione così al lavoro vi licenziano
    Guarda, sono pienamente d'accordo ma non ci possiamo fare niente purtroppo...
    Questo è un estratto delle limitazioni:
    
    Coerente coi principi della programmazione strutturata:
    * Privo di istruzioni goto.
    * Privo di istruzioni exit.
    * Privo di istruzioni continue.
    * Privo di istruzioni break che non si trovano alla fine di un case di uno switch.
    * Privo di molteplici istruzioni return nel corpo della stessa funzione.
    
    Spero intenda di non metterne troppi, ma conoscendolo ne dubito...



    Poi scusa l'ignoranza ma while(step--) sarebbe che esegue le istruzioni finché step non arriva a 0?
  • Re: RESTITUZIONE DI PUNTATORE A STRUCT

    Zack909 ha scritto:


    Weierstrass ha scritto:


    Zack909 ha scritto:




    Ottimo!! Funziona!! Ma in che senso una volta sola?
    Che le variabili static hanno un valore sbagliato la seconda volta che tenti di fare l'intersezione di due insiemi, quindi la funzione si può usare una volta sola.

    Secondo me "return intersezione" è una chiamata ricorsiva e automaticamente deve esserci un punto di uscita dalla ricorsione, quindi il return vero. Probabilmente il professore intendeva di non mettere altri return value a caso oltre al minimo necessario. Si possono fare barbatrucchi come quello mostrato sopra, ma perché? Se scrivete una funzione così al lavoro vi licenziano
    Guarda, sono pienamente d'accordo ma non ci possiamo fare niente purtroppo...
    Questo è un estratto delle limitazioni:
    
    Coerente coi principi della programmazione strutturata:
    * Privo di istruzioni goto.
    * Privo di istruzioni exit.
    * Privo di istruzioni continue.
    * Privo di istruzioni break che non si trovano alla fine di un case di uno switch.
    * Privo di molteplici istruzioni return nel corpo della stessa funzione.
    
    Spero intenda di non metterne troppi, ma conoscendolo ne dubito...
    Ho capito, vabbé. Allora scrivete così che è sicuro, anche se mi sembra una contorsione mentale per evitare cose che non si dovrebbero evitare
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
    
        if(ret == NULL){   
            ret = (insieme *)malloc(sizeof(insieme));
            if(ret != NULL){
                k = ret->l = step;
                if(k > 0){
                    ret->a = (double *)malloc(step*sizeof(double));  
                    if(ret->a != NULL){
                    	while(k--)
                        		ret->a[k] = i1.a[k];       
                    }
                    else 
                    	ret = NULL;
                }
            }
        }    
        
        step--;
        return ret;   
    }
    Poi scusa l'ignoranza ma while(step--) sarebbe che esegue le istruzioni finché step non arriva a 0?
  • Re: RESTITUZIONE DI PUNTATORE A STRUCT

    Weierstrass ha scritto:


    Zack909 ha scritto:


    Weierstrass ha scritto:




    Che le variabili static hanno un valore sbagliato la seconda volta che tenti di fare l'intersezione di due insiemi, quindi la funzione si può usare una volta sola.

    Secondo me "return intersezione" è una chiamata ricorsiva e automaticamente deve esserci un punto di uscita dalla ricorsione, quindi il return vero. Probabilmente il professore intendeva di non mettere altri return value a caso oltre al minimo necessario. Si possono fare barbatrucchi come quello mostrato sopra, ma perché? Se scrivete una funzione così al lavoro vi licenziano
    Guarda, sono pienamente d'accordo ma non ci possiamo fare niente purtroppo...
    Questo è un estratto delle limitazioni:
    
    Coerente coi principi della programmazione strutturata:
    * Privo di istruzioni goto.
    * Privo di istruzioni exit.
    * Privo di istruzioni continue.
    * Privo di istruzioni break che non si trovano alla fine di un case di uno switch.
    * Privo di molteplici istruzioni return nel corpo della stessa funzione.
    
    Spero intenda di non metterne troppi, ma conoscendolo ne dubito...
    Ho capito, vabbé. Allora scrivete così che è sicuro, anche se mi sembra una contorsione mentale per evitare cose che non si dovrebbero evitare
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
    
        if(ret == NULL){   
            ret = (insieme *)malloc(sizeof(insieme));
            if(ret != NULL){
                k = ret->l = step;
                if(k > 0){
                    ret->a = (double *)malloc(step*sizeof(double));  
                    if(ret->a != NULL){
                    	while(k--)
                        		ret->a[k] = i1.a[k];       
                    }
                    else 
                    	ret = NULL;
                }
            }
        }    
        
        step--;
        return ret;   
    }
    Poi scusa l'ignoranza ma while(step--) sarebbe che esegue le istruzioni finché step non arriva a 0?
    Grazie mille veramente!!
    Progetto consegnato, e nella correzione ci ha tolto 4 punti per(testuali parole):

    Le funzioni non sono propriamente ricorsive ma presentano una commistione di ricorsione e iterazione dove quest'ultima andrebbe evitata.

    Noi sinceramente non abbiamo capito cosa voglia dire, secondo voi?
  • Re: RESTITUZIONE DI PUNTATORE A STRUCT

    Zack909 ha scritto:


    Weierstrass ha scritto:


    Zack909 ha scritto:




    Guarda, sono pienamente d'accordo ma non ci possiamo fare niente purtroppo...
    Questo è un estratto delle limitazioni:
    
    Coerente coi principi della programmazione strutturata:
    * Privo di istruzioni goto.
    * Privo di istruzioni exit.
    * Privo di istruzioni continue.
    * Privo di istruzioni break che non si trovano alla fine di un case di uno switch.
    * Privo di molteplici istruzioni return nel corpo della stessa funzione.
    
    Spero intenda di non metterne troppi, ma conoscendolo ne dubito...
    Ho capito, vabbé. Allora scrivete così che è sicuro, anche se mi sembra una contorsione mentale per evitare cose che non si dovrebbero evitare
    insieme * intersezione(insieme i1, insieme i2)
    {
        int k, j;
        double temp;
        static insieme * ret = NULL;
        static int step = 0;
        
        if(step < 0){
          ret = NULL;
          step = 0;              
        }
    
        for(k = step; k < i1.l; k++)
            for(j = step; j < i2.l; j++)
                if(ret == NULL && i1.a[k] == i2.a[j]){
                    temp = i1.a[step];
                    i1.a[step] = i1.a[k];
                    i1.a[k] = temp;
                    temp = i2.a[step];
                    i2.a[step] = i2.a[j];
                    i2.a[j] = temp;
                    step++;
                    intersezione(i1, i2);
                }
    
        if(ret == NULL){   
            ret = (insieme *)malloc(sizeof(insieme));
            if(ret != NULL){
                k = ret->l = step;
                if(k > 0){
                    ret->a = (double *)malloc(step*sizeof(double));  
                    if(ret->a != NULL){
                    	while(k--)
                        		ret->a[k] = i1.a[k];       
                    }
                    else 
                    	ret = NULL;
                }
            }
        }    
        
        step--;
        return ret;   
    }
    Poi scusa l'ignoranza ma while(step--) sarebbe che esegue le istruzioni finché step non arriva a 0?
    Grazie mille veramente!!
    Progetto consegnato, e nella correzione ci ha tolto 4 punti per(testuali parole):

    Le funzioni non sono propriamente ricorsive ma presentano una commistione di ricorsione e iterazione dove quest'ultima andrebbe evitata.

    Noi sinceramente non abbiamo capito cosa voglia dire, secondo voi?
    Guarda, facendo la summa di quanto detto negli altri thread, mi pare di capire che alla fine il prof volesse la soluzione con le liste, solo che qualcuno (non mi ricordo chi) aveva tirato fuori la questione dei doppioni e allora siamo andati tutti fuori strada.

    In effetti il codice scritto in quel modo andrebbe evitato, al limite andava bene con il return in mezzo ai for ma non lo voleva...
Devi accedere o registrarti per scrivere nel forum
35 risposte