파일 I/O

파일 열기 :

HANDLE CreateFile(
      LPCTSTR lpFileName,                // 개방(open)할 파일 이름
      DWORD dwDesiredAccess,          // 읽기/쓰기 모드를 지정한다.(or (l) 연산으로 결합)
                                                          GENERIC_READ : 읽기 모드
                                                          GENERIC_WRITE : 쓰기 모드
      DWORD dwShareMode,               // 파일 공유방식 
                                                          0 : 다른 프로세스에 절대 공유 불가. 중복 개방 불가
                                                          FILE_SHARE_READ : 다른 프로세스에서 동시 읽기 접근 가능
                                                          FILE_SHARE_WRITE : 다른 프로세스에서 동기 쓰기 접근 가능
      LPSECURITY_ATTRIBUTES lpSecurityAttributes, // 보안 속성
      DWORD dwCreationDisposition,    // 파일의 생성되는 방법을 지정
                                                          CREATE_ALWAYS : 항상 새 파일을 생성
                                                          CREATE_NEW : 새 파일 생성, 같은 이름의 파일이 존재하면 생성 실패
                                                          OPEN_ALWAYS : 기존 파일 개방. 없으면 생성
                                                          OPEN_EXISTING : 기존 파일 개방, 존재하지 않으면 함수 호출 실패
                                                          TRUNCATE_EXISTING : 기존 파일의 내용 지우고 개방.
      DWORD dwFlagsAndAttributes,     // 파일의 특성 정보를 설정 (기본적 FILE_ATTRIBUTE_NORMAL 사용)
      HANDLE hTemplateFile               // 기존에 존재하는 파일과 동일한 특성을 가지는 새 파일을 만들때 사용
);


파일 쓰기(저장) :

BOOL WriteFile(
      HANDLE hFile,                                  // 데이터를 읽어 들일 파일을 지정(Mail Slot)
      LPCVOID lpBuffer,                             // 전송할 데이터가 저장되어 있는 버퍼 지정
      DWORD nNumberOfBytesToWrite,       // 전송할 데이터 크기를 지정한다  
      LPDWORD lpNumberOfBytesWritten,    // 함수 호출 완료 후 전송된 실제 데이터의 크기를 바이트 단위로
                                                                얻기 위한 변수의 주소 지정
      LPOVERLAPPED lpOverlapped           //
);


파일 읽기 :

BOOL ReadFile(
      HANDLE hFile,                                  // 해당 파일(Mail Slot)에 존재하는 데이터를 읽어들인다
      LPCVOID lpBuffer,                             // 읽어 들인 데이터를 저장할 버퍼 지정
      DWORD nNumberOfBytesToWrite,       // 읽어 들일 데이터의 최대 크기 지정  
      LPDWORD lpNumberOfBytesWritten,    // 함수 호출 완료 후 읽어 들인 실제 데이터의 크기를 바이트 단위로
                                                                얻기 위한 변수의 주소 지정
      LPOVERLAPPED lpOverlapped           //
);

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

int _tmain(int argc, TCHAR *argv[])
{
         TCHAR fileName[] = _T("dakuoText.txt");
         TCHAR fileWrite[] = _T("file I/O test");
         TCHAR fileRead[100];
 
         HANDLE hFile = CreateFile(fileName, GENERIC_WRITE | GENERIC_READ,
                                              FILE_SHARE_WRITE | FILE_SHARE_READ, 0, OPEN_EXISTING,
                                              FILE_ATTRIBUTE_NORMAL, 0);
         if(hFile==INVALID_HANDLE_VALUE)
         {
                   _tprintf(_T("File Creation fault!\n"));
                   return -1;
         }

#if 1         // 1 : Write       0 : Read
         DWORD numOfByteWritten = 0;                  
         WriteFile(hFile, fileWrite, sizeof(fileWrite), &numOfByteWritten, NULL);                         
         _tprintf(_T("Written Data size : %u  Written String : %s \n"), numOfByteWritten, fileWrite);
#else
         DWORD numOfByteRead = 0;
         ReadFile(hFile, fileRead, sizeof(fileRead), &numOfByteRead, NULL);
         fileRead[numOfByteRead/sizeof(TCHAR)] = 0 ;
         _tprintf(_T("Read Data size : %u  Read String : %s \n"), numOfByteRead, fileRead);
#endif
      
         CloseHandle(hFile);
         return 0;
}

파일 포인터의 이동 :

DWORD SetFilePointer(
          HANDLE hFile,                                  // 파일 포인터 위치를 이동시킬 대상 파일의 핸들을 지정
          LONG lDistanceToMove,                    // 이동시킬 거리를 지정 ( 64 비트 환경에서 하위 4 바이트)
          PLONG lpDistanceToMoveHigh,          // 64 비트 기반의 대용량 파일에서만 의미 (상위 4 바이트 표현 )
                                                                 // 32비트 환경에서는 NULL
          DWORD dwMoveMethod                     // 파일 포인터 이동시 기준 위치 지정 : 앞 : FILE_BEGIN
);                                                                                                                     현재위치 : FILE_CURRENT
                                                                                                                       뒤 : FILE_END
예외처리 :

32비트 : if(dwPtr == INVALID_SET_FILE_POINTER)       64비트 : if((dwPtrLow == INVALID_SET_FILE_POINTER)
            {                                                                                && (GetLatError() != NO_ERROR)) 
                        예외처리                                                     {
            }                                                                                          예외처리
                                                                                         }
(참고 : 64비트에서 4G바이트 이상의 대용량파일을 다루기 때문에 파일의 위치가 0xFFFFFFFF 가 되는데 이는
          INVALID_SET_FILE_POINTER 값과 같으므로 GetLastError 함수호출을 통해 반환값을 확인해줘야한다)



파일의 시간 정보 얻어오기 :

BOOL GetFileTime(
         HANDLE hFile,                             // 시간 관련 정보를 얻을 대상 파일의 핸들
         LPFILETIME lpCreationTime,         // 파일이 생성된 시간을 얻기 위한 FILETIME 구조체 변수주소
         LPFILETIME lpLastAccessTime,    // 파일의 마지막 접근 시간을 얻기 위한 FILETIME 구조체 변수주소
         LPFILETIME lpLastWriteTime,        // 파일의 마지막 데이터 갱신(덮어 쓰기 포함) 시간을 얻기 위한
};                                                         // FILETIME 구조체 변수주소
(참고 : 세가지 시간 정보중 원하지 않는 시간 정보에 NULL 전달)


FILETIME 구조체 :                                 SYSTEMTIME 구조체 :

typedef struct _FILETIME {                     typedef struct _SYSTEMTIME {
         DWORD dwLowDateTime;                      WORD wYear;
         DWORD dwHighDateTime;                      WORD wMonth;
} FILETIME, *PFILETIME;                               WORD wDayOfWeek;
                                                                    WORD wDay;
                                                                    WORD wHour;
                                                                    WORD wMinute;
                                                                    WORD wSecond;
                                                                    WORD wMilliseconds;
                                                          } SYSTEMTIME, *PSYSTEMTIME;

FILEITME 구조체는 시간 정보를 UTC 기반으로 나타내는 8바이트 자료형(DWORD*2)이다.
(참고 : UTC 시간 : 1601년 1월 1일을 기준으로 100 나노초 단위 기준으로 지나간 시간을 계산
SYSTEMTIME 구조체도 UTC 시간 기반이다)


BOOL FileTimeToSystemTime(                     // FILETIME 포맷을 SYSTEMTIME 포맷으로 변경하는 함수.
           CONST FILETIME *lpFileTime,           // UTC 정보가 들어있는 FILETIME 구조체 변수주소
           LPSYSTEMTIME lpSystemTime         // SYSTEMTIME 구조체 변수주소
);


BOOL SystemTimeToTzSpecificLocalTime(                 // UTC 기반시간을 현재 시스템시간으로 변경하는 함수.
            LPTIME_ZONE_INFORMATION lpTimeZone,    // TIME_ZONE_INFORMATION 구조체 변수주소
                                                                               // NULL : 현재 시스템의 지역정보
            LPSYSTEMTIME lpUniversalTime,            // UTC 시간정보가 들어있는 SYSTEMTIME 구조체 변수주소
            LPSYSTEMTIME lpLocalTime                 // 지역시간을 넘겨받을 SYSTEMTIME 구조체 변수주소
);

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

int _tmain(int argc, TCHAR *argv[])
{
         TCHAR fileName[] = _T("dakuoTime.txt");
         TCHAR fileCreateTimeInfo[100];
 
         FILETIME ftCreate;
         SYSTEMTIME stCreateUTC, stCreateLocal;
 
         HANDLE hFile = CreateFile(fileName, GENERIC_READ, 0, 0, OPEN_ALWAYS,
                                                FILE_ATTRIBUTE_NORMAL, 0);
         if(hFile == INVALID_HANDLE_VALUE)
         {
                   _tprintf(_T("File Open Fault\n"));
                   return -1;
         }
    
         if(!GetFileTime(hFile, &ftCreate, NULL, NULL))
         {
                   _tprintf(_T("GetFileTime function Fault\n"));
                   return -1;
         }

          FileTimeToSystemTime(&ftCreate, &stCreateUTC);
          SystemTimeToTzSpecificLocalTime(NULL, &stCreateUTC, &stCreateLocal);

          _stprintf(fileCreateTimeInfo, _T("%d/%02d/%02d   %02d:%02d"),
                      stCreateLocal.Year, stCreateLocal.wMonth, stCreateLocal.wDay,
                      stCreateLocal.wHour, stCreateLocal.wMinute);
          _tprintf(_T("File Create Time : %s \n"), fileCreateTimeInfo);
         
           CloseHandle(hFile);
           return 0;
}

(추가 : SetFileTIme 함수를 이용하면 함수의 시간 정보를 변경할수 있다.

BOOL SetFileTime(
HANDLE hFile,                                            // 시간 정보를 변경하고자 하는 파일의 핸들
CONST FILETIME *lpCreationTime,               // 파일의 생성시간 변경
CONST FILETIME *lpLastAccessTime,          // 파일의 마지막 접근시간 변경
CONST FILETIME *lpLastWriteTime               // 파일의 마지막 데이터 갱신 시간 변경
);



파일 사이즈 얻어오기 :

BOOL GetFileSizeEx(                    
        HANDLE hFile,                        // 파일 핸들을 지정한다.  
        PLARGE_INTEGER lpFileSize   // 파일 크기를 저장하기 위한 변수주소(LARGE_INTEGER = 8바이트 자료형)
);


파일의 특성(Attribute) 정보 얻어오기 :

DWORD GetFileAttributes(
        LPCTSTR lpFileName      // 특성정보를 얻고자 하는 파일의 핸들을 지정.
);  // 파일의 특성 정보를 DWORD 로 반환 (비트 단위로 의미 부여)

ex.    #define FILE_ATTRIBUTE_READONLY 0x00000001
         #define FILE_ATTRIBUTE_HIDDEN      0x00000002


BOOL SetFileAttributes(
       LPCTSTR lpFileName,         // 특성 정보를 변경하고픈 파일의 이름을 지정
       DWORD dwFileAttributes       // 변경할 특성 정보 전달
);


BOOL GetFileInformationByHandle(
     HANDLE hFile,                                                        // 정보를 얻고자 하는 파일의 핸들
     LPBY_HANDLE_FILE_INFORMATION lpFileInformation // BY_HANDLE_FILE_INFORMATION 구조체 변수주소
);

파일의 특성정보와 시간정보 파일 크기 정보를 비롯한 추가적인 파일 시스템 정보들도 얻을 수 있다.

typedef struct _BY_HANDLE_FILE_INFORMATION
{
         DWORD dwFileAttributes;
         FILETIME ftCreationTime;
         FILETIME ftLastAccessTime;
         FILETIME ftLastWriteTime;
         DWORD dwVolumSerialNumber;
         DWORD nFileSizeHigh;
         DWORD nFileSizeLow;
         DWORD nNumberOfLinks;
         DWORD nFileIndexHigh;
         DWORD nFileIndexLow;
} BY_HANDLE_FILE_INFORMATION, * BY_HANDLE_FILE_INFORMATION;

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

int _tmain(int argc, TCHAR *argv[])
{
         TCHAR fileName[] = _T("dakuoFile.txt");
         BY_HANDLE_FILE_INFORMATION fileInfo;
         
         HANDLE hFile = CreateFile(fileName, CENERIC_READ, 0, 0, OPEN_ALWAYS,
                                                FILE_ATTRIBUTE_NORMAL, 0);
         if(hFile == INVALID_HANDLE_VALUE)
         {
                _tprintf(_T("file open Error\n"));
                return -1;
         }

          LARGE_INTEGER fileSize;
          GetFileSizeEx(hFile, &fileSize);                      // 파일 사이즈 획득 함수
          _tprintf(_T("%u\n"), fileSize);
      
          DWORD arrtib = GetFileAttributes(fileName);       // 파일 속성 획득 함수
          _tprintf(_T("%u\n"), attrib);
          attrib = (FILE_ATTRIBUTE_READONLY); 
          SetFileAttributes(fileName, attrib);                      // 파일 속성 변경 함수
          _tprintf(_T("%u\n"), attrib);

          GetFileInformationByHandle(hFile, &fileInfo);       // 파일의 대한 정보 획득 함수
          _tprintf(_T("file size : %u \n "), fileInfo.nFileSizeLow);
      
          return 0;
}

실행결과 :

file size : 0            // 파일 사이즈 (GetFileSizeEx)
32                       // 파일 속성 값
1                         // 변경된 파일 속성 값
file size : 0           // 파일 사이즈 (GetFileInformaionByHandle)

파일의 경로(PATH) 얻기 :

DWORD GetFullPathName(
           LPCTSTR lpFileName,           // 완전경로(Full Path)를 확인하고자 하는 파일 이름을 전달한다.
           DWORD nBufferLength,           // 완전경로를 저장할 버퍼에 저장 가능한 문자열 길이를 지정한다.
           LPTSTR lpBuffer,                   // 완전경로를 저장할 버퍼의 주소값을 지정한다.
           LPTSTR *lpFilePart                // 버퍼의 저장된 값중 파일의 이름값을 가리키는 포인터
);

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

int _tmain(int argc, TCHAR *argv[])
{
        TCHAR fileName[] = _T(".exe");
        TCHAR fileFullPathName[100];
        LPTSTR filePtr;

        GetFullPathName(fileName, 100, fileFullPathName, &filePtr);

        _tprintf(_T("%s \n"), fileFullPathName);
        _tprintf(_T("%s \n"), filePtr);
 
        return 0;
}