[Linguaggio C] Thread Richieste Aiuto

[~marco]

Ciao,

ho pensato di creare questo topic per chi come me, vuoi per lavoro vuoi per studio, si trova ad affrontare le spigolosita' del C

Volendo, potrebbe essere un punto di ritrovo per chi ha bisogno di aiuto ed assistenza dove chi può da il suo apporto costruttivo e facciamo in modo di non sovraccaricare in maniera eccessiva i server del forum, riunendoci qui'

problema del giorno.

/* Prendere in input 3 valori, che rappresentano i 
** coefficienti di un’equazione di secondo grado, e 
** stampare i risultati dell’equazione.  */


#include <stdio.h>
#include <math.h>

int main()

{
int a, b, c, e, b1, d, sub, x, x1;
printf("immetti a: \n");
scanf("%d", &a);
printf("immetti b: \n");
scanf("%d", &;
printf("immetti c: \n");
scanf("%d", &c);

b1=pow(b,2);
e=4*a*c;
sub=b1-e;
d=sqrt(sub);

if((e>b1)||(a==0)) goto L1;

switch(x){

case 1:
x=(-b+d)/(2*a);
printf("il risultato e' %d:", x);
x1=(-b-d)/(2*a);
printf("il risultato e' %d:", x1);
break;
 }	


L1: printf("Valori non validi\n");
return 0;

 }

Praticamente, letti i tre interi, il programma entra sempre in L1 dandomi come output la scritta "Valori non validi" non eseguendo quindi alcuna computazione della x.

Ancor prima che qualcuno metta qui' la sua soluzione, vorrei sapere se secondo voi il programma e' logicamente corretto e in caso contrario, in quale/i punto/i lo rivedreste.

Grazie,

[mez]

io partirei con il sostituire il goto con:

if((e>b1) || (a==0)){

printf("Valori non validi\n");

return 0;

}

[BlackICE]

Sta cosa mi piace! Si sente solo parlare di Java, Eclipse, e varie...

Ritorniamo al buon vecchio C

/* Prendere in input 3 valori, che rappresentano i 
** coefficienti di un’equazione di secondo grado, e 
** stampare i risultati dell’equazione.  */


#include <stdio.h>
#include <math.h>

int main(){
   int a, b, c, e, b1, d, sub, x, x1; <---------| E' buona norma inizializzare le variabili

   printf("immetti a: \n"); <-------------------- Qui farei un ciclo in cui controllo subito 
   scanf("%d", &a);                                che 'a' non sia zero
   printf("immetti b: \n");
   scanf("%d", &;
   printf("immetti c: \n");
   scanf("%d", &c);

   b1=pow(b,2); <----------------------------------| Qui mi sa che c'e' un bel problema di fondo:
   e=4*a*c;                                           | pow ritorna valori float o double. Le tue
   sub=b1-e;                                         | variabili son dichiarate int, perdi informazioni
   d=sqrt(sub);

   if((e>b1)||(a==0)) goto L1; <--------------| Il controllo di a lo facciamo sopra. Quello di 'e'
                                                          | lo puoi fare dopo aver calcolato e. E ti prego:
   switch(x){                                         | leva i 'goto'! Non si dovrebbero quasi mai
   case 1:                                             | usare (anche se in effetti il posto dove e'
       x=(-b+d)/(2*a);                              | accettabile usarlo sono proprio per gestire
       printf("il risultato e' %d:", x);           | errori
       x1=(-b-d)/(2*a);
       printf("il risultato e' %d:", x1);
       break;
   }    <-----------------------------------------------| E sto switch?! Non riesco a capire a che
                                                          | server. E infatti non fa niente di che.
   L1: printf("Valori non validi\n");            | Il calcolo di x lo puoi fuori senza lo switch.
   return 0;

}

1) Ti scrive sempre "Valori non validi" perche' dopo lo switch quella printf la esegue sempre e comunque. Un goto non vuol dire che esegui il codice solo se chiami 'goto L1'. Quel codice viene eseguito anche quando lo incontra riga dopo riga.

2) non ti calcola i risultati di x perche' quello swithc che hai messo non server, anzi. Nel tuo caso x non e' uguale a 1 e quindi non entrerai mai nel case (non hai inizializzato x quindi avra' un valora casuale).

Vai, prova a correggerti

[Cpu86]

Possibile soluzione. Premetto che sono bruttissimi i return usati così nel main, ma ero di corsa:)

1 #include <stdio.h>

2 #include <math.h>

3

4 int main(int argc, char **argv){

5

6 float a,b,c,delta;

7

8 //ax^2+bx+c

9 printf("inserisci a: ");

10 scanf("%f",&a);

11 printf("inserisci b: ");

12 scanf("%f",&;

13 printf("inserisci c: ");

14 scanf("%f",&c);

15

16 //solving

17 if(a==0 && b==0 && c==0){

18 printf("identita'\n");

19 return 0;

20 }

21 if(a == 0){

22 if(b != 0)

23 printf("x = %f\n",-(c/:ciao:);

24 else

25 printf("impossibile\n");

26 return 0;

27 }

28 if(b == 0){

29 if(a <0 && c>= 0)

30 printf("x = +/-%f\n",sqrtf(-c/a));

31 else if(a>0 && c<0)

32 printf("x = +/-%f\n",sqrtf(-c/a));

33 else

34 printf("l'eq non ha soluzioni reali!\n");

35 return 0;

36 }

37 if(c == 0){

38 printf("x1 = 0, x2 = %f\n",-(b/a));

39 return 0;

40 }

41 else{

42 delta = (b*b-4*a*c);

43 if(delta < 0)

44 printf("non ammette soluzioni reali\n");

45

46 else

47 printf("x1 = %f, x2= %f\n",((-b+sqrtf(delta))/(2*a)),((-b-sqrtf(delta))/(2*a)));

48 return 0;

49 }

50

51

52 return 0;

53 }

/[code]

La prossima volta sbattici un po' la testa prima di chiedere aiuto:)

[~marco]

Grazie mille per la tua soluzione, ma preferisco non leggermela.

Spero capirai il perché

In teoria, al corso, il char** ancora non l'han spiegato.

sarebbe come uccidere una mosca con una 44pollici.

ps Ci sto ancora sbattendo la testa!

@BlackICE:

mi sono soffermato su ciò che hai scritto e...

a- la funzione pow ritorna al chiamante un double?

io credevo che facesse una "semplice operazione aritmetica" senza andare ad infastidire i tipi o comunque a interagire con essi.

b- il controllo per a==0 anziché "annidarlo" sotto, l'ho spostato sopra al momento della richiesta dei valori da tastiera, buono come consiglio così evita di entrare a fare operazioni inutili, nel caso in cui la condizione fosse verificata.

c- ti do ragione anche per quanta riguarda il costrutto goto.

il problema e' che sto lentamente migrando dall'assembler, dimenticando che l'astrazione offerta dal C e' un attimo differente da quella offerta dal suddetto.

Ovviamente, ho annidato la printf in un if.

ps nel linguaggio C, il costrutto 'goto', falsa in qualche modo il flusso del programma?

Lo chiedo perché più docenti mi hanno sconsigliato vivamente l'utilizzo di tale costrutto, sebbene i motivi mi sono ancora un pò misteriosi.

d- In effetti lo switch non ha senso in questo programma, ma "in teoria" dovrei implementare questo codice tramite il costrutto switch, anche se... per ora voglio prima vedere se esegue correttamente le operazioni senza di esso.

Metto quì presto il codice aggiornato, per ora il programma compila ma da output non corretti, per ora grazie delle dritte.

[Cpu86]

In quanto al goto, tutti storcono il naso a sentirlo nominare. Io non riesco a capire il perchè, alla fine un goto non è altro che un jump incondizionato. Comunque è brutto da vedersi in quando complica la vita a chi cerca di interpretare un sorgente.

Consiglio: scordati i goto e i break usali solo negli switch.

Per il char **, adesso non farci caso, non credo che vi facciano vedere il main dichiarato in quel modo(un vero peccato). In breve:

il main dichiarato in quel modo ha due parametri:

- intero che indica quanti parametri sono stati passati al prog al momento del lancio, il numero sarà sempre >= 1, in quanto il primo parametro è il nome dello stesso programma.

- un puntatore a un'array di punattori, che puntano a delle stringhe, le quali non sono altro che i parametri passati al prog.

Esempio:

ho un prog che si chiama stampa e che accetta un parametro stringa che stamperà a schermo. Lo lancio da terminale nel seguente modo:

./stampa ciao

in questo caso argc sarà = a 2 e l'array conterrà i valori:

argv[0] = "stampa"------------>questo è sempre così!!!! il primo elemento è il nome del programma stesso

argv[1] = "ciao"

I puntatori te li faranno vedere più avanti(spero), comunque spero di essere stato chiaro nella breve spiegazione

[redvex]

i goto sono antipatici, scomodi da debbugare e incasinano non poco il codice... il bravo programmatore usa funzioni, puntatori, condizioni, ma non salti nel buio e label perchè`di fatto alterano il flusso in modo arbitrario e senza grande utilità.

[Ren@to]

Il goto conduce a quello che si chiama "spaghetti code"...cioè grande caos, codica incasinato, quindi non va assolutamente usato

Il professore di un mio amico diceva che il goto è da falliti della programmazione

ciao

[Cpu86]

Il goto conduce a quello che si chiama "spaghetti code"...cioè grande caos, codica incasinato, quindi non va assolutamente usato

Il professore di un mio amico diceva che il goto è da falliti della programmazione

ciao

Sono d'accordo ma spiegato così sembra chissà che cosa, in realtà il goto è codificato in ASM con un jump incondizionato(ora non mi ricordo il codice memonico).

[Ren@to]

Sono d'accordo ma spiegato così sembra chissà che cosa, in realtà il goto è codificato in ASM con un jump incondizionato(ora non mi ricordo il codice memonico).

Certo, chiaramente mi riferisco a liguaggi di più alto livello, nel topic si parla di C.

ciao

[BlackICE]

Il problema del goto nella programmazione è che se se ne fa un uso eccessivo rende il codice di difficile lettura (come nel caso di abuso delle macro) e di difficile debugging. E' un costrutto pericoloso per rende il codice a "spaghetti".

Inoltre, mole persone lo interpretano come un blocco di codice a se stante ma così non è. Infatti ~marco ha fatto questo errore: pensava che il codice sotto la label in fondo al suo main venisse eseguito solo quando chiama il goto. Mentre nell'esecuzione del codice se un prog incontra una label eseguirà sempre le istruzioni sotto.

In linea di massima è accettato di usare i goto per la gestione degli errori. Esempio generale:

int myfunc(int a, int {
   /* Dichiara e inizializza variabili locali */
   int rc = 0;

   /* Fai qualcosa e controlla gli errori */
   rc = do_some_code();
   if (rc == ERR)
       goto MANAGE_ERR_AND_RETURN;

MANAGE_ERR_AND_RETURN:
   /* Esegui le operazioni di "pulizia" (free, reset di variabili, ecc) e ritorna */
   do_some_cleaning;
   return rc;
}

Spero di essermi spiegato abbastanza bene.

[slayer'89]

Mmm...a me servirebbe una bella spiegazione sul processo del multi-threading

[Cpu86]

Mmm...a me servirebbe una bella spiegazione sul processo del multi-threading

Potresti iniziare a vedere qualcosa sulla programmazione parallela(pid, fork, exit).

[slayer'89]

Mmm...qualche bella fonte?

[Cpu86]

Mmm...qualche bella fonte?

Cerca in google programmazione parallela.

[didoal84]

io partirei con il sostituire il goto.

Parole sante!!! il goto è unodi quei costrutti che quando ti insegnano a programmare ti dicono di non usare praticmanete mai perchè è deprecato.

All'università ci sono addirittura dei professori che ti stracciano l'elaborato e ti dicono di ripassare al prossimo appello se lo usi!!!

[BlackICE]

Mmm...a me servirebbe una bella spiegazione sul processo del multi-threading

In ordine:

1) cerca su google informazioni su IPC... sta per Inter-Process Communication.

2) Cerca su google informazioni su Concurrent programming (programmazione concorrente).

3) Cerca su google informazioni su multi-threaded programming

4) Cerca su google informazioni su parallel programming (attenzione che ti rifileranno discorsi su librerie parallele tipo MPI, OpenMP, HP Fortran che non penso ti possano essere utili. Pero' i concetti di concorrenza, accesso ai dati esclusivo, race-conditions, dead-locks, sincronizzazione, tipi di comunicazione bloccanti/non-bloccanti e sincrone/asincrone sono + o - gli stessi)

See you.

[slayer'89]

Grazie...

una curiosità,per fare apparire immagini bidimensionali sullo schermo suppongo che non si utilizzi la printf per la visualizzazione di una stringa no? :P

Devo usare (e quindi studiare) qualche libreria grafica?

[Cpu86]

Grazie...

una curiosità,per fare apparire immagini bidimensionali sullo schermo suppongo che non si utilizzi la printf per la visualizzazione di una stringa no?

Devo usare (e quindi studiare) qualche libreria grafica?

La cosa non è così semplice.

Hai varie possibilità:

- librerie GTK+, con cui è stato fatto Gnome di linux

- librerie QT

- chiamate a X11(non ho idea di come si faccia)

- studiarti il framework Cocoa

[zzi_miei]

Mmm...a me servirebbe una bella spiegazione sul processo del multi-threading

qui c'e' un buon libro (scaricabile) http://www.advancedlinuxprogramming.com, in particolare il cap. 4 parla della programmazione con i threads.

[slayer'89]

Credo che proverò con il GTK+ una volta terminato il manuale dei Deitel Bros

[Agathos]

Ma...siccome sono nuovo dei Mac...

come faccio a compilare un programma in C con xcode?

[stainer]

Dato un intero reale positivo "a" in input, e la sequenza di numeri reali:

X0 = 1, X1=1/2*(X0+a/X0),...,Xi+1=1/2*(Xi+a/Xi) per i=0,1,2,...

si dimostra matematicamente che per valori grandi di i, la sequenza approssima la radice quadrata di "a" (deriva dal metodo di Newton-Raphson).

Scrivete un programma che legga "a" in input ed "n" numero di iterazioni e utilizzi questo metodo per il calcolo approssimato della radice quadrata. Non va, ovviamente, utilizzata la funzione sqrt della libreria standard. A ogni esecuzione del ciclo stampare il numero di iterazione, ed i valori di X1 (che converge alla radice quadrata di "a"). Utilizzare l'istruzione while.

INPUT: float "a" ed intero "n" OUTPUT: sequenza di coppie (iterazione):(valore di X1)\n dove (iterazione) è un intero e (valore di X1) è un float es: dato a=4 ed n=3 l'output sarà: 1:1\n 2:2.5\n 3:2.05\n

[stainer]

Ma...siccome sono nuovo dei Mac...

come faccio a compilare un programma in C con xcode?

Ciao, guarda con Xcode non sono mai riuscito a compilare, ti conviene farlo da terminale

[Agathos]

Riuscite a trovare l'errore che ho fatto?

# include <stdio.h>

int main()
{
int integer1;
int integer2;
int somma;
int prodotto;
int differenza;
int quoziente;
int resto;

printf ("Immetti due numeri interi e io ti dirò qual'è la loro somma,il loro prodotto,la loro differenza,il loro quoziente e il loro resto!\n");

printf ("Immetti il primo numero:\n");
scanf ("%d" , &integer1);

printf ("Immetti il secondo numero:\n");
scanf ("%d" , integer2);

somma = integer1 + integer2;
printf ("La somma è %d" , somma);

prodotto = integer1 * integer2;
printf ("Il prodotto è %d" , prodotto); 

differenza = integer1 - integer2;
printf ("La differenza è %d" , differenza);

quoziente = integer1 / integer2;
printf ("Il quoziente è %d" , quoziente);

resto = integer1 % integer2;
printf ("Il resto è %d" , resto);

return 0;
}

[Cpu86]

Riuscite a trovare l'errore che ho fatto?

# include <stdio.h>

int main()
{
int integer1;
int integer2;
int somma;
int prodotto;
int differenza;
int quoziente;
int resto;

printf ("Immetti due numeri interi e io ti dirò qual'è la loro somma,il loro prodotto,la loro differenza,il loro quoziente e il loro resto!\n");

printf ("Immetti il primo numero:\n");
scanf ("%d" , &integer1);

printf ("Immetti il secondo numero:\n");
scanf ("%d" , integer2);

somma = integer1 + integer2;
printf ("La somma è %d" , somma);

prodotto = integer1 * integer2;
printf ("Il prodotto è %d" , prodotto); 

differenza = integer1 - integer2;
printf ("La differenza è %d" , differenza);

quoziente = integer1 / integer2;
printf ("Il quoziente è %d" , quoziente);

resto = integer1 % integer2;
printf ("Il resto è %d" , resto);

return 0;
}

printf ("Immetti il secondo numero:\n");

scanf ("%d" , integer2);

ci va una &

printf ("Immetti il secondo numero:\n");

scanf ("%d" , &integer2);

[Agathos]

Come mai appare il punto di domanda alla fine?

Immetti due numeri interi e io ti dir? qual'? la loro somma,il loro prodotto,la loro differenza,il loro quoziente e il loro resto!
Immetti il primo numero:
12
Immetti il secondo numero:
3
La somma ? 15
Il prodotto ? 36
La differenza ? 9
Il quoziente ? 4
Il resto ? 0

Non dovrebbe apparire la somma è...

il prodotto è...

ecc ecc?

[Cpu86]

la è appartiene all'ASCII esteso. Se il terminale non è settato per supportare l'ASCII esteso non vedrai la è. Ora non mi ricordo come fare e non posso neanche provare perchè ho il mac in assistenza e su linux va tranquillamente.

[Agathos]

E per quanto concerne il punto di domanda?Sulla printf non c'è nulla che lo ricordi nemmeno lontanamente...

[Cpu86]

E per quanto concerne il punto di domanda?Sulla printf non c'è nulla che lo ricordi nemmeno lontanamente...

La è viene codificata in un determinato modo, essendo che il terminale non supporta l'ASCII esteso, quando riceve il valore della è lo riconosce come quello del ?, l'unico è mettere la è come e'