Newsgroup: it.comp.lang.c
Titolo: System()....un dubbio!

Ciao a tutti, sono un newbie fresco fresco, il programma + difficile che ho
scritto fino ad ora e' il calcolo dell'area di un quadrato =o)
Dunque, il mio dubbio riguarda system( ), vorrei far copiare un file da una
locazione dell'hd ad una directory decisa dall'utente... io avevo(con le mie
poche conoscenze) scritto questo:
#include <stdio.h>
main()
{
 char dir[120];
    printf("Inserisci la directory, specificando il percorso, dove vuoi
installare il file:");
 gets(dir);
 system( "copy d:\\prove\\1.txt qui_voglio_inserire_la_stringa_dir" );
}
Come faccio a fargli inserire la stringa dir?
Grazie in anticipo
Kyo

         if(argc!=2) {
	if(argc!=3) {
-- 
Alla prossima,
Marco

 Come faccio a fargli inserire la stringa dir?
   Usa sprintf().
   Tuttavia, non vedo il motivo di scomodare la funzione system().
<code>
	/*
	 * cp.c -- Imaginatively copies a file from a side to
	 *         another one.
	 */
	#include <stdio.h>
	int
	main(int argc,char **argv)
	{
		FILE *in,*out;
		int ch;
		if(argc!=2) {
			fputs("usage: cp in_file out_file",stderr);
			return 1;
		}
		if((in=fopen(*(argv+1),"rb"))==NULL) {
			perror(*(argv+1));
			return 2;
		}
		if((out=fopen(*(argv+2),"w"))==NULL) }
			perror(*(argv+2));
			fclose(in); 	/* really defensive... */
			return 3;
		}
		while((ch=fgetc(in))!=EOF) fputc(ch,out);
		return 0;
	}
</code>
--
Alla prossima,
Marco

 </code>
Ma copy fa esattamente questo? non è un pò lenta questa implemntazione?
Non saerbbe meglio utilizzare un buffer per velocizzare la cosa?
Chiedo, non erano domande sarcastiche!

Chiedo, non erano domande sarcastiche!
L'uso corretto della bufferizzazione potrebbe portare a notevoli
miglioramenti. Inoltre il codice presentato e' errato (nel senso
che durante la copia "massacra" i file visto che legge in formato
binario ma scrive in formato testo).
Il comandi di copia fanno anche un sacco di cose in piu' come
mantenere le date e altre informazioni "accessorie" collegate
al file.
Sotto DOS ad esempio "copy" permette di concatenare piu' file
in un unico file.
Andrea
PS:
  ma perche' scrivere cose brutte come "*(argv+2)" poi ?
  bastava il molto piu' naturale, leggibile e compatto
  "argv[2]".
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

 Chiedo, non erano domande sarcastiche!
   Certamente la copia "a blocchi" e` piu` efficiente, cosi` come, 
probabilmente, l'utilizzo dei servizi a basso livello del sistema 
operativo (metodo certamente utilizzato dai vari programmi di copia).
   Tuttavia, considera che la system() deve, in qualche modo, interagire 
con la /shell/ per creare un nuovo processo che contenga il programma di 
copia, a grave deprimento delle prestazioni.
--
Alla prossima,
Marco

   ma perche' scrivere cose brutte come "*(argv+2)" poi ?
   Perche` /argv/ era stato definito come /char **/, semplice no?
--
Alla prossima,
Marco

copia, a grave deprimento delle prestazioni.
Mah... secondo me e' conveniente usare tutta la roba simpatica
che un sistema operativo (specie se modulare come Unix) mette a
disposizione.  Io preferisco scrivermi un paio di filtri e usare
la pipe-line del sistema operativo, piuttosto che inglobare tutto
"hard-coded".  Se il mio scopo, ad esempio, e' quello di ordinare
le righe di un file di testo, nella maggior parte dei casi mi va
bene il filtro "sort" di DOS.  Se il nostro amico sta cercando di
scrivere un programma che copia semplicemente dei file, perche'
sta installando qualcosa, gli conviene usare system().

   Perche` /argv/ era stato definito come /char **/, semplice no?
Non vedo, perche', anche se fosse definito in questo modo,
escludere argv[2].

 escludere argv[2].
   Omogeneita` formale.
--
Alla prossima,
Marco

   Omogeneita` formale.
eh eh eh ... bella questa ! :)

 eh eh eh ... bella questa ! :)
   Bella ma vera. Un puntatore a puntatore e` leggermente diverso da un 
vettore di puntatori, sicche`, in particolare in un contesto "didattico" 
come questo in cui scriviamo, e` importante distinguere i due concetti.
   Inoltre, per come sono strutturati gli /array/ in C, e` molto piu` 
intuitiva la notazione "a spiazzamento" rispetto a quella vettoriale, 
dato che in tutto il mondo, escluso il C, gli indici dei vettori 
appartengono all'insieme dei numeri naturali positivi. ;)
--
Alla prossima,
Marco

    Omogeneita` formale.
Capisco quello che vuoi dire, ma non mi sembra cosi' necessario come dici tu
!!!
Alex

appartengono all'insieme dei numeri naturali positivi. ;)
Questa non l'ho capita.

Grazie a tutti per l'interessamento ;-)

appartengono all'insieme dei numeri naturali positivi. ;)
Cretinata... mai sentito di linguaggi come Pascal o Fortran ?
Inoltre in C e' proprio uno dei linguaggi (assieme al COBOL)
in cui *NON* e' permesso decidere liberamente quali sono gli
estremi di indicizzazione per un array.
Andrea


Questa non l'ho capita.
Perche' e' una panzana.
In Pascal, come in Fortran e in altri linguaggi agli array si
possono assegnare range arbitrari di indici. Alcuni linguaggi
come C e COBOL invece hanno dei range predefiniti (in C si
va solo da 0 alla num_elementi-1).
Poi in C esiste l'aritmetica dei puntatori che permette di
scrivere cose come v[-3] (se v non e' un array ma e' un
puntatore). Questo e' pero' un altro discorso.
Andrea


 Perche' e' una panzana.
   Nel tuo ristretto mondo di linguaggi, non lo escludo. Purtroppo 
secoli di algebra vettoriale stanno li` fuori a smentirti. Domanda da un 
milione di dollari: qual e` il *primo* elemento di un vettore? Nota 
l'enfasi sull'ordinale: l'ho messa per evitarti una risposta... affrettata.
--
Alla prossima,
Marco

messa per evitarti una risposta... affrettata.
In C ? Il primo elemento ha indice zero, il secondo 1 e
cosi' via. In PERL (e parenti vari) la stessa cosa (anche
se e' possibile alterare $[ ... ma sono cose fortemente
sconsigliabili).
In pascal e fortran 90 dipende dall'array. Negli esempi
che ho mostrato il primo elemento ha indice -12.
In molti dialetti basic il primo elemento ha indice zero
ma la sintassi di dimensionamento trae in inganno (allocando
un elemento in piu' del numero indicato nello statement
di dimensionamento) e permette quindi anche cose come:
   dim a$(20)
   for i=1 to 20
     a$(i)="Prova"
   next
che potrebbero far pensare che gli indici partono da 1
anche se non e' vero.
In altri dialetti basic la cosa e' configurabile come
in pascal o fortran 90. Forse esistono dialetti basic in
cui gli indici partono sempre da 1 (ma personalmente
non li ho mai incontrati).
Esistono linguaggi in cui gli indici partono sempre e solo
da 1 (cobol e fortran 77, se non erro). Questi non sono
pero' gli unici linguaggi al mondo oltre al C (secondo me).
Ovviamente puo' anche essere che tu non intedessi affatto
dire che in tutti i linguaggi del mondo, tranne il C,
gli indici partono da 1.
In questo caso mi scuso :) ... e ti chiedo dove si puo'
trovare un dizionario di quel curioso linguaggio tanto
simile all'Italiano che usi tu.
Andrea
PS:
  Non ho voluto parlare di C++ perche' ho (malignamente)
  supposto che nel tuo pressapochismo C e C++ siano
  visti come un unico linguaggio.


 dei vettori sono numeri naturali positivi. 
   Sbagliato. Io parlavo degli indici dei vettori nella matematica, la 
quale, a tutt'oggi, rappresenta un complemento abbastanza corposo ai 
linguaggi di programmazione sull'insieme delle discipline nelle quali si 
usano gli indici.
   Il mio ragionamento era il seguente: IMHO, il C (o anche il Perl, o 
Java o altri linguaggio per i quali /vettore[0]/ puo` avere un senso) 
non hanno la concezione vettoriale della matematica, come la si apprende 
nelle istituzioni scolastiche.
   Nel caso del C, infatti, l'indice del vattore rappresenta lo 
spiazzamento dall'origine del vettore stesso (rappresentazione 
continua), mentre nell'algebra vettoriale l'indice rappresenta 
l'ordinalita` dell'elemento, sempre all'interno dell'elemento 
(rappresentazione discreta o ordinale).
   In alcune rappresentazioni particolari, come nelle serie che citi, la 
rappresentazione e` sempre ordinale, ma inizia dallo /0/ per questioni 
di comodo (ed e` sempre giustificato).
   Penso che arrivando al C dal nulla, e quindi almeno dalle basi della 
matematica, rappresentare gli /array/ come sequenze di oggetti 
raggiungibili tramite spiazzamento renda meno confusa la situazione, e 
la notazione
	*(array+offset)
concorra in quest'opera di chiarificazione. Ovviamente, non ho la 
verita` infusa (diversamente da altri) e non posso leggere nella mente 
di tutti: il ragionamento che ho fatto, l'ho detto, e` valido almeno per me.
   Detto questo, e confessando che la tabella EBCDIC ce l'ho davanti 
agli occhi cosi` come quando ho scritto quello sciagurato messaggio ma, 
ora, con i /gap/ ben visibili ;), chiudo la discussione e ti posteggio 
amichevolmente nel mio /killfile/: ammetto che possa commettere errori 
(anzi!) ed anche di essere ripreso, ma non di essere chiamato *Nantoni*, 
spiacente.

spiacente.
Mille scuse per l'errore di nome. Non era voluto e ne sono
dispiaciuto. In ogni caso "Nantoni" non voleva essere un
insulto (anche se dubito che si potesse intendere come tale).
Riguardo all'entrare nel tuo killfile ti faccio un piccolo
quiz (nel caso improbabile che tu legga questo messaggio):
 "In una scala che arriva sino ad un massimo di 10
  quanto mi importa che tu non legga i miei messaggi ?"
(Aiutino: ti ricordo che per me e' piu' naturale iniziare
 a contare da zero ... )
Io da parte mia continuero' a leggere quanto scrivi (nessun
nome e' mai entrato nel mio killfile) se non altro per tentare
di salvare gli innocenti dalle cavolate che dici se mai
parlerai ancora di qualcosa che conosco.
Andrea
