Newsgroup: it.comp.lang.c
Titolo: Chi si vuole divertire? Programmi C

Grazie e Al prossimo!

 Grazie e Al prossimo!
/*Quando lo lanci inserisci i numeri della sequenza e schiacci RETURN*/
/*la fine sequenza e' zero, come dicevi tu.*/
 #include<stdio.h>
max(int *p,int *s,int *r,int i)
{
 int j; 
 for (j=0;j<(i-1);j++)
      if ( *(p+j) >= *(s+j)) 
                      *(r+j)=*(p+j);
                 else *(r+j)=*(s+j);
}
 
 
 main()
 {
    int prima[20];               /*ho messo 20, ma pui mettere quello che vuoi*/
    int seconda[20];
    int risult[20];
 int inte,i,j;
    i=0;
    printf("---Inserire la prima sequenza--------\n");
      do{
         scanf("%u",&inte);
         prima[i]=inte;
         i=i+1;
      }while (inte != 0);
    printf("---Inserire la seconda sequenza-------\n");
 
    for (j=0;j<(i-1);j++){
           scanf("%u",&inte);
           seconda[j]=inte;
           } 
   max(prima,seconda,risult,i);
 
   printf("Sequenza massima:\n");   
   for (j=0;j<(i-1);j++)
             printf("%u ",risult[j]);
 
   printf("\n");         
 
 }
Eccoti il programma che chiedi!!!!!!!
Fabio.

richiesti.
Mica tanto, visto che serve per un esame con quel prototipo di main() mi sa
che si becca subito un insufficenza. main() ha due soli prototipi validi :
int main(void)
int main(int argc, char *argv[])
-- 
Warning!
Don't send any mail for me at my from: or replayto: addresses ;
I just kill the mail over there without reading!

Grazie e Al prossimo!
Prego!  Soprattutto, mi raccomando, _chiedi_ (su
questo gruppo, non nella mia mail, grazie) chiarimenti
su qualsiasi cosa non ti sia perfettamente chiara in
questa soluzione, perche`, per imparare, bisogna
capire i perche` e i percome, non solo dare una data
soluzione "a pappagallo"...
Alex

Alessandro Guarguaglini (
gua...@usa.net
) wrote:
: On Thu, 18 Jun 1998 22:21:31 +0200, Alberto Speranzon wrote:
: >Non ho provato il programma che comunque credo risponda ai requisiti
: >richiesti.
: Mica tanto, visto che serve per un esame con quel prototipo di main() mi sa
: che si becca subito un insufficenza. main() ha due soli prototipi validi :
: int main(void)
: int main(int argc, char *argv[])
Puoi chiarire, per favore ?
void main( void )
compila perfettamente sul gcc, anche se genera un warning...
Inoltre l'insufficienza se la becchera' per l'uso dei commenti C++
in un listato C, oppure per l'uso di 'then' dopo un if (quest'ultimo
non permette neanche di compilare ;).
Tra l'altro il punto d) non e' sviluppato.
Anche un
#include <stdio.h>
non guasterebbe...
...della serie meglio farseli da soli <g>
Ciao ciao
Andrea
-- 
"...Unix, MS-DOS, and Windows NT (also known as the Good, the Bad, and 
 the Ugly)."
(by Matt Welsh)

Alex Martelli (
al...@magenta.com
) wrote:
[ snip ]
: typedef struct vector_s {
:     int * data;
:     int length;
:     int allocated;
: } *vector_t;
: vector_t make_vector()
: {
:     vector_t result = malloc(sizeof(*vector_t));
      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
:     result->data = malloc(10*sizeof(int));
:     result->length = 0;
:     result->allocated = 10;
:     return result;
: }
Scusa, ma a te funziona "*vector_t" per allocare la struct ?
A me pare sbagliato, e in effetti il mio compilatore (pgcc 1.0.3)
mi da' un errore (parse error).
La chiamata corretta e' :
vector_t result = (vector_t)malloc(sizeof(struct vector_s));
fermo restando che devi anche definire la struct esplicitamente, 
ossia:
struct vector_s {
    int *data;
    int length;
    int allocated;
};
typedef struct vector_s * vector_t;


Andrea
Ciao.


Alessandro Guarguaglini (
gua...@usa.net
) wrote:
: On 19 Jun 1998 21:25:44 +0200, Andrea Foco wrote:
: >
: >: int main(void)
: >: int main(int argc, char *argv[])
: >
: >Puoi chiarire, per favore ?
: Chiarire?!? Cosa c'e' di non chiaro?? ;-))
: >void main( void )
: >
: >compila perfettamente sul gcc, anche se genera un warning...
: Appunto, il gcc e' abbastanza intelligente da fartelo notare, void main
: (void) non e' standard, perche' la funzione main() deve ritornare un valore. 
Cosa intendi con deve ? Che e' specificato nello Standard C ?
(Strano perche' se compilo con '-ansi -pedantic' tutto funge...)


#include "stdio.h"
#include "malloc.h"
#define MAX 50
int *crea_vettore_max(int quanti, int *v1, int *v2){
	static int *nvett;
	int i;
	nvett=(int *) malloc(quanti*sizeof(int));
	for(i=0; i< quanti ; i++){
		if(v1[i]>v2[i])
			nvett[i]=v1[i];
		else
			nvett[i]=v2[i];
	}
	return(nvett);
}
int main(void){
	int vettore[MAX];
	int vettore2[MAX];
	int *vettore_max;
	int i;	
	int i2;
	i=-1;
	i2=-1;
	/*  ciclo di lettura punto a */
	printf("Vettore a:\n");
	do{
		i=i+1;
		scanf("%d",&vettore[i]);
	}while((vettore[i]!=0) && ((i+1)<MAX));
 
	/* secondo ciclo di lettura punto b */
	printf("\nVettore b:\n");
	do{
		i2=i2+1;
		scanf("%d",&vettore2[i2]);
	}while( i2 < i-1 );
 
	/* crea vettore, punto c */
	vettore_max=crea_vettore_max(i,vettore,vettore2);
 
	/* stampa a terminale, punto d */
	printf("\nVettore max: ");
	for(i2=0; i2<i; i2++){
		printf("%d ",vettore_max[i2]);
	}
	printf("\n");
	return(1);
}

...della serie meglio farseli da soli <g>
Decisamente (certo piu` istruttivo), ma non usando con
leggerezza inutili costrutti non standard.
Alex

Cix (C...@cix.cix) wrote:
Carino !
Pero'...
[ snip ]
: 	/*  ciclo di lettura punto a */
: 	printf("Vettore a:\n");
: 	do{
: 		i=i+1;
: 		scanf("%d",&vettore[i]);
: 	}while((vettore[i]!=0) && ((i+1)<MAX));
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Se qui esci perche' ( i == MAX-1 ) con (vettore[MAX-1] != 0)
: 		
: 	/* secondo ciclo di lettura punto b */
: 	printf("\nVettore b:\n");
: 	do{
: 		i2=i2+1;
: 		scanf("%d",&vettore2[i2]);
: 	}while( i2 < i-1 );
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...qui 'perdi' l'ultimo elemento !
[ snip ]


...
:     [snip]
: >: che si becca subito un insufficenza. main() ha due soli prototipi validi
: :
: >
: >: int main(void)
: >: int main(int argc, char *argv[])
: >
: >Puoi chiarire, per favore ?
: Non sono l'autore cui rispondi, ma cerco di chiarire io.  Esiste uno
: standard per il linguaggio C, sancito dall'ANSI e poi dall'ISO tanti
: anni fa (e ancora valido).  Esso descrive accuratamente tutto quello
: che e` C e quello che non lo e`.
O.K. fino a qui lo so anche io, ma grazie lo stesso ;)
: Fra le cose che chiarisce, c'e` il
: dettaglio di come debba essere scritto main; e, a standard, puo`
: essere definito solo in uno di questi due modi.
Perfetto ! Questo risponde alla mia domanda.
Grazie mille.
[ snip ]
: compilatori piu` standard, domani potresti essere stupito.  Usa
: gli switch del tuo compilatore per dirgli di essere severo nella
: interpretazione a norma di standard, per gcc mi pare siano:
:        -ansi -Wall -pedantic -Werror
Se ti puo' interessare, io ho trovato un
-pedantic-errors
Che da' un errore anziche' un warning.


Andrea Foco (
big...@fokhouse.tin.it
) wrote:
: Alessandro Guarguaglini (
gua...@usa.net
) wrote:
: : On 19 Jun 1998 21:25:44 +0200, Andrea Foco wrote:
[ snip ]
: : >void main( void )
: : >
: : >compila perfettamente sul gcc, anche se genera un warning...
: : Appunto, il gcc e' abbastanza intelligente da fartelo notare, void main
: : (void) non e' standard, perche' la funzione main() deve ritornare un valore. 
: Cosa intendi con deve ? Che e' specificato nello Standard C ?
: (Strano perche' se compilo con '-ansi -pedantic' tutto funge...)
Mi rispondo da solo ;)
Ma se uso
-pedantic-errors
non compila affatto !
Comunque quello che volevo sapere io era se la definizione di main
come da te riportata era contenuta nello Standard o no.
Altri mi hanno risposto positivamente, per cui la questione e'
risolta, almeno per quello che mi riguarda.
Grazie a tutti.


(Strano perche' se compilo con '-ansi -pedantic' tutto funge...)
Infatti se leggi il manuale del GCC dice anche :
   GNU CC always tries to compile your program if possible; it never
gratuitously rejects a program whose meaning is clear merely because
(for instance) it fails to conform to a standard.  In some cases,
however, the C and C++ standards specify that certain extensions are
forbidden, and a diagnostic *must* be issued by a conforming compiler.
The -pedantic' option tells GNU CC to issue warnings in such cases;
-pedantic-errors' says to make them errors instead.  This does not
mean that *all* non-ANSI constructs get warnings or errors.
BTW, ho provato anch'io a compilare un programma minimo, il classico "Hello
word!", con void main(void), usando -ansi -pedantic -Wall, ma il gcc non si
lamenta minimamente...forse e' un caso di quelli contemplati nell'ultima
linea... ;-))


typedef struct vector_s * vector_t;
Nessun bisogno di spezzare la singola typedef che io ho
scritto in queste due dichiarazioni separate; sono rigorosamente
equivalenti.  La forma che ho usato io permette inoltre di
mantenere anonima la struttura (basta omettere l'identificatore
vector_s), il che di default io non faccio perche` certi debugger
hanno problemi a mostrare strutture anonime in fase, appunto,
di debugging, ma come linguaggio C e` corretto e preferibile
(meglio non dare nomi a cio` a cui non occorre riferirsi).
Alex

Andrea
Ciao.
Cix.

...
: >Alex Martelli (
al...@magenta.com
) wrote:
: >
: >[ snip ]
: >: {
: >:     vector_t result = malloc(sizeof(*vector_t));
: >      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
: Sorry del refuso, leggasi naturalmente sizeof(vector_t*)
: come argomento della malloc.
: >Scusa, ma a te funziona "*vector_t" per allocare la struct ?
: Non funziona "per allocare la struct"; funziona invece
: benissimo come *tipo*, che e` il suo ruolo. 
Si certo, mi sembrava chiaro cosa intendevo.
[ snip ]
: >La chiamata corretta e' :
: >
: >vector_t result = (vector_t)malloc(sizeof(struct vector_s));
: Questa chiamata e` ridondante nel linguaggio C: non e` mai
: necessario un cast esplicito del risultato della malloc, in quanto
: il void* che essa ritorna puo` essere assegnato a qualsiasi
: altro puntatore. 
OK, ma il fatto e' che il mio compilatore genera un warning.
( inoltre fare esplicitamente il cast aiuta a chiarire quello
  che si vuole fare ;)
[ snip ]
: Quanto all'argomento da passare alla malloc, visto come ho
: scritto la typedef, sizeof(vector_t*) e sizeof(struct vector_s)
: devono essere rigorosamente equivalenti.
Ecco io qui ho molte perplessita' !
vector_t   equivale a  struct vector_s *
vector_t*  equivale a  struct vector_s **
Se hai dei dubbi prova a controllare la lunghezza con sizeof
dei due tipi: sotto Linux (int == 32 bit == 4 byte) 
sizeof(vector_t*) == 4
sizeof(struct vector_s) == 12
In altre parole, vector_t* e' un tipo valido, ma allochi solo
la quantita' di memoria necessaria per il puntatore, non per
tutta la struct.


 int main(int argc, char *argv[])
Nello standard ANSI.... Nel Turbo C compila lo stesso... e soprattutto non e' rindondate....
-- 
Saluti.
*NATHAN*

Ecco io qui ho molte perplessita' !
E qui hai pienamente ragione!  Ho _aggiunto_ un livello di
indirettezza invece di _toglierlo_, uno svarione gravissimo.
"Oops", come si suol dire...!-)
Alex

Alex Martelli (
al...@magenta.com
) wrote:
[ snip ]
: Hai quindi un compilatore C scorretto, o forse e` un compilatore
: C++ (ovvero per un altro linguaggio).
pgcc 1.0.3, chiamato come gcc.
E' per il C (per il C++ viene chiamato con g++).
: >( inoltre fare esplicitamente il cast aiuta a chiarire quello
: >  che si vuole fare ;)
: Sbagliato, sbagliatissimo.  Facendo il cast dici al compilatore
: che SAI quel che vuoi fare, che cio` sia vero o meno.  Supponi
: di fare un errore di battitura e scrivere nalloc invece di malloc.
: Se non casti, e hai un compilatore corretto per il linguaggio C,
: avrai un errore di compilazione -- nalloc non essendo dichiarata,
: defaulta a valore di ritorno int, non assegnabile a pippo*, e il tuo
: compilatore puo` aiutarti dando subito l'errore.  Se casti, stai
: dicendo al tuo compilatore di NON darti messaggi, e l'errore
: ti verra` solo molto piu` tardi, al momento del link (con tanti
: auguri se il tuo linker non ti da` chiari messaggi su CHI, di tutti
: i tuoi moduli, abbia chiamato "nalloc", o se e` in una macro in
: un #define, ecc).
[root@fokhouse temp]# gcc prova3-1.c
/tmp/cca006281.o: In function `get_number':
/tmp/cca006281.o(.text+0xa5): the `gets' function is dangerous and should not be used.
/tmp/cca006281.o: In function `make_vector':
/tmp/cca006281.o(.text+0xc): undefined reference to `nalloc'
collect2: ld returned 1 exit status
Come dici tu, l'errore e' trovato dal linker, ma la diagnostica
mi sembra buona ;)
:  Peggio ancora, se l'errore e` piu` sottile,
: tipo perdere per svarione di editing tutti gli argomenti, cioe`
: tipo:    pippo=malloc;  Senza cast, errore di compilazione e
: facile correzione; col malnato cast, pippo=(pip*)malloc; nessun
: errore, a pippo viene inserito l'indirizzo del CODICE dove vive
: malloc, e *auguri* a trovare la causa degli erroracci risultanti.
Vero, pero' insomma, ti basta arrivare alla linea di codice con
malloc per capire 'al volo' l'errore <g>
Considera invece l'errore di chiamare malloc con un argomento di lunghezza
sbagliata. Il compilatore, in questo caso, non ti e' di nessun aiuto,
l'errore e' difficile da rintracciare, perche' ad una occhiata distratta
puo' sembrare che tutto vada bene (invece, se vedi "pippo = malloc;" capisci
*subito* che e' sbagliato).
Il vantaggio del cast esplicito e' quello di 'vedere' cosa stai facendo:
la chiamata errata nel tuo codice a me ha dato *subito* una brutta 
impressione...
: I cast vanno usati IL MINIMO POSSIBILE e quindi solo quando
: ASSOLUTAMENTE INDISPENSABILI, poiche` interferiscono
: gravemente con le possibilita` del computer di diagnosticare i
: problemi del tuo codice. 
In generale, sono d'accordo. In questo caso, pero', parlerei di trade-off:
perdo la diagnostica del compilatore in un numero limitato di casi, in 
cambio di un aiuto nella ricerca di errori piu' subdoli.
[ snip ]
: "Oops", come si suol dire...!-)
8-)


cambio di un aiuto nella ricerca di errori piu' subdoli.
ci aggiungo una storia di vita vissuta:
Nelle MFC (sig..), una funzione della clesse CWnd ritorna un puntatore
ad un oggetto CWnd a partire dal titolo della finestra 
(CWnd::FindWindow(char *, char *)). Nelle api di windows, la stessa
funzione ritorna un HWND di una finestra.
Qualcuno ha chiamato la findwindow, supponendo di chiamre la prima, e
facendo un bellissimo quanto dannoso cast a un (CWnd *).
Risultato: il compilatore ha chiamato la funzione delle api, ritornando
un puntatore HWND, il compilatore l'ha considerato un CWnd *, senza warning ne'
tantomeno errori, e generando il bellissimo schermo azzurro al primo tentativo
di esecuzione (pure da dentro il denbugger).
E io ci ho perso mezza giornata. :-(
	Leo
-- 
-----------------------------------------------------------------------
	Questo messaggio e' stato trasmesso e visualizzato
        utilizzando soltanto elettroni riciclati.
  	Nessun atomo e' stato ionizzato per creare questo messaggio