Discussion :

[flavia]

Bonjour,

Dans un petit programme en C je cherche à récupérer l'espace disque libre.
J'ai trouvé sur internet des choses qui m'ont pas servi à grand chose (dans la librairie dos.h il y une fonction _dos_getdiskfree() mais mon complilateur ne reconnais pas cette fonction, je pense que cette librairie n'est pas compatible windows xp).

merci pour votre aide "c'est urgent"

[Médinoc]

Rien de standard.
Sous Windows XP, tu as GetDiskFreeSpaceEx() pour cela.

[flavia]

Rien de standard.
Sous Windows XP, tu as GetDiskFreeSpaceEx() pour cela.

Je te remercie pour ta réponse, cette fonction est dans dos.h?

[Médinoc]

dos.h n'est pas une "librairie" (bibliothèque), mais un fichier d'en-tête. Un fichier d'en-tête uniquement pour DOS 16 bits.

GetDiskFreeSpaceEx() est une fonction Win32, elle est donc déclarée en incluant <windows.h>...

Quel est ton environnement de développement ?

[flavia]

dos.h n'est pas une "librairie" (bibliothèque), mais un fichier d'en-tête. Un fichier d'en-tête uniquement pour DOS 16 bits.

GetDiskFreeSpaceEx() est une fonction Win32, elle est donc déclarée en incluant <windows.h>...

Quel est ton environnement de développement ?

je suis sur Dev-C++ sous windows XP

[flavia]

J'arrive pas à utiliser GetDiskFreeSpaceEx quelqu'un peut m'aider?
merci d'avance.

[Pierre Maurette]

J'arrive pas à utiliser GetDiskFreeSpaceEx quelqu'un peut m'aider?
merci d'avance.

Vous donnez trop peu de renseignements. C'est limite manque de respect, je vous le dis comme je le pense. Et de plus Google est farci d'exemples.
Vous devez d'abord vérifier que vous pouvez inclure windows.h. Je ne me souviens plus pour DevC++ (mais il n'y a pas de raison que ce fut différent) mais dans l'installation complète de Code::Blocks, c'est inclus. Et dans mon Cygwin, c'est sous cygwinpath\usr\include\w32api\
Ensuite, c'est assez simple, avec quelques trucs pour afficher sans warning:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#include <stdlib.h>
 
#include <windows.h>
 
 
    int main(void) {
        unsigned __int64 FreeBytesAvailable, TotalNumberOfBytes, TotalNumberOfFreeBytes;
        GetDiskFreeSpaceEx("D:", (PULARGE_INTEGER)&FreeBytesAvailable, (PULARGE_INTEGER)&TotalNumberOfBytes, (PULARGE_INTEGER)&TotalNumberOfFreeBytes);
        printf("%I64d %I64u %I64u\n", FreeBytesAvailable, TotalNumberOfBytes, TotalNumberOfFreeBytes);
        unsigned long FreeBytesAvailableM = FreeBytesAvailable / (1024 * 1024);
        unsigned long TotalNumberOfBytesM = TotalNumberOfBytes / (1024 * 1024);
        unsigned long TotalNumberOfFreeBytesM = TotalNumberOfFreeBytes / (1024 * 1024);
        printf("%lu Mo %lu Mo %lu Mo\n", FreeBytesAvailableM, TotalNumberOfBytesM, TotalNumberOfFreeBytesM);
        float FreeBytesAvailableG = FreeBytesAvailableM / 1024.0;
        float TotalNumberOfBytesG = TotalNumberOfBytesM / 1024.0;
        float TotalNumberOfFreeBytesG = TotalNumberOfFreeBytesM / 1024.0;
        printf("%.2f Go %.2f Go %.2f Go\n", FreeBytesAvailableG, TotalNumberOfBytesG, TotalNumberOfFreeBytesG);
        return (0);
    }

(obtenir les float après une première division entière est idiot, je vous laisse corriger).

[Pierre Maurette]

Pour info:
J'ai regardé dans les .h (winnt.h) ce drôle de type ULARGE_INTEGER. C'est une union un peu velue. En bref, si sizeof(unsigned long long) vaut 8, on peut le voir comme une structure d'une seul champ unsigned long long (ou ULONGLONG) QuadPart.
On peut alors faire:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
#include <windows.h>
 
 
    int main(void) {
        assert(sizeof(unsigned long long) == 8);
        ULARGE_INTEGER FreeBytesAvailable, TotalNumberOfBytes, TotalNumberOfFreeBytes;
        GetDiskFreeSpaceEx("D:", &FreeBytesAvailable, &TotalNumberOfBytes, &TotalNumberOfFreeBytes);
        printf("%I64d %I64d %I64d\n", FreeBytesAvailable.QuadPart, TotalNumberOfBytes.QuadPart, TotalNumberOfFreeBytes.QuadPart);
        unsigned long FreeBytesAvailableM = FreeBytesAvailable.QuadPart / (1024 * 1024);
        unsigned long TotalNumberOfBytesM = TotalNumberOfBytes.QuadPart / (1024 * 1024);
        unsigned long TotalNumberOfFreeBytesM = TotalNumberOfFreeBytes.QuadPart / (1024 * 1024);
        printf("%lu Mo %lu Mo %lu Mo\n", FreeBytesAvailableM, TotalNumberOfBytesM, TotalNumberOfFreeBytesM);
        float FreeBytesAvailableG = FreeBytesAvailableM / 1024.0;
        float TotalNumberOfBytesG = TotalNumberOfBytesM / 1024.0;
        float TotalNumberOfFreeBytesG = TotalNumberOfFreeBytesM / 1024.0;
        printf("%.2f Go %.2f Go %.2f Go\n", FreeBytesAvailableG, TotalNumberOfBytesG, TotalNumberOfFreeBytesG);
        return EXIT_SUCCESS;
    }

[flavia]

Je te remercie pour ton aide,
J'ai trouvé de ma part une solution qui est pas mal.

Code :
/*
Determines the amount of free space available for the caller.
Runs on Windows 95 retail and later, and on Windows 4.0 and later.
Uses GetDiskFreeSpaceEx if available, otherwise reverts to
GetDiskFreeSpace.

To determine the amount of available space correctly:

* Use 64-bit math with the return values of both GetDiskFreeSpace
and GetDiskFreeSpaceEx so that you can determine the sizes of
volumes that are larger than 2GB.

Programs that need to determine how much free space the current user
can have (such as whether there is enough space to complete an
installation) have an additional requirement:

* Use the lpFreeBytesAvailableToCaller value from
GetDiskFreeSpaceEx rather than lpTotalNumberOfFreeBytes.
This is because Windows 2000 has disk quota management that
administrators may use to limit the amount of disk space that
users may use.
*/
#include <windows.h>
#include <stdio.h>


typedef BOOL (WINAPI *P_GDFSE)(LPCTSTR, PULARGE_INTEGER,
PULARGE_INTEGER, PULARGE_INTEGER);

int main (int argc, char **argv)
{
BOOL fResult;

char *pszDrive = NULL,
szDrive[4];

DWORD dwSectPerClust,
dwBytesPerSect,
dwFreeClusters,
dwTotalClusters;

P_GDFSE pGetDiskFreeSpaceEx = NULL;

unsigned __int64 i64FreeBytesToCaller,
i64TotalBytes,
i64FreeBytes;

pszDrive = argv[1];

if (pszDrive[1] == ':')
{
szDrive[0] = pszDrive[0];
szDrive[1] = ':';
szDrive[2] = '\\';
szDrive[3] = '\0';

pszDrive = szDrive;
}

/*
Use GetDiskFreeSpaceEx if available; otherwise, use
GetDiskFreeSpace.

Note: Since GetDiskFreeSpaceEx is not in Windows 95 Retail, we
dynamically link to it and only call it if it is present. We
don't need to call LoadLibrary on KERNEL32.DLL because it is
already loaded into every Win32 process's address space.
*/
pGetDiskFreeSpaceEx = (P_GDFSE)GetProcAddress (
GetModuleHandle ("kernel32.dll"),
"GetDiskFreeSpaceExA");
if (pGetDiskFreeSpaceEx)
{
fResult = pGetDiskFreeSpaceEx (pszDrive,
(PULARGE_INTEGER)&i64FreeBytesToCaller,
(PULARGE_INTEGER)&i64TotalBytes,
(PULARGE_INTEGER)&i64FreeBytes);
if (fResult)
{

/*
printf ("\n\nGetDiskFreeSpaceEx reports\n\n");
printf ("Available space to caller = %I64u MB\n",i64FreeBytesToCaller / (1024*1024));
printf ("Total space = %I64u MB\n",i64TotalBytes / (1024*1024));
printf ("Free space on drive = %I64u MB\n",i64FreeBytes / (1024*1024));
*/
printf ("%ld", i64FreeBytes / (1024*1024));
}
}
else
{
fResult = GetDiskFreeSpace (pszDrive,
&dwSectPerClust,
&dwBytesPerSect,
&dwFreeClusters,
&dwTotalClusters);
if (fResult)
{
/* force 64-bit math */
i64TotalBytes = (__int64)dwTotalClusters * dwSectPerClust *
dwBytesPerSect;
i64FreeBytes = (__int64)dwFreeClusters * dwSectPerClust *
dwBytesPerSect;

/*
printf ("GetDiskFreeSpace reports\n\n");
printf ("Free space = %I64u MB\n",i64FreeBytes / (1024*1024));
printf ("Total space = %I64u MB\n",i64TotalBytes / (1024*1024));
*/
printf ("%ld", i64FreeBytes / (1024*1024));
}
}

if (!fResult)
printf ("error: %lu: could not get free space for \"%s\"\n",
GetLastError(), argv[1]);
}