Realizzare la prenotazione di voli con grafi

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Beh ovvio ... perché tutto il codice che ti ho elencato qui non l'hai postato e tu ovviamente ce l'hai!
Ad esempio manca tutto il file Queue.h come vuoi che io possa compilare?

Quindi adesso stampi? Ma adesso hai cambiato domanda e sinceramente non ho capito cosa non riesci a fare

Vero scusami mi sono dimenticato di aggiungerlo ora lo aggiungo....

Codice:

#ifndef QUEUE_H
#define QUEUE_H
          // questa coda sara' utilizzata per contenere valori interi
         // che rappresentano i vertici di un grafo
         // Nb: solo i vertici e non i pesi di eventuali archi

typedef struct node_struct{
        struct node_struct* next;
        int vertex;
}* QNode;
   
typedef struct Tqueue{
        QNode head;
        QNode tail;
}* Queue;


Queue initQueue(void);

void  freeQueue(Queue Q);

QNode initQueueNode(int vertex);

int isEmptyQueue(Queue Q);

void enqueue(Queue Q, int vertex);
   
// il valore di ritorno e' utilizzato per vedere se l'operazione va a buon fine
// se e' vuota ritorna -1 e la dequeue non e' stata eseguita
// in ogni altro caso ritorna 0 ed il puntatore *vertex conterra' il vertice
int dequeue(Queue Q, int* vertex);

#endif

Queue.c

C:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "Queue.h"

Queue initQueue(){
    Queue q = (Queue) malloc(sizeof(struct Tqueue));
    assert(q != NULL);
    q->head = q->tail = NULL;
    return q;
}

void freeQueue(Queue Q){
    assert(Q != NULL);
    QNode iter = Q->head, tmp = NULL;
    while (iter){
        tmp = iter;
        iter = iter->next;
        free(tmp);
    }
    free(Q);
    return;
}

QNode initQueueNode(int vertex){
    QNode newnode = (QNode) malloc(sizeof(struct node_struct));
    assert(newnode != NULL);
    newnode->vertex = vertex;
    newnode->next = NULL;
    return newnode;
}

int isEmptyQueue(Queue Q){
    assert(Q != NULL);
    return Q->head == NULL;
}

void enqueue(Queue Q, int vertex){
    QNode newnode = initQueueNode(vertex);
    if(isEmptyQueue(Q)){
        Q->tail = Q->head = newnode;
    }else{
        Q->tail->next = newnode;
        Q->tail = newnode;
    }
    return;
}

int dequeue(Queue Q, int* vertex){
    if(isEmptyQueue(Q)){
        return -1;
    }
    *vertex = Q->head->vertex;
    QNode tmp = Q->head;
    if(Q->head == Q->tail){
        Q->tail = NULL;
    }
    Q->head = Q->head->next;
    free(tmp);
    return 0;
}

Ora visto che le città vengono stampate vorrei inserire una città nel vettore..però la città viene inserita da tastiera

theprogrammer.99 · 29 Maggio 2020

Ancora errori di compilazione (per codice mancante) su inizializza aggiungi_nodo aggiungi_arco visitainprofondita ... non te lo ripeterò più ... se non posti il codice di tutte le funzioni e non è possibile compilare non posso fare nessuna prova.

La città viene inserita da tastiera (dove?) ... e quindi?? Qual è la domanda?

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Ancora errori di compilazione (per codice mancante) su inizializza aggiungi_nodo aggiungi_arco visitainprofondita ... non te lo ripeterò più ... se non posti il codice di tutte le funzioni e non è possibile compilare non posso fare nessuna prova.

La città viene inserita da tastiera (dove?) ... e quindi?? Qual è la domanda?

Ho postato tutto il codice...nel main nella scelta 2 del menu dell'amministratore devo inserire una città e devo far in modo che poi viene stampata insieme alle altre città
--- i due messaggi sono stati uniti ---

sare1234 ha detto:
Ho postato tutto il codice...nel main nella scelta 2 del menu dell'amministratore devo inserire una città e lo faccio con pritf e scanf poi devo aggiungerla e l'ho aggiunta con addNode e poi la stampo...cioè devo far in modo che poi viene stampata insieme alle altre città

--- i due messaggi sono stati uniti ---
Main

Codice:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "Graph.h"
#include "List.h"
#include "Menu.h"
#define MAXCITTA 10
#define MAXEMAILAMMINISTRATORE  20
#define MAXEMAILPWDAMMINISTRATORE 7
int main() {
    int scelta;
    int sceltaUt;
    int sceltaAmministratore;
    char email;
    char pwd;
    char citta [MAXCITTA] ;
    char emailAmministratore[MAXEMAILAMMINISTRATORE];
    char pwdAmministratore[MAXEMAILPWDAMMINISTRATORE];
    char deleteDestinazione;
    Graph g = NULL;
    int numCitta;
    char* nomiCitta[20] = {"Napoli" /*vertice 0*/, "Milano" /*vertice 1*/, "Genova" /*vertice 2*/, "Firenze" /*vertice 3*/, "Roma" /*vertice 4*/, "Torino" /*vertice 5*/, "Venezia" /*vertice 6*/, "Palermo" /*vertice 7*/, "Bari" /*vertice 8*/, "Perugia" /*vertice 9*/,"Parma" /*vertice 10*/,"Calabria" /*vertice 11*/,"Trento" /*vertice 12*/,"Aosta" /*vertice 13*/,"Ancona" /*vertice 14*/,"Pescara" /*vertice 15*/,"Potenza" /*vertice 16*/,"Catania" /*vertice 17*/,"Reggio Emilia" /*vertice 18*/,"Cagliari" /*vertice 19*/};
 
    while((scelta = menu())){
    switch (scelta)
    {
 
     case 1:
                 printf("Inserisci email: ");
                 scanf("%s", &emailAmministratore);
                   
                 printf("Inserisci password(max 7 caratteri): ");
                 scanf("%s", &pwdAmministratore);
       
              while((sceltaAmministratore = menuAmministratore())){
                 switch (sceltaAmministratore) {
                     case 1://stampa archivo
                 
                         g = initGraph(20, nomiCitta);
                            printGraph(g);
                   
                            break;
                     
                     case 2://inserisci città
                 
                         printf("Inserisci il numero della città");
                         scanf("%d", &numCitta);
                     
                         printf("Inserisci la destinazione che desideri inserire:");
                         scanf("%s", &citta);
                     

                         addNode(numCitta , citta);

                          break;
                 
                     case 3://cancella
                       
                            printf("Inserisci destinazione da eliminare: ");
                           scanf("%s", &deleteDestinazione);
                     
                         removeNode(g,deleteDestinazione);
                       
                          break;
                  }
              }
            return 0;
         
         break;

    case 2:
              while((sceltaUt = menuUtente())){
                  switch (sceltaUt) {
                    case 1:
                   
                      printf("Inserisci l'email: ");
                      scanf ("%s", &email);
                   
                      printf("Inserisci password(max 7 caratteri): ");
                      scanf("%s", &pwd);
                   
                      printf("\niscrizione effettuata con successo");

               
                      break;
                   case 2:
                     printf("Inserisci l'email: ");
                     scanf ("%s", &email);
         
                     printf("Inserisci password(max 7 caratteri): ");
                     scanf("%s", &pwd);
         
                      printf("accesso effettuata con successo");
         
                break;
     
                  }
              }
           return 0;
   case 3: /*Se l'utente vuole uscire*/

      printf("Grazie per aver scelto il servizio di gestione prenotazione voli, torna a trovarci!\n");

      return 0;

       break;

    default: /*Se l'utente sbaglia ad inserire il numero*/
    printf("Questo tasto non consente di effetuare scelte! Riprova!\n");

       break;

          } /*Fine switch*/
    } /*Fine do*/
  return 0;
} /*Fine main*/

Graph.h

Codice:

#ifndef Graph_Graph_h
#define Graph_Graph_h
#include "List.h"

//struttura per il grafo
struct TGraph {
    List *adj;
    int nodes_count;
    char** cityNames;
};

typedef struct TGraph* Graph;

// Dealloca l'intero grafo
void freeGraph(Graph G);

// Inizializza un nuovo grafo vuoto specificando in ingresso quanti nodi saranno nel grafo
Graph initGraph(int nodes_count, char** cityNames);

// Stampa il grafo
void printGraph(Graph G);

// Aggiunge un arco, specificando sorgente, target e peso
void addEdge(Graph G, int source, int target, int peso);

// Rimuovi un arco specificando sorgente e target,restituisce la lista degli archi modifcata
List removeEdge(Graph G, int source, int target);

// Aggiungi un nodo
void addNode(Graph G, char* newCity);

// Rimuovi un nodo dal grafo, sistemando gli indici e riallocando la memoria
void removeNode(Graph G, int node_to_remove);

List checkListRemoval(List L, int node_to_remove);

// Crea un nuovo grafo e lo popola in base alla scelta effettuata dal menu
Graph graphCreationMenu(int n);

// Menu per la modifica e gestione dei grafi
void graphEditorMenu(Graph);

//enumerazione per colori utilizzati nella bfs
typedef enum{WHITE, GREY, BLACK} GraphColor;

// ricerca del percorso minimo dal vertice source a quello target
List bfs(Graph G, int source, int target);

// minimizza il percorso considerando il peso degli archi del grafo (funziona solo se tutti gli archi hanno peso positivo)
List dijkstra(Graph G, int source, int target);

// estrapola da visit_info il percorso da source a target
List generatePath(int* visit_info, int* weight_info, int source, int target);

// cerca il numero del vertice associato al nome di una particolare citta'
int getCityIndexByName(Graph G, char* key);

int getCityIndex(Graph G, char* message);

#endif

Graph.c

Codice:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>
#include <string.h>
#include "Graph.h"
#include "List.h"
#include "Queue.h"

Graph initGraph(int nodes_count, char** cityNames) {
    Graph G = (Graph)malloc(sizeof(struct TGraph));
    assert(G != NULL);
    G->adj = (List *)calloc(nodes_count, sizeof(List));
    assert(G->adj != NULL);
    G->nodes_count = nodes_count;
    G->cityNames = cityNames;
    return G;
}

void freeGraph(Graph G) {
    if (G != NULL) {
        if (G->nodes_count > 0) {
            int i = 0;
            for (i = 0; i < G->nodes_count; i++) {
                freeList(G->adj[i]);
            }
        }
        free(G);
    }
}

void printGraphAux(Graph G) {
    if (G != NULL) {
        int x = 0;
        for (x = 0; x < G->nodes_count; x++) {
           printf("(city: %s, id:%d) ", G->cityNames[x], x);
            printList(G->adj[x]);
            printf("\n");
        }
    }
}

void printGraph(Graph G) {
    printGraphAux(G);
    printf("\n\n");
}

void addEdge(Graph G, int source, int target, int peso) {
    assert(G != NULL);
    assert(source < G->nodes_count);
    assert(target < G->nodes_count);
    if (source != target) {
        G->adj[source] = appendNodeList(G->adj[source], target, peso);
    }
 
}


List removeEdge(Graph G, int source, int target) {
    assert(G != NULL);
    assert(source < G->nodes_count);
    assert(target < G->nodes_count);
    if (source != target) {
        G->adj[source] = removeNodeList(G->adj[source], target);
    }
    return G->adj[source];
}


void addNode(Graph G, char* newCity) {
    if (G != NULL) {
        List * old=G->adj;
        char** old_matrix = G->cityNames;
        int i=0;
        G->adj = (List *)calloc(G->nodes_count+1, sizeof(List));
        assert(G->adj != NULL);
        G->cityNames = (char**)calloc(G->nodes_count+1, sizeof(char*));
        assert(G->cityNames != NULL);
        for(i=0;i<G->nodes_count;i++){
            G->adj[i]=old[i];
            G->cityNames[i] = old_matrix[i];
        }
        G->nodes_count += 1;
        G->adj[G->nodes_count-1] = NULL;
        G->cityNames[G->nodes_count-1] = (char*) calloc(strlen(newCity)+1, sizeof(char));
        assert(G->cityNames[G->nodes_count-1] != NULL);
        strcpy(G->cityNames[G->nodes_count-1], newCity);
    }
}


void removeNode(Graph G, int node_to_remove) {
    if (G != NULL) {
        int i = 0;
        int x = 0;
        List *tmp = G->adj;
        char** old_matrix = G->cityNames;
        G->adj = (List *)calloc(G->nodes_count-1, sizeof(List));
        assert(G->adj != NULL);
        G->cityNames = (char**)calloc(G->nodes_count-1, sizeof(char*));
        assert(G->cityNames != NULL);
        for (i = 0; i < G->nodes_count; i++) {
            if (i != node_to_remove) {
                G->adj[x] = checkListRemoval(tmp[i], node_to_remove);
                G->cityNames[x] = old_matrix[i];
                x++;
            } else {
                free(old_matrix[i]);
                freeList(tmp[i]);
            }
        }
        free(tmp);
        free(old_matrix);
        G->nodes_count -= 1;
    }
}


List checkListRemoval(List L, int node_to_remove) {
    if (L != NULL) {
        L->next = checkListRemoval(L->next, node_to_remove);
        if (L->target == node_to_remove) {
            List tmp = L->next;
            free(L);
            return tmp;
        } else if (L->target > node_to_remove) {
            L->target -= 1;
        }
    }
    return L;
}

List bfs(Graph G, int source, int target){
    assert(G != NULL);                                          // controllo che il grafo non sia nullo
    assert(source < G->nodes_count || target < G->nodes_count); // controllo che i vertici inseriti appartengano al grafo
    Queue Q = initQueue();
    int* visit_path = (int*)calloc(G->nodes_count, sizeof(int));
    assert(visit_path != NULL);
    int* current_weight = (int*) calloc(G->nodes_count, sizeof(int));
    assert (current_weight != NULL);
    // calloc inizializza gli interi a zero, che nella enum corrisponde a WHITE
    GraphColor* visited = (GraphColor*) calloc(G->nodes_count, sizeof(GraphColor));
    assert(visited != NULL);
    enqueue(Q, source);
    visited[source] = BLACK;
    // il nodo di partenza e' raggiungibile da se stesso con un percoso nullo
    visit_path[source] = source;
    current_weight[source] = 0;
    int target_found = 0;
    int v;
    while(!isEmptyQueue(Q)  && !target_found){
        // non occorre controllare  che la coda abbiamo terminato l'operazione correttamente
        // dato che in questo punto del codice sicuramente non e' vuota;
        dequeue(Q, &v);
        for(List iter = G->adj[v]; iter != NULL; iter = iter->next){
            if(visited[iter->target] == WHITE){
                enqueue(Q, iter->target);
                // segno di aver visitato il vertice in cui termina l'arco
                visited[iter->target] = BLACK;
                // segno che il vertice in questione e' raggiungibile con un arco partendo dal vertice v
                visit_path[iter->target] = v;
                // bcalcolo il peso del percorso
                current_weight[iter->target] = current_weight[v] + iter->peso;
                if(iter->target == target){
                    target_found = 1;
                    break;
                }
            }
        }
    }
    freeQueue(Q);
    List path = NULL;
    if(target_found != 0) {
        // genera il percorso da source a target(se presente) e lo inserisce in una lista
        path = generatePath(visit_path, current_weight, source, target);
    }
    free(visited);
    free(visit_path);
    free(current_weight);
    return path;
}

List dijkstra(Graph G, int source, int target){
    assert(G != NULL);                                          // controllo che il grafo non sia nullo
    assert(source < G->nodes_count || target < G->nodes_count); // controllo che i vertici inseriti appartengano al grafo
    Queue Q = initQueue();
    int* visit_path = (int*)calloc(G->nodes_count, sizeof(int));
    assert(visit_path != NULL);
    // a differenza dell bfs, dijkstra deve tenere traccia anche del peso dei percorsi finora analizzati
    int* current_weight = (int*) calloc(G->nodes_count, sizeof(int));
    assert(current_weight != NULL);
    // calloc inizializza gli interi a zero, che nella enum corrisponde a WHITE
    GraphColor* visited = (GraphColor*) calloc(G->nodes_count, sizeof(GraphColor));
    assert(visited != NULL);
    enqueue(Q, source);
    visited[source] = BLACK;
    // il nodo di partenza e' raggiungibile da se stesso con un percoso nullo
    visit_path[source] = source;
    current_weight[source] = 0; // questa assegnazione e' inutile ma rende piu' semplice da capire l'algoritmo
    int target_found = 0;
    int v;
    while(!isEmptyQueue(Q)){
        // non occorre controllare  che la coda abbiamo terminato l'operazione correttamente
        // dato che in questo punto del codice sicuramente non e' vuota;
        dequeue(Q, &v);
        for(List iter = G->adj[v]; iter != NULL; iter = iter->next){
            if(visited[iter->target] == WHITE){
                enqueue(Q, iter->target);
                // segno di aver visitato il vertice in cui termina l'arco
                visited[iter->target] = BLACK;
                // segno che il vertice in questione e' raggiungibile con un arco partendo dal vertice v
                visit_path[iter->target] = v;
                // calcolo il peso del percorso
                current_weight[iter->target] = current_weight[v] + iter->peso;
                if(iter->target == target){
                    target_found = 1;
                }
            }else if(visited[iter->target] == BLACK && (current_weight[iter->target] > current_weight[v] + iter->peso)){
                // nel caso un vertice venga raggiunto da un percorso "piu' leggero", cambio il predecessore, ed il peso, del nodo in questione
                visit_path[iter->target] = v;
                current_weight[iter->target] = current_weight[v] + iter->peso;
            }
        }
    }
    freeQueue(Q);
    List path = NULL;
    if(target_found != 0){
        // genera il percorso da source a target(se presente) e lo inserisce in una lista
        path = generatePath(visit_path, current_weight, source, target);
    }
    free(visited);
    free(visit_path);
    free(current_weight);
    return path;
}

List generatePath(int* visit_info, int* weight_info, int source, int target){
    if(source == target){
        return initNodeList(source, weight_info[source]);
    }else{
        List path = generatePath(visit_info, weight_info, source, visit_info[target]);
        path = appendNodeList(path, target, weight_info[target]);
        return path;
    }
}

int getCityIndexByName(Graph G, char* key){
    assert(G != NULL);
    assert(G->cityNames != NULL);
    int index = -1;
    int i;
    for(i=0; i<G->nodes_count; i++){
        if(!strcmp(G->cityNames[i], key)){
            index = i;
            break;
        }
    }
    return index;
}

int getCityIndex(Graph G, char* message){
    int choice;
    do{
        printf("\nMete disponibili:\n");
        for(int i=0; i<G->nodes_count; i++){
            printf("Nome: %s, id: %d\n", G->cityNames[i], i);
        }
        printf("\nSeleziona una meta di %s:", message);
        scanf("%d", &choice);
        if(choice < 0 || choice >= G->nodes_count){
            printf("Scelta non valida.\n");
        }
    }while(choice < 0 ||  choice >= G->nodes_count);
    return choice;
}

List.h

Codice:

#ifndef Graph_List_h
#define Graph_List_h

//struttura per la lista di adiacenza
struct TList {
    int target;
    int peso;
    struct TList* next;
};

typedef struct TList* List;

// Inizializza un nuovo nodo
List initNodeList(int target, int peso);

// Aggiunge un nodo alla fine della lista
// controllandone l'esistenza
// La funzione ritorna sempre la testa della lista
List appendNodeList(List L, int target, int peso);

// Aggiunge un nodo in testa alla lista
// senza controllare l'esistenza
// La funzione ritorna sempre la testa della lista
List addNodeHead(List L, int target, int peso);

// Rimuove solo un occorrenza di un nodo con il target specificato
// dalla lista
// La funzione ritorna sempre la testa della lista
List removeNodeList(List L, int target);

// Dealloca la lista interamente
void freeList(List L);

// Stampa la lista
void printList(List L);

#endif

List.c

Codice:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <time.h>
#include "List.h"

List initNodeList(int target, int peso) {
    List L = (List)malloc(sizeof(struct TList));
    assert(L != NULL);// controllo che vi sia ancora memoria disponibile
    L->target = target;
    L->peso = peso;
    L->next = NULL;
    return L;
}

List appendNodeList(List L, int target, int peso) {
    if (L != NULL) {
        if (L->target != target) {
            L->next = appendNodeList(L->next, target, peso);
        }
        //else target gia' presente in lista e non sono ammessi duplicati, quindi non si fa nulla
    } else {
        L = initNodeList(target, peso);
    }
    return L;
}

List addNodeHead(List L, int target, int peso) {
    List G = initNodeList(target, peso);
    if (L != NULL) {
        G->next = L;
    }
    return G;
}


List removeNodeList(List L, int target) {
    if (L != NULL) {
        if (L->target == target) {
            List tmp = L->next;
            free(L);
            return tmp;
        }
        L->next = removeNodeList(L->next, target);
    }
    return L;
}


void freeList(List L) {
    if (L != NULL) {
        freeList(L->next);
        free(L);
    }
}


void printList(List L) {
    if (L != NULL) {
        printf(" (id:%d, peso:%d) ", L->target, L->peso);
        printList(L->next);
    }
}

QUEUE.h

Codice:

#ifndef QUEUE_H
#define QUEUE_H
          // questa coda sara' utilizzata per contenere valori interi
         // che rappresentano i vertici di un grafo
         // Nb: solo i vertici e non i pesi di eventuali archi

typedef struct node_struct{
        struct node_struct* next;
        int vertex;
}* QNode;
 
typedef struct Tqueue{
        QNode head;
        QNode tail;
}* Queue;


Queue initQueue(void);

void  freeQueue(Queue Q);

QNode initQueueNode(int vertex);

int isEmptyQueue(Queue Q);

void enqueue(Queue Q, int vertex);
 
// il valore di ritorno e' utilizzato per vedere se l'operazione va a buon fine
// se e' vuota ritorna -1 e la dequeue non e' stata eseguita
// in ogni altro caso ritorna 0 ed il puntatore *vertex conterra' il vertice
int dequeue(Queue Q, int* vertex);

#endif

queue.c

Codice:

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "Queue.h"

Queue initQueue(){
    Queue q = (Queue) malloc(sizeof(struct Tqueue));
    assert(q != NULL);
    q->head = q->tail = NULL;
    return q;
}

void freeQueue(Queue Q){
    assert(Q != NULL);
    QNode iter = Q->head, tmp = NULL;
    while (iter){
        tmp = iter;
        iter = iter->next;
        free(tmp);
    }
    free(Q);
    return;
}

QNode initQueueNode(int vertex){
    QNode newnode = (QNode) malloc(sizeof(struct node_struct));
    assert(newnode != NULL);
    newnode->vertex = vertex;
    newnode->next = NULL;
    return newnode;
}

int isEmptyQueue(Queue Q){
    assert(Q != NULL);
    return Q->head == NULL;
}

void enqueue(Queue Q, int vertex){
    QNode newnode = initQueueNode(vertex);
    if(isEmptyQueue(Q)){
        Q->tail = Q->head = newnode;
    }else{
        Q->tail->next = newnode;
        Q->tail = newnode;
    }
    return;
}

int dequeue(Queue Q, int* vertex){
    if(isEmptyQueue(Q)){
        return -1;
    }
    *vertex = Q->head->vertex;
    QNode tmp = Q->head;
    if(Q->head == Q->tail){
        Q->tail = NULL;
    }
    Q->head = Q->head->next;
    free(tmp);
    return 0;
}

Menu.h

Codice:

#ifndef Menu_h
#define Menu_h

#include <stdio.h>

//menu principale
int menu(void);

//menu scelte utente
int menuUtente(void);

//menu scelte amministatore
int menuAmministratore(void);

#endif /* Menu_h */

Menu.c

Codice:

#include "Menu.h"

int menu(void){
int scelta; /*Questa variabile sarà utilizzata nella switch per decidere che cosa fare...*/
printf("* * * * * * * * * * * * * * * * * * * * * * *  Benvenuto in gestione prenotazione voli\n* * * * * * * * * * * * * * * * * * * * * * *  \n");

    printf(" 1. Accesso amministratore\n");
    printf(" 2. Accesso utente\n");
    printf(" 3. Uscire\n");
    printf("Inserisci scelta:");
    scanf("%d",&scelta); /*Viene inserito nella variabile var il numero inserito dall'utente e di conseguenza inserito nel ciclo Switch*/
   while(scelta<0 || scelta>3) {
       printf("Questo tasto non consente di effetuare scelte! Riprova!\n");
      printf("Scelta: ");
      scanf("%d", &scelta);
   return scelta;

   }

return scelta;

}

int menuUtente(void){
int sceltaUt; /*Questa variabile sarà utilizzata nella switch per decidere che cosa fare...*/
printf("* * * * * * * * * * * * * * * * * * * * * * * *                   UTENTE\n* * * * * * * * * * * * * * * * * * * * * * * *  \n");

    printf(" 1. Effettua Iscrizione\n");
    printf(" 2. effettua accesso\n");
    printf("Inserisci scelta:");
    scanf("%d",&sceltaUt); /*Viene inserito nella variabile var il numero inserito dall'utente e di conseguenza inserito nel ciclo Switch*/
   while(sceltaUt<0 || sceltaUt>2) {
       printf("Questo tasto non consente di effetuare scelte! Riprova!\n");
      printf("Scelta: ");
      scanf("%d", &sceltaUt);
   return sceltaUt;

   }

return sceltaUt;

}

int menuAmministratore(void){
int sceltaAmministratore; /*Questa variabile sarà utilizzata nella switch per decidere che cosa fare...*/
printf("* * * * * * * * * * * * * * * * * * * * * * * *                 AMMINISTRATORE \n* * * * * * * * * * * * * * * * * * * * * * * *  \n");
 
    printf(" 1. Stampa destinazioni\n");
    printf(" 2. Inserisci destinazione \n");
    printf(" 3. Cancella destinazione\n");
    printf("Inserisci scelta:");
    scanf("%d",&sceltaAmministratore); /*Viene inserito nella variabile var il numero inserito dall'utente e di conseguenza inserito nel ciclo Switch*/
    while(sceltaAmministratore<0 || sceltaAmministratore>3) {
       printf("Questo tasto non consente di effetuare scelte! Riprova!\n");
      printf("Scelta: ");
      scanf("%d", &sceltaAmministratore);
   return sceltaAmministratore;

   }

return sceltaAmministratore;

}

Questo è tutto il codice io ora vorrei inserire una città nel grafo che ho creato..cosi come ho fatto ma non mi funziona

theprogrammer.99 · 29 Maggio 2020

Guarda che il codice della funzioni

aggiungi_nodo
aggiungi_arco

io non lo vedo ... dimmi tu dove sta altrimenti non so cosa dirti.

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Guarda che il codice della funzioni

aggiungi_nodo
aggiungi_arco

io non lo vedo ... dimmi tu dove sta altrimenti non so cosa dirti.

no ho modificato il programma...quello che funziona e tutto il programma scritto nell'ultimo messaggio quelli precedenti non devi considerarli

theprogrammer.99 · 29 Maggio 2020

E quando l'hai detto che hai modificato tutto?? Ma così diventiamo matti ...

In quest'altro codice comunque questa riga

addNode(numCitta, &citta);

dà un errore (ovviamente) dato che il primo parametro non è quello che si aspetta ...

Ma tu li compili i programmi??

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
E quando l'hai detto che hai modificato tutto?? Ma così diventiamo matti ...

In quest'altro codice comunque questa riga

addNode(numCitta, &citta);

dà un errore (ovviamente) dato che il primo parametro non è quello che si aspetta ...

Ma tu li compili i programmi??

scusa mi sono dimentica di dirlo...sisi so che da errore dovrei passare g invece di numCittà giusto?
--- i due messaggi sono stati uniti ---

sare1234 ha detto:
scusa mi sono dimentica di dirlo...sisi so che da errore dovrei passare g invece di numCittà giusto?

ma facendo addNode(g, città) comunque non me lo aggiunge :(

theprogrammer.99 · 29 Maggio 2020

Ma che sono tutte queste

char email;
char pwd;
char citta;
char emailAmministratore;
char pwdAmministratore;

???

Devono essere stringhe e non char. Sai la differenza tra una stringa del C e un char?

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Ma che sono tutte queste

char email;
char pwd;
char citta;
char emailAmministratore;
char pwdAmministratore;

???

Devono essere stringhe e non char. Sai la differenza tra una stringa del C e un char?

in realtà sono utilizzate dopo quindi per ora sto sistemando prima la parte dell'amministratore

theprogrammer.99 · 29 Maggio 2020

Guarda che questa

char citta;

la usi nella

addNode(numCitta, &citta);

ed è sbagliata ....

E comunque è un discorso generale ... molte volte utilizzi char al posto di stringhe nel tuo codice, ovviamente con tutti i problemi che ne conseguono. Prima aggiusta questo problema e poi si parla del resto.

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Guarda che questa

char citta;

la usi nella

addNode(numCitta, &citta);

ed è sbagliata ....

E comunque è un discorso generale ... molte volte utilizzi char al posto di stringhe nel tuo codice, ovviamente con tutti i problemi che ne conseguono. Prima aggiusta questo problema e poi si parla del resto.

--- i due messaggi sono stati uniti ---

sare1234 ha detto:
aggiustato

theprogrammer.99 · 29 Maggio 2020

Aggiustati? Dove?

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Aggiustati? Dove?

ho modifico sopra

theprogrammer.99 · 29 Maggio 2020

Ma fai le cose tanto per farle o le capisci?

Se continui a scrivere

addNode(g, &citta);

ovviamente è un errore.

Oltre al fatto che 10 caratteri per la città non mi sembra abbia senso.

Comunque continuo a pensare (adesso ne sono sicuro) che tu non compili il codice e non vuoi capire ma solo ottenere la scrittura del codice.

sare1234 · 29 Maggio 2020

theprogrammer.99 ha detto:
Ma fai le cose tanto per farle o le capisci?

Se continui a scrivere

addNode(g, &citta);

ovviamente è un errore.

Oltre al fatto che 10 caratteri per la città non mi sembra abbia senso.

Comunque continuo a pensare (adesso ne sono sicuro) che tu non compili il codice e non vuoi capire ma solo ottenere la scrittura del codice.

nono giuro lo compilo ed me lo fa compilare solo che poi quando voglio aggiungere non mi va..perche i parametri g e città non vanno bene..ho scritto addNode(g,citta), perche non va bene?

Realizzare la prenotazione di voli con grafi

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo

theprogrammer.99

Nuovo Utente

sare1234

Utente Attivo