Newsgroup: it.comp.lang.c
Titolo: argc e argv

Buongiorno a tutti,
volevo una informazione "newbba" :)
Ho una funzione main definita cosi:
void main (argc, argv)
  int argc;
  char **argv;
{
 if  (argc != 2)
 { fprintf (stderr, "parameter missing\n");
   //.....segue tutto il codice
}
In pratica era un programma che prendeva in ingresso la path di un file, ad 
esempio:
c:\mioprogramma.exe pippo.dat
Ora questa funzione vorrei farla diventare non più main ma funzione1.
In pratica cosi:
void funzione1 (argc, argv)
  int argc;
  char **argv;
{
 if  (argc != 2)
{ fprintf (stderr, "parameter missing\n");
//..... segue tutto il codice
}
Il main è un altro, questo.
void main ()
{
std::ofstream ofs( "d:\\gOrig.txt" );
ofs << "Prova";
ofs.close();
//Vorrei richiamare la funzione passandogli il file appena creato, come 
posso fare?
funzione1(........)
}
Grazie a tutti per l'aiuto ;) 

 ha scritto:
Mi sarebbe piů comodo anche evitare il save del file.
In pratica ora prevedevo di fare cosi:
Main --> Scrivo il file gOrig.txt --> passo la path del file a Funzione1.
Funzione1-->Leggo il file passatomi --> Output risultato.
Mi sarebbe piů comodo evitare il save e poi la lettura del file, in pratica 
cosě:
Main -->"Tutto quello che c'era scritto nel file 
gOrig.txt"--->Funzione1-->Output risultato.
Come posso fare?
Vi ringrazio infinitamente. 

 posso fare?
postare sul newsgroup giusto, questo e' quello per il C, non per il C+
+.
Ciao Jack

 +.
Ok, cosi va bene? :p
Buongiorno a tutti,
volevo una informazione "newbba" :)
Ho una funzione main definita cosi:
void main (argc, argv)
  int argc;
  char **argv;
{
 if  (argc != 2)
 { fprintf (stderr, "parameter missing\n");
   //.....segue tutto il codice
}
In pratica era un programma che prendeva in ingresso la path di un file, ad
esempio:
c:\mioprogramma.exe pippo.dat
Ora questa funzione vorrei farla diventare non più main ma funzione1.
In pratica cosi:
void funzione1 (argc, argv)
  int argc;
  char **argv;
{
 if  (argc != 2)
{ fprintf (stderr, "parameter missing\n");
//..... segue tutto il codice
}
Il main è un altro, questo.
void main ()
{
FILE *pf
pf = fopen ( "gOrig.txt" , "w" ) ;
fprintf( pf , "PROVA") ;
fclose(pf);
//Vorrei richiamare la funzione passandogli il file appena creato, come
posso fare?


 Ok, cosi va bene? :p
Il fatto è che il primo programma (funzione1) è scritto in C il main invece 
è scritto in C++ :-/

 
Al di là del ng.
Non capisco perchè tu non voglia utilizzare un semplice buffer per
passare questa stringa dal main alla funzione...

 passare questa stringa dal main alla funzione...
Ciao Antonio,
innanzi tutto grazie per avermi risposto.
Come avrai capito sono molto newbie.
Cerco di spiegare meglio quello che voglio realizzare.
Ho trovato una funzione scritta in C che funziona perfettamente.
Essa prende come input un file e poi lo elabora.
Ecco un pezzo del programma:
void main (argc, argv)
  int argc;
  char **argv;
{
  FILE *fd;
  graph *gr;
  if  (argc != 2)
   { fprintf (stderr, "parameter missing\n");
     fprintf (stderr, "usage prg <input filename>\n");
     exit (1);
   }
  if ((fd = fopen (argv[1], "r")) == NULL)
   { fprintf(stderr, "Unable to open %s\n", argv[1]);
     exit (1);
   }
  gr = get_graph (fd);
  if (gr == (graph *) 0)
   { close (fd);
     exit (1);
   }
  close (fd);
ecc..ecc..
Senza voler stravolgere tutto il programma come faccio a passare il buffer 
che mi dicevi prima?
In pratica i problemi nascono con "fd", perchè molte funzioni (ad esempio 
get_graph) si aspettano una variabile di tipo FILE e io, come dicevo prima, 
non voglio modificare più di tanto il programma :(
In effetti sarebbe veramente schifoso scrivere in un file per poi passarlo 
alla funzione per l'elaborazione...sarebbe davvero meraviglioso se si 
potesse fare tutto con un "buffer".
Grazie davvero per l'aiuto.
Ciao. 

 Ciao.
non riesco a capire quale sia il problema.
puoi aprire il file e poi passarlo alla funzione, oppure passi
direttamente argc e argv alla funzione. dopodiche' nella funzione apri
il file e fai quello che devi fare.
io opteri per la prima opzione.
Ciao Jack

 io opteri per la prima opzione.
Il fatto č che inglobando questa funzione nel mio progetto, i valori che 
vorrei passare alla funzione li tengo in memoria.
Quindi (spero che voi mi smentiate) dovrei fare Memoria-->Save file-->Passo 
il puntatore del file alla funzione.
Tutto questo per non stravolgere il programma da inglobare perchč, ripeto, 
ci sono **molte funzioni** come get_graph che si aspettano un tipo FILE.
Grazie per l'interessamento ;) ;) ;).

 
aaaah. ho capito adesso.
Bhè se la tua funzione si aspetta di leggere da file e stavolta non deve
fare così, devi necessariamente modificare la funzione.
Devi modificare le funzioni, ed ogni fread dal file le trasformi in
lettura dalla struttura apposita che hai in memoria e che avrai creato
prima di chiamare tale funzione.
C'è poco da fare

 è scritto in C++ :-/
No: il main non si avvicina nemmeno a C++ valido.
% g++ -pedantic -W -Wall kr.cc 
kr.cc:1: error: variable or field 'main' declared void
kr.cc:1: error: 'argc' was not declared in this scope
kr.cc:1: error: 'argv' was not declared in this scope
kr.cc:1: error: initializer expression list treated as compound
expression
kr.cc:2: error: expected ',' or ';' before 'int'
kr.cc:4: error: expected unqualified-id before '{' token
In particolare in C++ non e' ammesso mettere i parametri senza tipo e
poi specificare il tipo dopo come in:
int main (argc, argv)
  int argc;
  char **argv;
{
}
-- 
-riko

 No: il main non si avvicina nemmeno a C++ valido.
Doh >_<'
Forse sono io che mi spiego malissimo, mah!
Riscrivo lo stralcio della funzione C del programma che voglio RIUTILIZZARE:
void main (argc, argv)
  int argc;
  char **argv;
{
  FILE *fd;
  graph *gr;
  if  (argc != 2)
   { fprintf (stderr, "parameter missing\n");
     fprintf (stderr, "usage prg <input filename>\n");
     exit (1);
   }
  if ((fd = fopen (argv[1], "r")) == NULL)
   { fprintf(stderr, "Unable to open %s\n", argv[1]);
     exit (1);
   }
  gr = get_graph (fd);
  if (gr == (graph *) 0)
   { close (fd);
     exit (1);
   }
  close (fd);
Il problema è che questa funzione vuole in ingresso un FILE (che poi verrà 
passeto a molte funzioni, una di queste è la get_graph(fd), ma ce ne sono 
altre).
Io chiedevo se c'era un modo (senza stravolgere tutto il codice) di passare 
al main invece che il puntatore al file i dati che ho già in memoria.
Comunque mi è stato detto da più fronti che la risposta è NO!
Amen procederò cosi: Dati che ho in memoria ---> Salvataggio su 
disco--->Passaggio del puntatore al file alla funzione su scritta.
Ciao.

 
Ma perchè non modificare un attimino le funzioni? e risparmiare "ore" di
I/O?

 disco--->Passaggio del puntatore al file alla funzione su scritta.
Se il tuo sistema operativo supporta file mappati in memoria, oppure
ram file systems, puoi sicuramente fare il passaggio (memoria
processo) -> (file in memoria contenente i dati), e il sistema fa una
semplice memcpy.
Ma questo e' specifico al tuo sistema operativo (o allo standard usato
dal sistema operativo). Il linguaggio C di per se, non impone nemmeno
che FILE* punti a contenuti su disco...

 I/O?
Umm non hai tutti i torti anche a me non piace molto fare I/O :)
Il file di testo che il programma leggeva in origine era cosifatto:
e 1 2 5
e 2 3 4
e 3 4 1
e 4 5 3
e 5 2 1
Ipotizzando che io abbia messo questi dati in una char in questo modo:
char argv[]= "e 1 2 5\ne 2 3 4\ne 3 4 1\ne 4 5 3\ne 5 2 1"
Nel programma vi sono queste istruzioni che leggono riga per riga il file:
fscanf (fd, "%c", &any);
if (any == 'e')
{
.....
}
Come faccio ora a fargli leggere "riga per riga" il mio char?
Mettere i dati nella char argv[] è la scelta migliore oppure mi consigli 
qualcos'altro?
Grazie ancora per l'aiuto ;)