[C++] Scansione file e creazione coppie

[oiboo]

C++ Esercizio bisogno di chiarimenti
Salve a tutti ho provato a scrivere un programma che legge in input da un file liste testo.txt e poi dovrebbe scansionare il file e creare delle coppie, questo e il file testo:

Alberto 24 Palermo 1
Ciccio 26 Roma 2
Carlo 30 Pisa 3
1 Carla 28 Roma
2 Maria 28 Roma
3 Giusi 28 Roma

Il programma dovrebbe creare queste coppie:
Alberto 24 Palermo
Carla 28 Roma
Ciccio 26 Roma
Maria 28 Roma
Carlo 30 Pisa
Giusi 28 Roma

Io ho provato a compilare il programma e gira, ma quando faccio run non mi fa vedere niente, potreste corregermi dove sbaglio. Grazie
Sotto vi posto il mio codice:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>


typedef struct LUI {
char nome_lui[50];
int eta_lui;
char citta_lui[50];
int n_lui;
struct _LUI *maschio;
}LUI;

typedef struct LEI {
int n_lei;
char nome_lei[50];
int eta_lei;
char citta_lei[50];
struct _LEI *femmina;
}LEI;


int main()
{
int i, j, nlui=0, nlei=0, res, aux, p, k, n;
FILE *fp;
fp=fopen("Archivio_coppie.txt", "r");
LUI archivio[50];
LEI archivio1[50];


if (fp==NULL) /*Si è verificato un errore il file Archivio_coppie non esiste*/
printf ("Errore: il file 'Archivio_coppie.txt' non esiste\n");

do
{ res=fscanf (fp,"%s %d %s %d %d %s %d %s " ,
archivio[nlui].nome_lui,
&archivio[nlui].eta_lui,
archivio[nlui].citta_lui,
&archivio[nlui].n_lui,
&archivio1[nlei].n_lei,
archivio1[nlei].nome_lei,
&archivio1[nlei].eta_lei,
archivio1[nlei].citta_lei);
}


while (res!=EOF && ++nlui && ++nlei);
fclose (fp);




p = n;
do
{k = 0;
for(i=0; i<nlui-1; i++)
for(j=0; i<nlei-1; i++)
if(archivio[i].n_lui>archivio1[i+1].n_lei) {
aux = archivio[i].n_lui; archivio[i].n_lui= archivio1[i+1].n_lei; archivio1[i+1].n_lei= aux;
k = 1; p = i+1;
}
n = p;
}
while(k==1);



{ printf ("\n%d\n%d\n%s\n%s\n%s\n%s\n%d\n%d\n", archivio[i].n_lui,
archivio1[i].n_lei,
archivio[i].nome_lui,
archivio1[i].nome_lei,
archivio[i].citta_lui,
archivio1[i].citta_lei,
archivio[i].eta_lui,
archivio1[i].eta_lei);


printf ("\nPremi INVIO per visualizzare la coppia successiva\n");
getchar();
}

printf ("\n\nPremi 'INVIO' per chiudere il programma.\n\n");
getchar();


return 0;
}



Il file testo "Archivio_coppie.txt" è scritto in questo modo:

Alberto 24 Palermo 1
Ciccio 26 Roma 2
Carlo 30 Pisa 3
1 Carla 28 Roma
2 Maria 28 Roma
3 Giusi 28 Roma

Le righe non sono fissate a priori, le stringhe possono anche essere mescolate, il calcolatore deve essere ingrado di fare le coppie corrette anche con stringhe mescolate e riconoscere se una stringa e ripetuta e eliminarla.

Il file è scritto:
nome_lui eta_lui citta_lui n_lui
..............................
.................................
.......................................
n_lei nome_lei eta_lei citta_lei

Le coppie verranno fatte in base a n_lui e n_lei, tipo:
Alberto 24 Palermo
Carla 28 Roma

Il file deve creare le coppie anche se è scritto così:
Carlo 30 Pisa 3
1 Carla 28 Roma
Ciccio 26 Roma 2
2 Maria 28 Roma
3 Giusi 28 Roma
Alberto 24 Palermo 1

E deve riconoscere se ci sono stringhe doppie e eliminare tipo:
Alberto 24 Palermo 1
Ciccio 26 Roma 2
Carlo 30 Pisa 3
1 Carla 28 Roma
2 Maria 28 Roma
3 Giusi 28 Roma

Alberto 24 Palermo 1

Un bel casino!!!!!!!!!!

[LeleFT]

Per richieste di "lavori" a pagamento esiste un apposito Forum.
Se la tua è una richiesta di aiuto per la modifica di un codice che non funziona, nel senso che desideri ricevere delle dritte, consigli o quant'altro, allora ti invito a specificare dei titoli che siano più significativi, che riassumano la sostanza del tuo problema.

Questo lo modifico io.

Oltretutto mi sembra che tu stia parlando di C++... per questi linguaggi c'è il forum generico "Programmazione".


Ciao.

[oiboo]

Perchè non mi date qualche dritta , non penso che nessuno in questo forum non sia capace a fare questo esercizio!!!!!!!!

[oregon]

Originariamente inviato da oiboo
Perchè non mi date qualche dritta , non penso che nessuno in questo forum non sia capace a fare questo esercizio!!!!!!!!

Calma! Se nessuno ti risponde, le cause possono essere

1) non si sa come affrontare il tuo problema

2) non si capisce il tuo problema

3) non si ha tempo

In ogni caso, con l'impazienza non ottieni nulla ...

Dato che hai detto che il lavoro puo' essere retribuito, prova comunque nell'area "offerta lavoro" ...

Per quanto riguarda il problema stesso, se ho capito bene, ci sono

Nome Età Città ID

e

ID Nome Età Città

E i campi ID collegano la coppia? E' così?
Il numero di elementi è sempre corrispondente (n nel primo gruppo ed n nel secondo)?
Gli ID possono essere qualsiasi valore o sono in sequenza?

[oiboo]

Scusate tutti, per la mia inpazienza.

E i campi ID collegano la coppia?

Si

E' così?

SI

Il numero di elementi è sempre corrispondente (n nel primo gruppo ed n nel secondo)?

SI

Gli ID possono essere qualsiasi valore o sono in sequenza?

Sono in seguenza.

Grazie ancora.

[oiboo]

Sempre per l'esercizio di cui sopra, ho provato ha risolverlo così:

/*LEGGE DA FILE.txt E STAMPA A VIDEO IL FILE COPPIE*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define DIM 50



typedef struct LUI {
char nome_lui[50];
int eta_lui;
char citta_lui[50];
int n_lui;
}LUI;

typedef struct LEI {
int n_lei;
char nome_lei[50];
int eta_lei;
char citta_lei[50];
}LEI;

int main()
{
int LUI archivio1[DIM], LEI archivio2[DIM], archivio3[2*DIM];
int i, j, k, res, narchivio1=0, narchivio2=0 ;

FILE *fp;
fp=fopen("Archivio_coppie.txt", "r");



for(i=0; i<DIM; i++)

{ res=fscanf (fp,"%s %d %s %d" ,
LUI archivio1[i].nome_lui,
&LUI archivio1[i].eta_lui,
LUI archivio1[i].citta_lui,
&LUI archivio1[i].n_lui);

}
for (i=0; i<DIM; i++)

{ res=fscanf (fp,"%d %s %d %s " ,
&LEI archivio2[i].n_lei,
LEI archivio2[i].nome_lei,
&LEI archivio2[i].eta_lei,
LEI archivio2[i].citta_lei);
}
for (i=0, j=0, k=0; (i<DIM)&&(j<DIM); k++) {
if (LUI archivio1[i]>LEI archivio2[j])
archivio3[k]=LEI archivio2[j];
j++;
} else {
archivio3[k]=LUI archivio1[i];
i++;
}
while (j<DIM) {
archivio3[k]=LEI archivio2[j];
j++;
k++;
}
while (i<DIM) {
archivio3[k]=LUI archivio1[i];
i++;
k++;
}

for (k=0;k<2*DIM;k++)

{ printf ("\n%d\n%d\n%s\n%s\n%s\n%s\n%d\n%d\n", archivio3[k].n_lui,
archivio3[k].n_lei,
archivio3[k].nome_lui,
archivio3[k].nome_lei,
archivio3[k].citta_lui,
archivio3[k].citta_lei,
archivio3[k].eta_lui,
archivio3[k].eta_lei);


printf ("\nPremi INVIO per visualizzare la coppia successiva\n");
getchar();
}

printf ("\n\nPremi 'INVIO' per chiudere il programma.\n\n");
getchar();


return 0;
}

ma mi da degli errori di compilazione,
c'è qualcuno che me lo può corregere.
E anche un'altra cosa sono sulla strada giusta a far fare al compilatore quello che interessa a me?

[oiboo]

Finalmente penso di essere arrivato quasi alla soluzione del mio problema, il programma funziona se metto tutti i numeri davanti al nome, ma siccome i numeri delle ragazze sono messi a fine stringa il programma mi ordina separatamente i maschi dalle ragazze tipo:
1 Alberto 29 Palermo
2 Paolo 23 Roma
3 Alessandro 22 Milano
Carla 22 Roma 1
Paola 23 Roma 2
Roberta 24 Roma 3.

Potreste leggere il programma che vi posto e vedere dovè l'errore grazie:
#include <stdio.h>
#define LUNGMAX 50 /* La prossima definizione consente di cambiare facilmente la lunghezza massima consentita dei nomi e dei cognomi */
#define NMAXSTUD 100 /* La prossima definizione consente di cambiare facilmente il numero massimo di coppie */

/* Definizione dei prototipi delle funzioni */
void incastra_ordinato(char elenco[][], int inizio, int separa,
int fine, int iniz_chiave, int iniz_chiave2, int lung_chiave);
void ordina(char elenco[][], int nstud, int iniz_chiave, int iniz_chiave2, int lung_chiave);
void scambia_righe(char elenco[][], int riga1, int riga2);

int main()
{
int i, ncoppie;
char iniz_chiave, iniz_chiave2, lung_chiave;
char intestazione[3*LUNGMAX];
char elenco[NMAXSTUD][3*LUNGMAX];
FILE *ifp; /* Apriamo il file di input "Archivio_coppie.txt" in lettura, associamo a ifp l'indirizzo corrispondente al file */
ifp = fopen("Archivio_coppie.txt", "r");

fgets(intestazione, 3*LUNGMAX, ifp); /* Leggiamo la prima riga di intestazione in cima al file di input */

ncoppie = 0; /* Inizializziamo la variabile ncoppie (che rappresenta il numero di coppie) uguale a 0 */

while( fgets(&elenco[ncoppie][0], 3*LUNGMAX, ifp) != NULL) { /* Leggiamo una riga del file di input e la scriviamo nella
ncoppie-esima riga della matrice elenco utilizzando
l'istruzione fgets.
Questa istruzione di lettura la mettiamo all'interno di una
condizione di esecuzione di un ciclo while(...) {...}.
Continuiamo ad eseguire il ciclo, mentre e' verificata la
condizione che il risultato restituito da fgets sia diverso da
NULL */
ncoppie++; /* Incrementiamo di 1 la variabile ncoppie */
}

fclose(ifp); /* Chiudiamo il file di input */
/* Vogliamo mettere in fila l'elenco delle coppie secondo l'ordine dell'id
sappiamo che:
(1) ci sono 0 caratteri prima che inizi id
(2) cognome e nome insieme sono lunghi al piu' 2*LUNGMAX-2 caratteri */

iniz_chiave = 0; /* Allora poniamo iniz_chiave uguale a 0 ... */
iniz_chiave2 = 21;


lung_chiave = 3 * LUNGMAX ; /* ... e lung_chiave uguale a 2*LUNGMAX-2 caratteri */

ordina (elenco, ncoppie, iniz_chiave, iniz_chiave2, lung_chiave); /* Ordiniamo l'elenco */


for(i=0; i<ncoppie; i++)

{
printf("%s", &elenco[i][0]); /* Visualizziamo su video l'output la i-esima riga della matrice elenco */
}
system("pause");

}

void incastra_ordinato(elenco, inizio, separa, fine, iniz_chiave, iniz_chiave2, lung_chiave)
char elenco[][3*LUNGMAX];
int inizio, separa, fine, iniz_chiave, iniz_chiave2, lung_chiave;
{
int i, i1, i2, j, vetord[NMAXSTUD];
i1 = inizio; /* Inizializziamo il contatore i1 uguale a inizio ... */

i2 = separa; /* ... e il contatore i2 uguale a separa ... */


i = inizio; /* ... e il contatore i uguale a inizio */
/* A questo punto vogliamo definire il vettore vetord in modo che contenga gli indici delle righe (comprese tra la inizio-esima e
la fine-1-esima) secondo il criterio di ordinamento che viene considerato.
A questo scopo eseguiamo un ciclo di istruzioni mentre sono verificate ENTRAMBE le due seguenti condizioni:
(1) il contatore i1 deve essere minore di separa,
(2) il contatore i2 deve essere minore di fine */
while( ( i1 < separa ) && ( i2 < fine ) ) {
/* Eseguiamo il confronto tra la i1-esima riga di elenco e la i2-esima riga limitando il confronto a partire
dal carattere iniz_chiave-esimo per un numero di caratteri uguale a lung_chiave.
Se (limitatamente ai caratteri confrontati) la i1-esima riga viene prima della i2-esima o sono uguali ... */
if( strncmp( &elenco[i1][iniz_chiave] ,
&elenco[i2][iniz_chiave] , lung_chiave ) != 0 ) {

vetord[i] = i1; /* ... allora poniamo l'i-esimo elemento del vettore vetord uguale ad i1 */

i1++; /* Incrementiamo di 1 il valore del contatore i1 */
}

else { /* Altrimenti ... */

vetord[i] = i2; /* ... poniamo l'i-esimo elemento del vettore vetord uguale ad i2 */

i2++; /* Incrementiamo di 1 il valore del contatore i2 */
}

i++; /* Incrementiamo di 1 il valore del contatore i */
}
/* Attenzione!!! Mancano le definizioni di alcuni elementi del vettore vetord!!!
Infatti, mancano separa-1-i1 definizioni (se siamo usciti dal ciclo precedente perche' i2 = fine) oppure mancano fine-1-i2
definizioni (se siamo usciti dal ciclo precedente perche' i1 = separa). */

for(;i1<separa;i1++) { /* Di conseguenza, eseguiamo un ciclo di istruzioni sul contatore i1 che parte dal valore che esso ha
attualmente fino a separa-1 */

vetord[i] = i1; /* Poniamo l'i-esimo elemento del vettore vetord uguale ad i1 */

i++; /* Incrementiamo di 1 il valore del contatore i */
}
/* Adesso eseguiamo un ciclo di istruzioni sul contatore i2 che parte dal valore che esso ha attualmente fino a fine-1 */
for(;i2<fine;i2++) {

vetord[i] = i2; /* Poniamo l'i-esimo elemento del vettore vetord uguale ad i2 */

i++; /* Incrementiamo di 1 il valore del contatore i */
}
/* A questo punto eseguiamo effettivamente lo scambio delle righe dell'elenco (comprese tra la inizio-esima e la fine-1-esima)
secondo il criterio di ordinamento che viene considerato. A questo scopo eseguiamo un ciclo di istruzioni mentre il
contatore i va da inizio a fine-1 */
for(i=inizio;i<fine;i++) {

if(i != vetord[i]) { /* Eseguiamo le istruzioni seguenti solo se e' verificata la condizione che i sia diverso da vetord[i] (altrimenti
non c'e' bisogno di fare alcunche') */

scambia_righe(elenco, i, vetord[i]); /* Eseguiamo lo scambio tra la i-esima riga e la vetord[i]-iesima riga dell'elenco facendo appello alla
routine scambia_righe */
/* Attenzione!!! Siccome abbiamo cambiato di posto un paio di righe dobbiamo aggiornare il vettore vetord!!! */

for(j=i+1; j<fine; j++) { /* Eseguiamo il seguente ciclo di istruzioni mentre il contatore j va da i+1 a fine-1 */

if(vetord[j] == i) { /* Se il j-esimo elemento di vetord e' proprio uguale ad i ... */

vetord[j] = vetord[i]; /* ... poniamo il j-esimo elemento di vetord uguale all'i-esimo elemento di vetord ... */

break; /* ... e, con un'istruzione break, usciamo dal ciclo che utilizza j come contatore */
}
}
vetord[i] = i; /* Poniamo l'i-esimo elemento di vetord uguale a i */
}
}
}

void ordina(elenco, ncoppie, iniz_chiave, iniz_chiave2, lung_chiave)
char elenco[][3*LUNGMAX];
int ncoppie, iniz_chiave, iniz_chiave2, lung_chiave;
{
int pot2, inizio, separa, fine;

pot2 = 1; /* Inizializziamo la variabile pot2 uguale ad 1 */
/* Continuiamo ad eseguire il seguente ciclo di istruzioni mentre e' verificata l'ipotesi che pot2 sia minore di ncoppie */
while(pot2 < ncoppie) {

inizio = 0; /* Inizializziamo la variabile inizio uguale a 0 ... */

separa = pot2; /* ... e la variabile separa uguale a pot2 */
/* Le righe che sono comprese tra la inizio-esima e la separa-1-esima sono da considerarsi gia' ordinate dalle
operazioni precedentemente effettuate durante l'esecuzione dell'algoritmo;
quindi, continuiamo ad eseguire un ciclo di istruzioni mentre e' verificata l'ipotesi che separa sia minore di ncoppie */
while( separa < ncoppie ) {

fine = separa + pot2; /* Poniamo la variabile fine uguale a separa+pot2 */
/* Non ha senso cercare di ordinare le righe successive a ncoppie (perche' l'elenco delle coppie e' costituito
da al piu' ncoppie righe);*/

if(fine > ncoppie) /*quindi se fine e' maggiore di ncoppie la poniamo uguale ad ncoppie */
fine = ncoppie;
/* A questo punto dobbiamo ordinare il blocco di righe dell'elenco compreso tra la inizio-esima riga e la
fine-1-esima, sapendo che i due sottoblocchi compresi (nel primo caso) tra la inizio-esima riga e la separa-1-esima e
(nel secondo caso) tra la separa-esima riga e la fine-1-esima sono da considerarsi gia' ordinati.
Eseguiamo l'ordinamento dell'unione dei due sottoblocchi facendo appello alla routine incastra_ordinato */
incastra_ordinato(elenco, inizio, separa, fine, iniz_chiave, iniz_chiave2, lung_chiave);

inizio = fine; /* Ridefiniamo la variabile inizio uguale a fine ... */

separa = inizio + pot2; /* ... e la variabile separa uguale a inizio + pot2 */
}

pot2 *= 2; /* Raddoppiamo il valore della variabile pot2 */
}
}

void scambia_righe(elenco, riga1, riga2)
char elenco[][3*LUNGMAX];
int riga1, riga2;
{
int i;
char tmp;
/* Eseguiamo il seguente ciclo di istruzioni mentre il contatore i va da 0 a 3*LUNGMAX (cioe' consideriamo tutte le colonne
della matrice elenco) */
for(i=0;i<3*LUNGMAX;i++) {

tmp = elenco[riga1][i]; /* Poniamo tmp uguale all'i-esimo elemento di colonna della riga1-esima riga della matrice elenco */
/* Poniamo l'i-esimo elemento di colonna della riga1-esima riga della matrice elenco uguale all'i-esimo elemento di colonna
della riga2-esima riga della stessa matrice elenco */
elenco[riga1][i] = elenco[riga2][i];

elenco[riga2][i] = tmp; /* Poniamo l'i-esimo elemento di colonna della riga2-esima riga della matrice elenco uguale a tmp */
}
}

[oregon]

Non aprire continuamente thread su questo problema ... mi hai inviato un PM ... leggi la risposta...