Delen via

Een tijdelijk bestand maken en gebruiken

Toepassingen kunnen unieke bestands- en padnamen voor tijdelijke bestanden verkrijgen met behulp van de GetTempFileName- en GetTempPath2--functies. De functie GetTempFileName genereert een unieke bestandsnaam en de functie GetTempPath2 haalt het pad op naar een map waarin tijdelijke bestanden moeten worden gemaakt.

In de volgende procedure wordt beschreven hoe een toepassing een tijdelijk bestand maakt voor gegevensmanipulatiedoeleinden.

een tijdelijk bestand maken en gebruiken

  1. De toepassing opent het door de gebruiker verstrekte brontekstbestand met behulp van CreateFile.
  2. De toepassing haalt een tijdelijk bestandspad en een bestandsnaam op met behulp van de functies GetTempPath2 en GetTempFileName en gebruikt vervolgens CreateFile om het tijdelijke bestand te maken.
  3. De toepassing leest blokken tekstgegevens in een buffer, converteert de bufferinhoud naar hoofdletters met behulp van de functie CharUpperBuffA en schrijft de geconverteerde buffer naar het tijdelijke bestand.
  4. Wanneer al het bronbestand naar het tijdelijke bestand wordt geschreven, worden beide bestanden gesloten en wordt de naam van het tijdelijke bestand gewijzigd in 'allcaps.txt' met behulp van de functie MoveFileEx.

Elk van de vorige stappen wordt gecontroleerd op succes voordat u naar de volgende stap gaat en er wordt een beschrijving van een fout weergegeven als er een fout optreedt. De toepassing wordt onmiddellijk beëindigd nadat het foutbericht wordt weergegeven.

Houd er rekening mee dat het bewerken van tekstbestanden alleen voor eenvoudige demonstratie is gekozen en kan worden vervangen door een gewenste procedure voor het bewerken van gegevens. Het gegevensbestand kan van elk gegevenstype zijn, niet alleen tekst.

De functie GetTempPath2 haalt een volledig gekwalificeerde padtekenreeks op uit een omgevingsvariabele, maar controleert niet vooraf op het bestaan van het pad of de juiste toegangsrechten voor dat pad. Dit is de verantwoordelijkheid van de ontwikkelaar van de toepassing. Zie GetTempPath2voor meer informatie. In het volgende voorbeeld wordt een fout beschouwd als een terminalvoorwaarde en wordt de toepassing afgesloten nadat een beschrijvend bericht naar de standaarduitvoer is verzonden. Er zijn echter veel andere opties, zoals het vragen van de gebruiker voor een tijdelijke map of het gewoon proberen om de huidige map te gebruiken.

Notitie

De functie GetTempFileName vereist niet dat de functie GetTempPath2 wordt gebruikt.

 

In het volgende C++-voorbeeld ziet u hoe u een tijdelijk bestand maakt voor gegevensmanipulatiedoeleinden.

//
//  This application opens a file specified by the user and uses
//  a temporary file to convert the file to upper case letters.
//  Note that the given source file is assumed to be an ASCII text file
//  and the new file created is overwritten each time the application is
//  run.
//

#include <windows.h>
#include <tchar.h>
#include <stdio.h>

#define BUFSIZE 1024

void PrintError(LPCTSTR errDesc);

int _tmain(int argc, TCHAR *argv[])
{
    HANDLE hFile     = INVALID_HANDLE_VALUE;
    HANDLE hTempFile = INVALID_HANDLE_VALUE; 

    BOOL fSuccess  = FALSE;
    DWORD dwRetVal = 0;
    UINT uRetVal   = 0;

    DWORD dwBytesRead    = 0;
    DWORD dwBytesWritten = 0; 

    TCHAR szTempFileName[MAX_PATH];  
    TCHAR lpTempPathBuffer[MAX_PATH];
    char  chBuffer[BUFSIZE]; 

    LPCTSTR errMsg;

    if(argc != 2)
    {
        _tprintf(TEXT("Usage: %s <file>\n"), argv[0]);
        return -1;
    }

    //  Opens the existing file. 
    hFile = CreateFile(argv[1],               // file name 
                       GENERIC_READ,          // open for reading 
                       0,                     // do not share 
                       NULL,                  // default security 
                       OPEN_EXISTING,         // existing file only 
                       FILE_ATTRIBUTE_NORMAL, // normal file 
                       NULL);                 // no template 
    if (hFile == INVALID_HANDLE_VALUE) 
    { 
        PrintError(TEXT("First CreateFile failed"));
        return (1);
    } 

     //  Gets the temp path env string (no guarantee it's a valid path).
    dwRetVal = GetTempPath2(MAX_PATH,          // length of the buffer
                           lpTempPathBuffer); // buffer for path 
    if (dwRetVal > MAX_PATH || (dwRetVal == 0))
    {
        PrintError(TEXT("GetTempPath2 failed"));
        if (!CloseHandle(hFile))
        {
            PrintError(TEXT("CloseHandle(hFile) failed"));
            return (7);
        }
        return (2);
    }

    //  Generates a temporary file name. 
    uRetVal = GetTempFileName(lpTempPathBuffer, // directory for tmp files
                              TEXT("DEMO"),     // temp file name prefix 
                              0,                // create unique name 
                              szTempFileName);  // buffer for name 
    if (uRetVal == 0)
    {
        PrintError(TEXT("GetTempFileName failed"));
        if (!CloseHandle(hFile))
        {
            PrintError(TEXT("CloseHandle(hFile) failed"));
            return (7);
        }
        return (3);
    }

    //  Creates the new file to write to for the upper-case version.
    hTempFile = CreateFile((LPTSTR) szTempFileName, // file name 
                           GENERIC_WRITE,        // open for write 
                           0,                    // do not share 
                           NULL,                 // default security 
                           CREATE_ALWAYS,        // overwrite existing
                           FILE_ATTRIBUTE_NORMAL,// normal file 
                           NULL);                // no template 
    if (hTempFile == INVALID_HANDLE_VALUE) 
    { 
        PrintError(TEXT("Second CreateFile failed"));
        if (!CloseHandle(hFile))
        {
            PrintError(TEXT("CloseHandle(hFile) failed"));
            return (7);
        }
        return (4);
    } 

    //  Reads BUFSIZE blocks to the buffer and converts all characters in 
    //  the buffer to upper case, then writes the buffer to the temporary 
    //  file. 
    do 
    {
        if (ReadFile(hFile, chBuffer, BUFSIZE, &dwBytesRead, NULL)) 
        {
            //  Replaces lower case letters with upper case
            //  in place (using the same buffer). The return
            //  value is the number of replacements performed,
            //  which we aren't interested in for this demo.
            CharUpperBuffA(chBuffer, dwBytesRead); 

            fSuccess = WriteFile(hTempFile, 
                                 chBuffer, 
                                 dwBytesRead,
                                 &dwBytesWritten, 
                                 NULL); 
            if (!fSuccess) 
            {
                PrintError(TEXT("WriteFile failed"));
                return (5);
            }
        } 
        else
        {
            PrintError(TEXT("ReadFile failed"));
            return (6);
        }
    //  Continues until the whole file is processed.
    } while (dwBytesRead == BUFSIZE); 

    //  The handles to the files are no longer needed, so
    //  they are closed prior to moving the new file.
    if (!CloseHandle(hFile)) 
    {
       PrintError(TEXT("CloseHandle(hFile) failed"));
       return (7);
    }
    
    if (!CloseHandle(hTempFile)) 
    {
       PrintError(TEXT("CloseHandle(hTempFile) failed"));
       return (8);
    }

    //  Moves the temporary file to the new text file, allowing for differnt
    //  drive letters or volume names.
    fSuccess = MoveFileEx(szTempFileName, 
                          TEXT("AllCaps.txt"), 
                          MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED);
    if (!fSuccess)
    { 
        PrintError(TEXT("MoveFileEx failed"));
        return (9);
    }
    else 
        _tprintf(TEXT("All-caps version of %s written to AllCaps.txt\n"), argv[1]);
    return (0);
}

//  ErrorMessage support function.
//  Retrieves the system error message for the GetLastError() code.
//  Note: caller must use LocalFree() on the returned LPCTSTR buffer.
LPCTSTR ErrorMessage(DWORD error) 
{ 
    LPVOID lpMsgBuf;

    FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER 
                   | FORMAT_MESSAGE_FROM_SYSTEM 
                   | FORMAT_MESSAGE_IGNORE_INSERTS,
                  NULL,
                  error,
                  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                  (LPTSTR) &lpMsgBuf,
                  0,
                  NULL);

    return((LPCTSTR)lpMsgBuf);
}

//  PrintError support function.
//  Simple wrapper function for error output.
void PrintError(LPCTSTR errDesc)
{
        LPCTSTR errMsg = ErrorMessage(GetLastError());
        _tprintf(TEXT("\n** ERROR ** %s: %s\n"), errDesc, errMsg);
        LocalFree((LPVOID)errMsg);
}