ReadFile Win32 API

Question

i want to read a file.. but.. when i debug my program it runs but a pop up appears and says system programming has stopped working and in the console, it`s written that Press enter to close the program. my code is ::

// System Programming.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "iostream"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    HANDLE hin;
    HANDLE hout;
    TCHAR buff[20]= {'q','2','3'};
    TCHAR buff2[20]={'a','v'};
    hin = CreateFile(_T("Abid.txt"),GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
    if(hin == INVALID_HANDLE_VALUE)
    {
        cout<<"error";
    }

    WriteFile(hin,buff,40,0,NULL);
    CloseHandle(hin);

    hout = CreateFile(_T("Abid.txt"),GENERIC_READ,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);

    if(hout == INVALID_HANDLE_VALUE)
    {
        cout<<"error";
    }

    ReadFile(hout,buff2,40,0,NULL);
    CloseHandle(hout);
    return 0;
}

Answer 1

According to MSDN, lpNumberOfBytesWritten paremeter can be NULL only when the lpOverlapped parameter is not NULL. So the calls should be

DWORD nWritten;
WriteFile(hin, buff, 40, &nWritten, NULL);

and

DWORD nRead;
ReadFile(hout, buff2, 40, &nRead, NULL);

Also, rename hin and hout .

Answer 2

Others have already answered your question. This is about the code.

// Your code:
// System Programming.cpp : Defines the entry point for the console application.
//

Just remove that comment. It isn't true. :-) The entry point for your program is where the machine code starts executing, and with the Microsoft toolchain it's specified by the /entry linker option.

Note that Microsoft's documentation is generally confused about entry points, eg it has always, one way or other, documented incorrect signature for entry point.

It's one of the most infamous Microsoft documentation errors, and, given that it's persisted, in various forms, for 15 years, I think it says something (not sure exactly what, though).

// Your code:
#include "stdafx.h"

You don't need this automatically generated header. Instead use <windows.h> . A minimal way to include <windows.h> for your program would be

#undef  UNICODE
#define UNICODE
#include <windows.h>

For C++ in general you'll want to also make sure that STRICT and NOMINMAX are defined before including <windows.h> . With modern tools at least STRICT is defined by default, but it doesn't hurt to make sure. Without it some of declarations won't compile with a C++ compiler, at least not without reinterpret casts, eg dialog procedures.

// Your code:
#include "iostream"
using namespace std;

Almost OK.

Do this:

#include <iostream>
using namespace std;

The difference is where the compiler searches for headers. With quoted name it searches in some additional places first (and that's all that the standard has to say about it). With most compilers those additional places include the directory of the including file.

// Your code:
int _tmain(int argc, _TCHAR* argv[])

Oh no! Don't do this. It's a Microsoft "feature" that helps support Windows 9.x. And it's only relevant when you're using MFC linked dynamically and you're targeting Windows 9.x; without MFC in the picture you'd just use the Microsoft Unicode layer.

Area you really targeting Windows 9.x with an app using dynamically linked MFC?

Instead, do ...

int main()

... which is standard, or use the Microsoft language extension ...

int wMain( int argc, wchar_t* argv[] )

... if you want to handle command line arguments the "easy" way.

// Your code:
{
    HANDLE hin;
    HANDLE hout;
    TCHAR buff[20]= {'q','2','3'};
    TCHAR buff2[20]={'a','v'};

The TCHAR stuff is just more of that MFC in Windows 9.x support stuff.

Apart from being totally unnecessary (presumably, you're not really targeting Windows 9.x, are you?), it hides your intention and hurts the eyes.

Did you mean ...

char buff[20] = {'q', '2', '3'};

... perhaps?

// Your code:
    hin = CreateFile(_T("Abid.txt"),GENERIC_WRITE,0,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
    if(hin == INVALID_HANDLE_VALUE)
    {
        cout<<"error";
    }

As others have mentioned, OPEN_EXISTING isn't logical when you're creating the file, and the count pointer argument can't be 0 for your usage.

When using <windows.h> , with UNICODE defined as it should be, the filename argument should be specifed as L"Abid.txt" .

Cheers & hth.,

Answer 3

The problem is that you're passing a NULL pointer in for the lpNumberOfBytesWritten / lpNumberOfBytesread parameter. While this is an optional parameter, there's a condition:

This parameter can be NULL only when the lpOverlapped parameter is not NULL

Also, you may have the size of your buffers wrong:

WriteFile(hin,buff,40,0,NULL);  // says that buff has 40 bytes

ReadFile(hout,buff2,40,0,NULL); // says that buff2 has 40 bytes

But if you're compiling for ANSI instead of UNICODE, these will only be 20 bytes in size.

You should probably use sizeof(buff) and sizeof(buff2) instead.

Answer 4

Assuming your initial code attempts to create the file as a new file, then you cannot use OPEN_EXISTING , you have to use OPEN_ALWAYS (or some other creational variant) on this call.

The OPEN_EXISTING usage for readback will be OK.

btw once this is fixed the WriteFile calls causes an access violation, as you are trying to write more bytes that your array contains.