[C] Leggere e cancellare file dentro a una cartella

[Vincenzo1968]

Il comando per compilare con GCC si Windows:

gcc -O3 dirwalk.c -o dirwalk.exe

[Vincenzo1968]

Allucinante! Su Linux con GCC non mi trova dir.h(come Visual Studio su Windows):

[Vincenzo1968]

Originariamente inviato da Antonio23

non intendevo proprio quello. l'esempio che avevo fatto era semplicemente per dire che se in linux vuoi linkare con la libreria libm.so, devi dare alla riga di comando il parametro -lm (ovvero -l togli lib e .so dal nome del file e ti rimane m, se vuoi linkare lib<nome>.so, dai -l<nome> ecc.).
Credevo fosse un problema di linking (evidentemente non e'), per cui non linkava di default la libreria in cui i tipi e le funzioni in dir.h sono implementate (non solo quale sia, libm.so e' la libreria dove sono implementate le funzioni di math.h, per esempio).

Ok Antonio, con GCC su Windows ho risolto. Ho il problema con GCC su Linux. Non mi trova dir.h(come Visual Studio su Windows).
Evidentemente devo passare -I specificando il percorso. Ma qual è?

[Vincenzo1968]

Ahhhhh!!!!!

Fossil dos header file:

http://www.daniweb.com/software-deve...ds/84545/dir.h


Allora ho fatto bene a consigliare le api di Windows:

http://msdn.microsoft.com/en-us/library/Aa364418.aspx

Ma, Misterx, perché non provi a compilare e far funzionare il codice prima di copincollarlo da chissà quale sito?

[Vincenzo1968]

Eh si Antonio, credo proprio di si.

La soluzione migliore rimane, secondo me, quella di AnonimoVeneziano nel contest 19:

#if !_WIN32
bool load_files(const char* directory) {

  DIR* RESTRICT dir_obj = opendir(directory);
  struct dirent* RESTRICT dir_struct;
  char * RESTRICT * RESTRICT files_names;
  const uint16_t path_size = strlen(directory);

  int count = 0;

  if (dir_obj == NULL)
    return TRUE;

  while ((dir_struct = readdir(dir_obj)) != NULL) {
    //printf("File name: %s\n", dir_struct->d_name);
    if (!IS_SPECIAL_DIRECTORY(dir_struct->d_name))
      ++file_nums;
  }

  rewinddir(dir_obj);

  files_names = malloc(file_nums*sizeof(char*));  

  while ((dir_struct = readdir(dir_obj)) != NULL) {
    if (!IS_SPECIAL_DIRECTORY(dir_struct->d_name)) {
      int name_size = strlen(dir_struct->d_name);
      int size = path_size + name_size + 1;
 
      files_names[count] = malloc(sizeof(char)*size);
      strncpy(files_names[count], directory, path_size);
      strncpy(files_names[count]+path_size, dir_struct->d_name, name_size);
      //printf("%s\n", files_names[count]);
      ++count;
    }
  }

  closedir(dir_obj);

  //printf("%d\n", file_nums);
  //printf("Size of dir: %d\n", path_size);
  
  // Read files
  read_files(files_names, file_nums);

  for (int i = 0; i < file_nums; ++i)
    free((void*)files_names[i]);

  free((void**)files_names);
 
  return FALSE;
}
#else

bool load_files(const char* directory) {

  WIN32_FIND_DATA find_data;
  HANDLE hFind;
  char * RESTRICT * RESTRICT files_names;
  const uint16_t path_size = strlen(directory)-1;

  int count = 0;
  hFind = FindFirstFile(directory, &find_data);
  if ( hFind == INVALID_HANDLE_VALUE)
    return TRUE;

  do  {
    //printf("File name: %s\n", dir_struct->d_name);
	if (!(find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
        ++file_nums;
  } while (FindNextFile(hFind, &find_data));

  FindClose(hFind);
  hFind = FindFirstFile(directory, &find_data);

  files_names = 
	  (char* RESTRICT * RESTRICT) malloc(file_nums*sizeof(char*));  

  do {
    if (!(find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
      int name_size = strlen(find_data.cFileName);
      int size = path_size + name_size + 1;
      files_names[count] = 
		  (char* RESTRICT)malloc(sizeof(char)*size);
      strncpy(files_names[count], directory, path_size);
	  strncpy(files_names[count]+path_size, find_data.cFileName, name_size+1);
      //printf("%s\n", files_names[count]);
      ++count;
    }
  } while (FindNextFile(hFind, &find_data));

  FindClose(hFind);

  //printf("%d\n", file_nums);
  //printf("Size of dir: %d\n", path_size);
  
  // Read files
  read_files(files_names, file_nums);

  for (int i = 0; i < file_nums; ++i)
    free((void*)files_names[i]);

  free((void**)files_names);
 
  return FALSE;
}

#endif

In questo modo si ha il codice compilabile e con gcc e con Visual Studio; e su Windows e su Linux.

Ciao e grazie di tutto. Non si finisce mai d'imparare

[Vincenzo1968]

Altro spezzone di codice firmato AnonimoVeneziano per il contest 19:

#if _WIN32
#include <Windows.h>
#define RESTRICT __restrict
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef char int8_t;
typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
#define fseeko _fseeki64
#define ftello _ftelli64

const char* files_dir = ".\\All\\*";

#else

#include <stdint.h>
#include <stdbool.h>
#include <dirent.h>
#define RESTRICT restrict
#define TRUE true
#define FALSE false
const char* files_dir = "./All/";
#endif

Poi dice che i contest non servono a niente

[misterx]

una variante più moderna della precedente. Ho lasciato le modifiche a scopo didattico. L'ho compilato con lcc-win32

#include <stdio.h>
//#include <dir.h>
//#include <dos.h>
#include <io.h>

int main(void)
{
   //struct ffblk ffblk;
   struct _finddata_t ffblk;
   int done;

   printf("Lista dei file di tipo: *.*\n");
   //done = _findfirst("*.*", &ffblk, 0);
   done = _findfirst("*.*", &ffblk);

   while(_findnext(done, &ffblk) == 0)
   {
       //printf(" %s\n", ffblk.ff_name);
	   printf(" %s\n", ffblk.name);
       //done = _findnext(&ffblk);
   }

   return 0;

[Vincenzo1968]

[Vincenzo1968]

Moderno. Bihhhhhh!

http://stackoverflow.com/questions/2...sing-io-h-file

Found something that looks like your problem here. Apparently, althought io.h is a standard Microsoft header, there is no port of it to mobile plataforms.

You are probably using some library that was not designed for use with mobile devices, and that library must be trying to use the non-mobile API.

[wingman87]

Perché lo provi su ubuntu se è per windows?

[Vincenzo1968]

Originariamente inviato da wingman87

Perché lo provi su ubuntu se è per windows?

Può darsi che su Windows funzioni(anzi funzionerà sicuramente) sostituendo dir.h con io.h, ma è "moderno"?

Apparently, althought io.h is a standard Microsoft header, there is no port of it to mobile plataforms.

Lo sviluppo per "mobile platform" è una cosa moderna o no?

Dai un'occhiata su MSDN e vedi cosa consiglia oggi la Microsoft per leggere directory e file: api windows o io.h? Secondo te?

[Vincenzo1968]

La soluzione migliore, secondo me, ripeto, è quella fornita da AnonimoVeneziano nel contest 19: moderna e compilabile su entrambi i sistemi(Linux/Windows) e con entrambi i compilatori(GCC/Visual Studio).

[wingman87]

Originariamente inviato da Vincenzo1968

Può darsi che su Windows funzioni(anzi funzionerà sicuramente) sostituendo dir.h con io.h, ma è "moderno"?

Apparently, althought io.h is a standard Microsoft header, there is no port of it to mobile plataforms.

Lo sviluppo per "mobile platform" è una cosa moderna o no?

Dai un'occhiata su MSDN e vedi cosa consiglia oggi la Microsoft per leggere directory e file: api windows o io.h? Secondo te?

Non so cosa intendesse misterx con "moderno" ma l'OP ha detto chiaramente che cercava una soluzione per windows, quindi non capisco perché posti i tentativi falliti di compilare su Ubuntu a discredito della soluzione proposta.

[Vincenzo1968]

Originariamente inviato da wingman87

Non so cosa intendesse misterx con "moderno" ma l'OP ha detto chiaramente che cercava una soluzione per windows, quindi non capisco perché posti i tentativi falliti di compilare su Ubuntu a discredito della soluzione proposta.

Perché quella è una soluzione per Windows non portabile nelle diverse piattaforme windows: desktop, mobile, etc.
Che facciamo? Scriviamo millemila funzioni, una per ogni piattaforma Windows?
Se proprio dobbiamo scrivere più funzioni tanto vale scriverne due come ha fatto AnonimoVeneziano e il codice funziona dappertutto.

Se poi non gl'interessa farlo funzionare su Linux, è sempre meglio, secondo me, usare l'api Windows piuttosto che scrivere una funzione per win desktop e una per win mobile.

[wingman87]

Quello che hai detto adesso ha un senso, far intendere che non sia una buona soluzione perché non compila su Ubuntu invece no

[Vincenzo1968]

Originariamente inviato da wingman87

Quello che hai detto adesso ha un senso, far intendere che non sia una buona soluzione perché non compila su Ubuntu invece no

Invece copincollare codice senza nemmeno provarlo è corretto? Questo v'insegnano all'università?

Dire che mi professo grande esperto del C senza fornire un link è corretto?

[wingman87]

Originariamente inviato da Vincenzo1968

Invece copincollare codice senza nemmeno provarlo è corretto? Questo v'insegnano all'università?

Dire che mi professo grande esperto del C senza fornire un link è corretto?

Direi di no, ma cosa ti dice che non l'abbia provato?
Non so, a me non l'hanno insegnato.
Ti professi grande esperto del C o no? Se sì è corretto, altrimenti no. In entrambi i casi il link non è necessario se non irreperibile

[Vincenzo1968]

Originariamente inviato da wingman87

Direi di no, ma cosa ti dice che non l'abbia provato?
Non so, a me non l'hanno insegnato.
Ti professi grande esperto del C o no? Se sì è corretto, altrimenti no. In entrambi i casi il link non è necessario se non irreperibile

No, non mi sono mai sognato di professarmi grande esperto del C. Lo testimoniano molti miei post. Se ti fa piacere te ne elenco qualcuno.

Wingman87, smettiamola con questa farsa. Misterx è andato a cercare in fretta e furia un codice che fosse molto più semplice e più corto di quello che avevo consigliato io. Con l'unico intento di farmi fare una brutta figura. Cosa che non gli è riuscita. Anzi, s'è verificato il contrario.

MisterX ha cominciato a fare brutte figure nel thread sugli automi a stati finiti dove blaterava di gente che avrebbe dovuto sgamarmi. Cosa avrebbero dovuto sgamare e chi avrebbe dovuto sgamarmi se lo sa solo lui.

Evidentemente anche qui ha postato con l'unica intenzione di rendermi ridicolo. Ha copincollato il codice da chissà dove e l'ha postato. Per sua sfortuna io, contrariamente a lui, sono abituato a compilare e controllare il funzionamento del codice prima di postarlo. E la sua prima versione non compilava né con Visual Studio né con GCC per Windows.
In seguito io sono riuscito a farlo compilare con GCC per Windows e la seconda versione che ha postato MisterX è identica alla mia tranne che per "include <io.h>". S'è affrettato a postarla spacciandola per moderna

Se tu avessi letto con attenzione tutto il thread te ne saresti accorto da solo. Mi pare di notare anche in te un certo malanimo nei miei confronti... Se così non fosse sei evidentemente molto, ma molto, distratto.
Visto che sei cosi solerte nel fare notare ciò che è corretto e ciò che non lo è, avresti dovuto per primo riprendere MisterX e poi, casomai, me.

[wingman87]

Non provo malanimo nei tuoi confronti e può darsi che sia stato distratto.
Il motivo per cui me la sono presa con te è che non mi piace come combatti le tue battaglie: con sottintesi, ironia e, soprattutto, un sacco di messaggi fuori tema. Vai dritto al punto come hai fatto nel tuo ultimo post e chiudila lì no?
E comunque, posso capire che ti sia sentito così dopo il messaggio di misterx ma io (una persona distratta qualunque) non ho pensato che la tua soluzione fosse ridicola.

[misterx]

Originariamente inviato da wingman87

Direi di no, ma cosa ti dice che non l'abbia provato?

ero preso col lavoro e leggo solo ora questo dibattito. Per chiarire: il primo codice proviene dalla documentazione ufficiale del compilatore della Borland, le funzioni devono essere chiamate in quell'ordine e quindi non c'è nulla da inventare; si compila con Turbo C della Borland.

Il secondo codice è un mio adattamento e si compila tranquillamente con lcc-win32 che guardacaso è gratuito.

IMHO è sempre meglio postare codice già noto, quello ricavato dalle varie documentazioni dei compilatori ad esempio, in quanto si dà la possibilità ai non esperti di approfondire. Se posti codice tuo solitamente altamente personalizzato e non documentato crei solo confusione in chi ti legge. Io ad esempio che sviluppo in ambiente Borland Builder C++ dove il codice non è affatto pulito solo raramente posto codice C a meno che non sia di facile comprensione come nei miei precedenti esempi copiaincollati

Ad ogni buon conto: Borland Builder C++ compila tranquillamente tutti gli esempi da me postati senza generare alcun warning, se l'autore avesse specificato cosa usa per sviluppare programmi avrei agito in modo differente, ma vedo che non interviene più.

Speriamo che i vari codici gli siano serviti.