Array...una piccola problema

[Sk_Anonymous]

Ciao raga...volevo kiedervi se è possibile associare all'elemento a[0] di un array un tipo int e un tipo char...e visualizzarli entrambi???
mi spiego meglio:

a[0] = char ciao[20];
a[0] = int hello;

in poche parole dev far corrispondere all'elemento char ciao[20] il corrispettivo intero hello...cm posso fare????in qst modo ho visto ke mi visualizza solo int hello...potreste spiegarmi meglio...?GRAZIE e CIAO!!!

[wedge]

mi sa che devi crearti una structure
http://en.wikipedia.org/wiki/C%2B%2B_st ... nd_C.2B.2B

[Sk_Anonymous]

lo so e infatti l'ho fatto ma vedi il problema è che con una struttura nn mi effettua l'ordinamento poichè dichiao un array di tipo struct e cn la funzione insertionsort nn è compatibile...allora cm osso fare????...se ti faccio vedere il codicemi daresti un okkiata e magari dv è necessario qualke consiglio o correzione???...grazie...


GUARDA UN PO':

#include
#include
#include

/****************************/
/* definizione di struttura */
/****************************/

struct database {

char cognomi[20];
int matricole;
int voti;

};


/****************************************/
/* dichiarazione di funzione insertsort */
/****************************************/

void insertsort(int *,
int);


/***********************************/
/* definizione della funzione main */
/***********************************/

int main()
{
FILE *file_database; /* lavoro: puntatore al file di input */

struct database d[3], *p; /* input: struttura dati */


int matricola_1, /* output: matricole */
matricola_2,
matricola_3;

char cognome_1[20], /* output: cognomi */
cognome_2[20],
cognome_3[20];

int voto_1, /* output: voti */
voto_2,
voto_3;

int n = 4, i, m[4], v[3]; /* input: numero degli elementi array inizializzati */




/* aprire i file */
file_database = fopen("database.txt", "r");


/* acquisire i 10 cognomi con rispettive matricole e voti */
fscanf(file_database, "\%s %d %d", cognome_1, &matricola_1, &voto_1);
fscanf(file_database, "\%s %d %d", cognome_2, &matricola_2, &voto_2);
fscanf(file_database, "\%s %d %d", cognome_3, &matricola_3, &voto_3);



/* assegnare ai campi delle strutture dichiarate i valori di fscanf */
strcpy(d[0].cognomi, cognome_1);
d[0].matricole = matricola_1;
d[0].voti = voto_1;

strcpy(d[1].cognomi, cognome_2);
d[1].matricole = matricola_2;
d[1].voti = voto_2;

strcpy(d[2].cognomi, cognome_3);
d[2].matricole = matricola_3;
d[2].voti = voto_3;


/*ciclo for per visualizzare gli elementi della struct */
for(p = d; p < d+3; ++p)
printf("%s %d %d\n", p->cognomi, p->matricole, p->voti);

/* associa a m[3] i valori matrici e gli indizzi voti */
m[0] = cognome_1;
m[1] = cognome_2;
m[2] = cognome_3;

v[0] = voto_1;
v[1] = voto_2;
v[2] = voto_3;


for(i = 0; i < n; ++i)
fscanf(file_database, "\%s %d %d", m, p->matricole, p->voti);

insertsort(m, n);

for(i = 0; i < n; ++i)
printf("\n%s\n", m, p->matricole, p->voti);


/* invocazione di funzione: ordinamento per nome */
/* insertsort(d, n);

for(p = d; p < d+3; ++p)
printf("\nArray ordinato: %s %d %d\n", p->cognomi, p->matricole, p->voti);

*/
return(0);

}

/* definizione di funzione: insertsort */
void insertsort(int a[],
int n)
{
int valore_acquisito,
i,
j;

for (i = 1;
(i < n);
i++)
{
for (valore_acquisito = a, j = i - 1;
((j >= 0) && (a[j] > valore_acquisito));
j--)
a[j + 1] = a[j];

if (j+ 1 != i)
a[j + 1] = valore_acquisito;
}
}

[david_e1]

Ti chiederei se possibile di scrivere il codice dentro l'ambiente "code" in maniera che risulti più leggibile: veramente si fa una fatica non indifferente a capire il tuo codice...

Per il resto la soluzione più semplice, ma meno elegante, in questo caso è semplicemente riscrivere l'insertsort in modo che quando scambi di posto due elementi di tipo int scambi anche quelli associati di tipo char: in questo modo questi rimangono sempre nella stessa posizione relativa.

Altrimenti ci sono soluzioni un po' più complicate come il creare un array di reindirizzamento (stile FORTRAN) oppure si potrebbe fare un insertsort per riordinare le struct, ma viene una cosa un po' tecnica (i.e. una cosa molto complicata), perché bisogna usare i puntatori a void e i puntatori a funzione...

[Sk_Anonymous]

è solo da modificare allora linsertoort????...ma ho provato e niente...tu cm faresti???

io provo a scriverlo in modo +leggibile ma nn lo fa e nn so xkè...mi dispiace!!! :

void insertsort(int a[],
int n)
{
int valore_acquisito,
i,
j;

for (i = 1;
(i < n);
i++)
{
for (valore_acquisito = a, j = i - 1;
((j >= 0) && (a[j] > valore_acquisito));
j--)
a[j + 1] = a[j];

if (j+ 1 != i)
a[j + 1] = valore_acquisito;
}

}

...allora spetto una tua risp..grazie e Ciao!!!!

[wedge]

"giocala88":
io provo a scriverlo in modo +leggibile ma nn lo fa e nn so xkè...mi dispiace!!! :

mi aspettavo che uno studente di informatica riuscisse a fare questo:

void insertsort(int a[], 
                      int n) 
{ 
     int valore_acquisito, 
     i, 
     j;
  
   for (i = 1; 
        (i < n); 
         i++) 
   {
        for (valore_acquisito = a[i], j = i - 1; 
        ((j >= 0) && (a[j] > valore_acquisito)); 
         j--)
            a[j + 1] = a[j]; 
       
         if (j+ 1 != i) 
         a[j + 1] = valore_acquisito; 
     }

}

[Sk_Anonymous]

wedge nn riuscivo a scriverlo qua...lo so cosa intendi x leggibile...se nn sapevo fare qst ero proprio negato del ttt...cmq hai risolto xcaso il mio problema????...fammi sapere...anke se dubito ke si potesse fare....GRAZIE ancora ciao!!!

[wedge]

onestamente al volo non so come fare, è una cosa fuori dal mio campo e prima di usare del tempo per risolvere i tuoi esercizi per casa (e in questo forum ne stai mettendo parecchi ) ho altro da fare.
mi spiace

[david_e1]

Guarda il codice C per esteso non te lo posto, comunque la soluzione più semplice è che nell'insertsort ti fai passare sia il vettore degli int che quello delle stringhe:

void insertsort(int a[],char b[][],int n)

poi tutti i sort funzionano scambiando i valori all'interno di a[]. Tu devi fare la stessa cosa, in maniera coerente, scambiando anche i valori di b[][]. In pseudo-codice:

switch(a[i],a[j]);

diventa (occhio che questo è pseudo-codice: queste istruzioni ovviamente non compilano scritte così):

switch(a[i],a[j]);
switch(b[i][],b[j][]);

la cosa più semplice da fare è implementare una funzione di switch per fare questo scambio partendo da a[] da b[][] e dagli indici i e j.

Altrimenti puoi fare un vettore v[] di indici tale per cui v[3], ad esempio, ti dia l'indice dell'elemento che nell'ordinamento viene per 3zo in modo che (anche questo in pseudo-codice):

for(int i=0;i<n;++i) {
    print(a[v[i]]);
    print(b[v[i]]);
}

dia i valori ordinati.

Per scrivere il codice ordinato basta incapsularlo fra [@code@] e [@/code@] senza le '@'.