Oppure

Loading
10/02/11 21:00
__BlackworM__
Salve amici,
adesso mi spiego meglio io devo fare la ricerca del massimo con una ricorsione, la ricorsione deve essere applicata ad un array di un tipo da me definito con la struct e cioè :
typedef struct alunno
{
char nome[100];
char cognome[100];
int matricola;
char dataNascita[15];
char luogoNascita[50];
int presenze;
int assenze;
struct indirizzo {
                    char via[100];
                    int cap;
                    int civico;
                 } indirizzo;
} alunno;
//dichiaro un tipo di dato alunno ma sottoforma di array chiamato classe
struct alunno classe[10];


adesso ho creato una funzione ricorsiva e vi posto il codice
int massimo_r(classe vettore[],int n)
{
int max;
if(n==0) { return vettore[0]; }

else
max=massimo_r(vettore[].assenze,n);
if(max>vettore[n].assenze) { return max; }
else { return vettore[n].assenze; }

}


adesso mi da errore codeblock dicendo che si aspetta una parentesi tonda prima di int massimo_r ma credo che non stia bene l'IDE perchè tutto è corretto, mi aiutate a capire dove sbaglio ?
aaa
10/02/11 21:42
Pitagora
Il mio consiglio? Riscrivi la funzione perchè è TOTALMENTE sbagliata dal punto di vista logico. Riparti da qui:

int massimo_r(struct alunno vettore[],int n)


Magari la potresti riscrivere prima senza ricorsione e poi te la modifichi.
Ultima modifica effettuata da Pitagora 10/02/11 21:47
aaa
10/02/11 22:05
TheKaneB
Postato originariamente da __BlackworM__:

Salve amici,
adesso mi spiego meglio io devo fare la ricerca del massimo con una ricorsione, la ricorsione deve essere applicata ad un array di un tipo da me definito con la struct e cioè :
typedef struct alunno
{
char nome[100];
char cognome[100];
int matricola;
char dataNascita[15];
char luogoNascita[50];
int presenze;
int assenze;
struct indirizzo {
                    char via[100];
                    int cap;
                    int civico;
                 } indirizzo;
} alunno;
//dichiaro un tipo di dato alunno ma sottoforma di array chiamato classe
struct alunno classe[10];


adesso ho creato una funzione ricorsiva e vi posto il codice
int massimo_r(classe vettore[],int n)
{
int max;
if(n==0) { return vettore[0]; }

else
max=massimo_r(vettore[].assenze,n);
if(max>vettore[n].assenze) { return max; }
else { return vettore[n].assenze; }

}


adesso mi da errore codeblock dicendo che si aspetta una parentesi tonda prima di int massimo_r ma credo che non stia bene l'IDE perchè tutto è corretto, mi aiutate a capire dove sbaglio ?


intanto mettici una bella "n" dentro quelle parentesi quadre, inoltre la funzione prende un array di struct, non un INT...
max=massimo_r(vettore, n);


se ancora si lamenta, aggiungi una forward declaration prima della funzione, cioè:
int massimo_r(struct alunno* vettore,int n); // dichiaro ma non definisco... definisco sotto


Comunque mi sa che hai fatto un bel casino, rifalla da capo che fai prima XD
Ultima modifica effettuata da TheKaneB 10/02/11 22:08
aaa
11/02/11 1:38
__BlackworM__
Adesso resterebbe da capire come richiamare la funzione e con quali parametri allora posto codice :
int massimo_r(alunno classe[MAX_STUDENTI].assenze,MAX_STUDENTI);

in pratica ho una struct di tipo array con MAX_STUDENTI che indica il numero di studenti e la sua dimensione è di MAX_STUDENTI ma mi d- questo errore
main.c|49|error: expected ';', ',' or ')' before '.' token|
la riga in questione è quella che ho postato sopra.

La funzione riscritta è questa
int massimo_r(struct alunno* vettore[],int n)
{
int max;

if(n==0) { return vettore[0]; }

else
max=massimo_r(vettore[n],n);
if(max>vettore[n]) { return max; }
else { return vettore[n]; }

}


P.S. Grazie mille ragazzi in questo periodo sto praticamente inondando il forum di domande, ma sto facendo un progetto per l'università di programmazione e col C non ho molta dimistichezza anche se programmo abbastanza in PHP.
aaa
11/02/11 1:44
__BlackworM__
Mi sà che sto facendo un macello, perchè quasi quasi mi sembra che non sia ricorsiva la funzione ed io DEVO farla ricorsiva, avevo anche creato la funzione non ricorsiva e tutto funzionava ma poi l'ho riscritto in modo ricorsivo ed adesso guardando bene mi sà che non lo sia....8-|
aaa
11/02/11 8:10
Xaratroom
Postato originariamente da __BlackworM__:

Mi sà che sto facendo un macello, perchè quasi quasi mi sembra che non sia ricorsiva la funzione ed io DEVO farla ricorsiva, avevo anche creato la funzione non ricorsiva e tutto funzionava ma poi l'ho riscritto in modo ricorsivo ed adesso guardando bene mi sà che non lo sia....8-|

Spesso rendere ricorsivo qualcosa che funziona alla grande da iterativo diventa un casino (vale anche il viceversa).

Alla tua funzione devi aggiungere il massimo come parametro. La prima volta assumi come massimo il primo elemento.
Io ti consiglierei di partire da qualcosa di più simile a questo (il codice è solo abbozzato e, dal momento che sono sveglio da 10 minuti, potrebbe contenere errori):
int max (int first, int second) {
	if (first > second) 
		return first;
	else
		return second;
}

int massimo_r (struct alunno* vettore, int n) { //inizializza massimo_r(struct, int, int)
	return massimo_r(alunno+1, n-1, vettore->assenze); //la prima volta il massimo è il primo elemento
}

int massimo_r (struct alunno* vettore, int n, int first) {
	if (n == 0)
		return first;
	else
		return massimo_r (vattore+1, n-1, max(vettore->assenze, first));
}
aaa
11/02/11 15:51
__BlackworM__
Ragazzi sono esausto ormai, questa piccolezza mi sta facendo perdere una barca di tempo, adesso posto i codici completissimi che ancora danno errore per favore ditemi dove sbaglio sto impazzendo: (anche se so che non è importante vi dico comunque che uso codeblocks mille casi fosse problema di editor)

MAIN:
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "function_e_struct.h"

// Prototipi delle funzioni precedentemente create
void inserisci_alunni();
void stampa();
void seleziona_alunno();
void presenza(int);
void assenza (int);
int massimo_r(struct alunno* vettore,int);

int main()
{
    SetConsoleTitle("Gestione Alunni 1.0");
    int scelta=0;
    int inizio=0;

    do
    {
        if(inizio==0)
        {
        printf("\n Andiamo a creare un elenco 10 studenti !\n");
        system("PAUSE");
        printf("\n\n");
        inserisci_alunno();
        inizio=1;
        system("cls");
        }
        system("cls");
        printf("\n");
        printf("  ############################\n");
        printf("  # Cosa vuoi fare ?         #\n");
        printf("  # Stampa alunni = 1        #\n");
        printf("  # Appello = 2              #\n");
        printf("  # Cerca alunno = 3         #\n");
        printf("  # Per uscire premi 0       #\n");
        printf("  ############################\n");
        printf("  Scelta : ");
        scanf("%d",&scelta);

        switch(scelta)
        {
        case 1 : stampa(); break;
        case 2 : appello(); break;
        case 3 : seleziona_alunno(); break;
        case 4 : massimo_r(alunno* classe,MAX_STUDENTI); break;
        case 0 : break;
        default: printf("Attenzione scelta errata !");
        }

    } while(scelta != 0);

return 0;
}


file function_e_struct.h
#include <stdio.h>
#include <string.h>

#define MAX_STUDENTI 2

//Questa è la struct "alunno" in cui dichiarerò le variabili che compongono la struct
typedef struct alunno
{
char nome[100];
char cognome[100];
int matricola;
char dataNascita[15];
char luogoNascita[50];
int presenze;
int assenze;
struct indirizzo {
                    char via[100];
                    int cap;
                    int civico;
                 } indirizzo;
} alunno;
//dichiaro un tipo di dato alunno ma sottoforma di array chiamato classe della dimensione di MAX_STUDENTI
struct alunno classe[MAX_STUDENTI];

//La funzione inserisci_alunno() ci sarà utile per inserire inizialmente i dati degli alunni che poi andremo a manipolare.
//L'inserimento verrà fatto per "MAX_STUDENTI" volte
void inserisci_alunno()
{
int i;
for(i=0;i<=MAX_STUDENTI;i++)
    {
     system("cls");
     fflush(stdin);
     printf("\n");
     printf(" Alunno numero %d\n\n",i+1);

     printf(" Nome : ");                                                         gets(classe[i].nome);                          fflush(stdin);
     printf(" Cognome : ");                                                      gets(classe[i].cognome);                       fflush(stdin);
     printf(" Matricola (Inserisci solo numeri) : ");                            scanf("%d",&classe[i].matricola);              fflush(stdin);
     printf(" Data di Nascita : ");                                              gets(classe[i].dataNascita);                   fflush(stdin);
     printf(" Luogo di Nascita : ");                                             gets(classe[i].luogoNascita);                  fflush(stdin);
     printf(" Via/Corso/Piazza (Inserisci solo l'indirizzo senza civico) : ");   gets(classe[i].indirizzo.via);                 fflush(stdin);
     printf(" Numero civico (Inserisci solo numeri) : ");                        scanf("%d",&classe[i].indirizzo.civico);       fflush(stdin);
     printf(" CAP (Inserisci solo numeri) : ");                                  scanf("%d",&classe[i].indirizzo.cap);          fflush(stdin);
    }
}

//La funzione stampa() stamperà a video tutto l'elenco completo degli alunni del corso
void stampa()
{
system("cls");
int i;
printf("  ##########################################################\n");
for(i=0;i<=MAX_STUDENTI;i++)
    {
        printf("  # Alunno numero %d\n",i+1);
        printf("  # Nome : %s\n",classe[i].nome);
        printf("  # Cognome : %s\n",classe[i].cognome);
        printf("  # Matricola : %d\n",classe[i].matricola);
        printf("  # Data di Nascita : %s\n",classe[i].dataNascita);
        printf("  # Luogo di Nascita : %s\n",classe[i].luogoNascita);
        printf("  # Indirizzo : %s,%d - CAP : %d\n",classe[i].indirizzo.via,classe[i].indirizzo.civico,classe[i].indirizzo.cap);
        printf("  # Presenze : %d\n",classe[i].presenze);
        printf("  # Assenze : %d\n",classe[i].assenze);
        printf("  ##########################################################\n");
    }
system("PAUSE");
}


void presenza(int studente) { classe[studente].presenze+=1; }

//La funzione assenze ci permetterà di inserire le assenze degli alunni
void assenza (int studente) { classe[studente].assenze+=1; }

void appello()
{
int count;
int i;

printf(" Se l'alunno è assente=1, se presente=0\n");

for(i=0;i<=MAX_STUDENTI;i++)
    {
        printf(" %s %s : ",classe[i].cognome,classe[i].nome);
        fflush(stdin);
        scanf("%d",&count);

        switch(count)
        {
        case 0: presenza(i); break;
        case 1: assenza(i); break;
        }

    }
}


void seleziona_alunno()
{
system("cls");
int i;
char nome[100];
char cognome[100];
fflush(stdin);
printf("Inserisci il nome dell'alunno che cerchi : ");
gets(nome);
fflush(stdin);
printf("Inserisci il cognome dell'alunno che cerchi : ");
gets(cognome);
fflush(stdin);

for(i=0;i<=MAX_STUDENTI;i++)
    {
       if( !strcmp(classe[i].nome,nome) && !strcmp(classe[i].cognome,cognome) )
        {
        printf("  # Nome : %s\n",classe[i].nome);
        printf("  # Cognome : %s\n",classe[i].cognome);
        printf("  # Matricola : %d\n",classe[i].matricola);
        printf("  # Data di Nascita : %s\n",classe[i].dataNascita);
        printf("  # Luogo di Nascita : %s\n",classe[i].luogoNascita);
        printf("  # Indirizzo : %s,%d - CAP : %d\n",classe[i].indirizzo.via,classe[i].indirizzo.civico,classe[i].indirizzo.cap);
        printf("  # Presenze : %d\n",classe[i].presenze);
        printf("  # Assenze : %d\n",classe[i].assenze);
        system("PAUSE");
        break;
        }
    }
}


int massimo_r(struct alunno* vettore, int n)
{
    if (n == 0)
       return vettore[0].assenze;
    else
       return massimo_r(vettore->assenze, n-1);
}

:hail::hail::hail:
aaa
11/02/11 23:07
Xaratroom
int massimo_r(struct alunno* vettore, int n)
{
    if (n <= 0)
        return -1;
    if (n == 1)
       return vettore[0].assenze;
    else
       return max(vettore->assenze, massimo_r(vettore+1, n-1));
}
aaa