DEV Community: Noah11012

Using SDL2: Events

Noah11012 — Tue, 18 Aug 2020 23:34:13 +0000

Games by definition need the quality of being interactive in order to be considered one. A video game typically is interacted through input devices like a joystick or gamepad on consoles and on PCs keyboards and mice are the preferred option. Keys are pressed, the mouse is moved and buttons are clicked.

All of these aforementioned actions produce what are called events. In SDL and like many other graphical libraries the way you find out what keys are pressed, the coordinates of the mouse and what, if any, mouse buttons are being clicked is by polling for events.

Internally, SDL has a queue or more specific an event queue. If you don't know what a queue is, you can more or less think about it as a line of people at the checkout. The first people to enter the line are the first people served. We call this a FIFO data structure or First In First Out.

As the user interacts more with the keyboard and mouse the more the queue is filled with events. Adding to the queue is called enqueuing and the opposite is called dequeuing where you take items off the queue or polling as it is referred to in SDL.

To poll events off the queue, use the SDL_PollEvent function.

The only argument it takes is a pointer to an SDL_Event structure which is basically an enum plus a union. For any type of event that SDL sends to the queue and can be polled by the programmer there is a corresponding event structure that is placed in the union of SDL_Event.

For example, if the event's type is equal to the enum constant SDL_MOUSEMOTION this means the mouse has moved within confines of the window and can be accessed through the structure SDL_MouseMotionEvent to get the relevant information that the programmer needs. The SDL documentation provides all possible events that can be generated here: https://wiki.libsdl.org/SDL_Event

Because it is possible to have multiple events on the queue at any given time, it is desirable to continuously poll the queue until we exhaust it. SDL_PollEvent returns one if we still have events on the queue and zero if empty.

#include <iostream>
#include <SDL2/SDL.h>

/* Helper function to convert the number mapped to the buttons
   on the mouse to a readable string. This function does
   not handle all possible mouse buttons. */
char const *convert_button_number_to_string(int button)
{
    char const *result = "NO_BUTTON";
    switch (button)
    {
        case SDL_BUTTON_LEFT:
        result = "left";
        break;

        case SDL_BUTTON_MIDDLE:
        result = "middle";
        break;

        case SDL_BUTTON_RIGHT:
        result = "right";
        break;

        default:
        break;
    }

    return result;
}

int main()
{
    SDL_Init(SDL_INIT_EVERYTHING);
    SDL_Window *window = SDL_CreateWindow("SDL2 Window",
                                          SDL_WINDOWPOS_UNDEFINED,
                                          SDL_WINDOWPOS_UNDEFINED,
                                          1280,
                                          720,
                                          0);

    SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0);
    SDL_Event event;
    bool running = true;
    while (running)
    {
        while (SDL_PollEvent(&event) > 0)
        {
            switch (event.type)
            {
                case SDL_QUIT:
                std::cout << "Quitting application\n";
                running = false;
                break;

                case SDL_MOUSEMOTION:
                std::cout << "Mouse Position = { "
                          << event.motion.x << " "
                          << event.motion.y << " }\n";
                break;

                case SDL_MOUSEBUTTONDOWN:
                case SDL_MOUSEBUTTONUP:
                std::cout << convert_button_number_to_string(event.button.button)
                          << " mouse button " << ((event.button.state == SDL_PRESSED) ? "pressed" : "released");
                std::cout << "\n";
                break;

                case SDL_KEYDOWN:
                case SDL_KEYUP:
                std::cout << "Key " << (char)event.key.keysym.sym << " "
                          << ((event.key.state == SDL_PRESSED) ? "pressed" : "released") << "\n";
                break;
            }
        }

        SDL_RenderPresent(renderer);
    }

    SDL_DestroyWindow(window);
    SDL_Quit();
}

Above is something to help you get started with SDL events. It only handles very basic events like closing of the application, key presses and mouse events like movement and use of the mouse buttons.

To find this and the rest of the code for the series up to this point and in the future go to the SDL2 Tutorial Code repository: https://github.com/Noah11012/sdl2-tutorial-code

And I'll see you all in my next article!

String Internalization

Noah11012 — Sun, 24 Feb 2019 03:31:53 +0000

Many modern interpreted programming languages like Python and Lua have a builtin feature that allows for O(1) comparisons of strings. Ordinarily, comparing two strings is a O(min(x, y)) operation that for huge strings can cause slow downs in performance. Compilers and interpreters can utilize this to their advantage to improve performance when checking against keywords and such. This will hopefully allow the programmer to focus on the more important tasks on hand like lexing, parsing, and generation of assembly instructions or byte code.

How does string internalization work? Like all other problems when related to the computer and the world, everything has a trade off. The two main ones are efficiency and memory usage and consumption. Some solution to a problem may have a small footprint when it comes to memory but might be slow comparatively to something that uses more memory but is more efficient. There are a few ways we can go about to internalize a string but we will do it how I have been doing it.

First, we need a data structure to store the strings themselves and to solve that we will use a stretchy buffer. If you don't know, they were invented by Sean Barrett and is similar to C++'s std::vector. Because this article is dealing with string internalization, we will not focus on the implementation details of a stretchy buffer.

// If buffer is NULL, create it and push the item.
// If buffer is full, reallocate and push the item.
#define buffer_push(buffer, item) ...

// Gets the length of a stretchy buffer.
#define buffer_length(buffer) ...

When it comes time to compare two internalized strings, what is actually being compared? Well, in our version, it is the memory address of the strings. If both are the same, then the strings are the same, if not, then the strings are not the same.

When we internalize a string, we will have to search the list and compare each entry against the one we are trying to internalize. This is the price we pay, but in the long is worth it as you can hold onto the memory address long as you want to.

/* Where all internalized strings will be stored. */
static char *inter_strings;

char const *string_internalize(char const *string)
{
    /* Search if the string already exists in the list. */
    int i = 0;
    while(i < buffer_length(inter_strings))
    {
        /* If found, return the internalized string. */
        if(string_compare(string, inter_strings))
            return inter_strings;
        ++i;
    }

    /* If not found, create internalized copy and return it. */
    char* new_string;
    int string_len = string_length(string);

    new_string = calloc(string_len + 1, sizeof(char));

    memory_copy(new_string, string, string_len);

    buffer_push(inter_strings, new_string);

    return new_string;
}

This is definitely a short one, but thought it was something that might be helpful.

C++ References

Noah11012 — Tue, 05 Feb 2019 01:37:25 +0000

C++ is backward compatible with C so it inherited pointers. A quick recap if you don't know what a pointer is: a pointer is a variable that holds the memory address of an object. Declaring a pointer involves the type of object we are pointing to and the symbol '*'.

Example:

int value = 10;
int *ptr_value = &value;

double vaule2 = 506.305;
double *ptr_value2 = &value;

We have our pointer, but how do we get an object's memory address? With the ampersand symbol (&).

To access data through a pointer, we need to do what is called dereferencing. This again includes the use of the * symbol.

printf("value: %d\n", *ptr_value);
printf("value2: %f\n, *ptr_value2);

Now that the recap is over, we can move onto references.

C++ introduced references as an alternative to pointers. References were designed to be simpler, safer, and easier to read when in use. To create a reference is similar to how we declare a pointer. First, we need the type and the symbol '&'.

int value = 200;
int &ref_value = value;

Notice we don't have anything extra on the right-hand side as we had with pointers. The only extra symbol in this statement is the & symbol on the left.

Another benefit is obvious when it is time to retrieve value from the reference:

std::cout << ref_value << "\n";

There are no extra symbols cluttering the code. Viewing small examples of dereferenced pointers may not show the cognitive burden that may be placed on someone when viewing a larger block of code that has several dereferences going on in a short amount of time.

References, as aforementioned, are safer. Going back to pointers for a moment, a pointer can be within a state of "invalidness". This could mean two things:

The pointer is declared but has no initializer and is subsequently default-initialized

Within local scope, if a variable is not provided with an initial value at creation, a garbage value is left there. Most likely, it was some value left over from some memory previously that we are now occupying. Accessing a default-initialized object is undefined behavior and dereferencing a default-initialized pointer is also undefined behavior.

Null Pointers

A null pointer is a special kind of pointer. Usually, it is a way to say, "Hey, I'm not in use right now, but I am still explicitly initialized!". Null pointers have a place in API design. Many C functions that return a pointer may instead return a null pointer on error. Despite it being "safer" than the previous type of invalid pointer, dereferencing a null pointer is undefined behavior.

At the creation of a reference, it must have an initial value to bind. Failure to do so is a compile time error. Also, a reference is bound to one value for its entire lifetime.

However, references have their weaknesses, too. Like pointers, a reference can "dangle": referring to a space of memory that is freed.

Example:

int &return_five()
{
    int value = 5;
    return &value;
}

int some_value = return_five();
std::cout << some_value << '\n'; // undefined behavior

return_five() is a function that creates a variable and returns it. This may appear innocent to the inexperienced but this program is in error. This value being returned is created on the stack and when the function returns, the stack frame is destroyed and so is the variable inside.

By the time we return the main function, the reference some_value is now referring to freed memory and is a dangling reference.

The Conclusion

References, in theory, are a better alternative to pointers in some regards. Providing a simpler syntax at creation and accessing bounded values. The restraints in place eliminate some of the problems that using pointers may arise.

Socket Programming in C: Communication Styles

Noah11012 — Sat, 26 Jan 2019 14:35:28 +0000

Being there are multiple different types of sockets available for our use, we will take a brief look at some of them. When we get to socket creation, the second argument takes a number that represents the communication style. Each number has a symbolic constant.

1. SOCK_STREAM

A socket that streams data over a connection like a cable or a pipe. It transmits data like a stream of bytes reliably.

2. SOCK_DGRAM

This style of sockets doesn't have a connection but instead, each packet is addressed and sent individually. Also, this an unreliable style of communication unlike SOCK_STREAM. Each data written to this kind of socket is converted into one packet. The only guarantee this socket gives you is it will try its best to transmit every packet you send.

3. SOCK_RAW

Most user-level programs will not use this kind of communication as it provides low-level access to protocols and interfaces.

Small Patterns and Idioms in C

Noah11012 — Sun, 20 Jan 2019 17:57:17 +0000

Patterns are constructs that programmers use to solve a general recurring problem. If a problem has deviated from the original, the pattern can be adapted to still be effective. In this article, we will learn a couple of them for the C programming language that I believe beginners and intermediates should know and start to apply them where ever possible.

1. Do-While Loop in Macros

If you need to use a temporary variable to store a value that will shortly be used in a macro, then it will "leak" into the local scope where it is used. The user will no longer be able to reuse the variable's name and if they do, the compiler will complain of a "redefinition". Some programmers solve this by giving a name that nobody else would use. Usually, this is a hash prefixed/suffixed onto the variable's name. The better way, in my opinion, is to use a do-while loop. When the loop goes out of scope, so do the variables and there is no "leakage". A do-while loop will always run at least once even if the while's condition is false.

Example:

#include <stdio.h>

#define swap(type, a, b)  \  
    do                    \  
    {                     \  
        type temp = *b;   \  
        *b = *a;          \  
        *a = temp;        \  
    } while(0)            \  

int main()  
{  
    int a = 100;  
    int b = 200;  

    swap(int, &a, &b);  

    printf("Swapped values:\na = %d, b = %d\n", a, b);
}

2. Unions and Enums

Before we move on, let's make sure all of us understand what a union is. A union is like a structure but with one stipulation: only one member can be used at a time. You can think unions as types that change depending on what type of value we want to store. An example of using a union can found when processing tokens in a compiler/interpreter. Some tokens may be an integer, character, or string. Perfect place for a union. But there is one problem: the union doesn't give us the information about what type is currently in use. That's where enums come in. An enum or enumeration is a list of names that map to a number. The first member is, by default, equal to zero and subsequent values are one plus the previous value. One of the uses of an enumeration is listing the possible values. In our case, this would be the list of possible tokens that we can accept.

Examples:

typedef enum  
{              
    INT,  
    CHAR,  
    STRING  
} TokenType;  

typedef struct  
{          
    TokenType type;  
    union  
    {          
        int  int_value; 
        char char_value;  
        char *string_value;
    } value;
} Token;

Every time we encounter a token, we figure out what type it is, set type to the appropriate value and set the correct member in value. When the compiler/interpreter comes back to this list of tokens to form an AST or whatever it needs to do, it can look at the type and do the right operation.

Conclusion

Programmers can use the language's ability for leverage to solve problems that pop up every now and then. Sometimes we see two features paired and used in tandem like in the last entry.

For now, this is a standalone post but may in the future, close or far, be a series.

Socket Programming in C: What is a Socket?

Noah11012 — Wed, 16 Jan 2019 19:35:01 +0000

This is the post that marks the beginning of this series. A journey, when arrived at the end, will give you control over sockets. No longer will they be disorderly or out of your reach because you will be the one to have dominion over them. Bending their will to yours and serving your every whim.

People dream to have this kind of power and you can be the one to achieve it only if you read this series to its conclusion.

Of course, you can still get this kind of power from other great tutorials out on the internet but it would be appreciated if you stuck till the very end.

Let us begin this journey!

What is a socket? Simply put, a socket is an endpoint for where the data will be sent to and received. Sockets are used as a generalized means of communication between different processes on the same computer or one on the same network. Because everything in a Unix based OSes is a file or can be represented as one, processes identify sockets by their file descriptor.

Sockets come in different flavors. Each flavor specifies the guarantees and leniency that is given. From now on this will be known as communication styles. Next, what protocol is used? This is where the low-level details and mechanisms tell how the data is transmitted and received.

Communication styles can be thought of as a series of questions that are given a different answer depending on the socket's communication style.

Units used?

Some styles regard data as simply bytes with no structure whatsoever. Others think data as being grouped into a structure determined by the style.

Loss during transmission?

Will the occasional drop of a packet matter overall? Will the packets received on the other end be in the same order as it was sent? Some styles guarantee that all packets transmitted will be retrieved in the same order and that if a packet is dropped, it is resent. Other styles of communication may allow some packets to drop. Packets may also arrive more than once and out of order. Programmers who use such sockets must place safeguards in their code to accommodate for the unreliability of this communication style.

Partner?

The traditional way of thinking a socket is similar to the client-server relationship, where both parties can freely exchange data with each other. There is also a one-sided version: stamp the address and send the data on its way.

How do we set the endpoint for a socket? Each socket is paired with a socket address, or in other words, the IP address and a port number. Setting a socket's address is called binding.

For the next article, we will discuss the different kinds of communication styles that we can use.

Socket Programming in C: Introduction

Noah11012 — Tue, 15 Jan 2019 19:24:38 +0000

Today I am announcing a new series that is underway. The series will teach socket programming in C and will hopefully provide material that is clear and easy to understand especially for those new to sockets and wanting to learn. Plus, if you stick till the end, a reward in the form of a final project is made that I think you will all enjoy.

Why Learn Socket Programming

In the next post, where I will go into more depth to what a socket is, provides a means of communication between two processes which could be across the world provided they are both on the same network. You may want to learn sockets to do just this. Another reason is simply to learn. Nothing wrong with increasing your knowledge about the world around you and becoming more informed in the process.

Prerequisites

This series assumes its audience has little to none experience with sockets. With that being said, you will still need how to program in C or even C++.

The next post will talk more about sockets.

Reading and Writing Files in C: Part 5

Noah11012 — Mon, 14 Jan 2019 16:24:00 +0000

Just as I promised, we will write and subsequently read back a C structure! One caveat though: you need to know about binary files. You can learn more in the previous article.

For testing, the following structure will be used:

struct TestStruct
{
    int    a;
    double b;
};

First, a connection to a file, specifically, a binary file is needed. Next, we create an instance of TestStruct and set our desired values. Finally, using fwrite() to write the structure into the file.

#include <stdio.h>

typedef struct
{
    int    a;
    double b;
} TestStruct;

int main(void)
{
    FILE *file = fopen("test", "wb");

    TestStruct ts;
    ts.a = 105;
    ts.b = 194.543;

    fwrite(&ts, sizeof(TestStruct), 1, file);
    fclose(file);
}

Output:

~/Desktop 
➜ clang main.c 

~/Desktop 
➜ ./a.out 

~/Desktop 
➜ cat test 
i!VL7�A`Qh@%                                                                    
~/Desktop 
➜

Trying to output a file that is saved with a C structure results in garbage.

Let's now read back in the data and see if everything is still correct.

#include <stdio.h>

typedef struct
{
    int    a;
    double b;
} TestStruct;

int main(void)
{
    FILE *file = fopen("test", "rb");

    TestStruct ts;

    fread(&ts, sizeof(TestStruct), 1, file);
    fclose(file);

    printf("ts.a = %d\nts.b = %f\n", ts.a, ts.b);
}

Output:

~/Desktop 
➜ clang main.c 

~/Desktop 
➜ ./a.out     
ts.a = 105
ts.b = 194.543000

~/Desktop 
➜

Everything was written and read properly.

This is a short article and there is more to explore but I feel everything that was taught in this series will provide many people with adequate knowledge to accomplish basic and more difficult problems relating to files.

Reading and Writing Files in C: Part 4

Noah11012 — Mon, 14 Jan 2019 00:35:49 +0000

For the last three posts, we have only handled text and nothing more. But now we will delve into binary files and how to read from and write to it. I'm sure the first question if don't know what a binary file is, "What is it?". Good question especially for something we are about to use.

A binary file is a file that isn't intended to be read like text. Instead, they are based more on numerical values.

When opening a binary file, the mode is additionally set to binary and we do this by simply appending a 'b' to the end.

Example:

FILE *binary_file = fopen(path, "rb");

Two functions you will be familiarized with are fread() and fwrite(). Usually, they are reserved for working with binary files but are as capable of operating on text files.

Both have the same number of arguments and all but the first have the exact same purpose. The first argument for fwrite() is where the data will be transferred from to the file whereas in fread() it is the destination for any data read from a file. Because the first argument's type is a void pointer, we can receive or transmit any type of data. The second is the size of each object. The third is how many objects we want to read/write. And finally, the fourth and last is the file stream.

I feel like you now deserve an example:

#include <stdio.h>

int main(void)
{
    FILE *file = fopen("test", "wb");

    int numbers[4] = { 65, 66, 67, 10 };
    fwrite(numbers, sizeof(int), 4, file);
    fclose(file);
}

Output:

~/Desktop 
➜ clang main.c 

~/Desktop 
➜ ./a.out 

~/Desktop 
➜ cat test 
ABC

~/Desktop 
➜

If you try to open the file that was written with a text editor, most likely it will complain at you with the error "Unknown encoding" or something similar. If you use a terminal command like cat you will see the contents is A, B, and C.

Even though we didn't write any text, we used the character's corresponding ASCII value. And if you didn't know, the number 10 is the ASCII value for a newline.

For the next post, we'll leverage them a bit more to read and write entire C structures!

Function Pointers in C

Noah11012 — Sun, 13 Jan 2019 03:22:51 +0000

My last article was about a topic that most beginners found challenging when first confronted: double pointers

Well, in this post, we will take a look at another class of pointers: function pointers

At their essence, function pointers are like their normal counterparts: a variable that holds the memory address of an object. Function pointers fulfill this role but the object they refer to have a special quality: they are callable. When an object is callable, the operator () can be used. The only callable objects in C are functions but in C++ some of the additions are classes that overload the call operator.

The syntax for defining a function pointer is considered the more quirky of the language and some beginners find it difficult to discern. So, we will start with a basic example:

void (*function_pointer)(void);

To better help ourselves learn the syntax of function pointers, we will tease it apart slowly. One thing that pops out immediately is the appearance of braces around *function_pointer. These parentheses are important and without them it means something entirely different. With the exclusion of the parentheses, it means a function that takes no input and returns a void pointer.

void *function_pointer(void);

Another thing that makes a function pointer a pointer is the use of the symbol *. All pointers have them and function pointers are no different but they are within the braces. Everything else can be read the same. To help with reading function pointers, remove the braces and * and read it like it is a normal function.

Example:

int *(*function_pointer)(int *, double *);

Remove the braces and *.

int *function_pointer(int *, double *);

Cleaner and easier to parse with our eyes! We now know this function pointer points to a function that takes an int * and a double * and returns a
int *.

Now, like everything else that is learned, what are the uses for function pointers?

Function pointers can be passed as an argument to another function which will be called within. These function pointers are known as callbacks. For example, let's say we have a function that downloads something from the internet and takes a function pointer. When the download is complete or an error has happened, we would like to execute the callback.

void download_file(const char *file, void (*callback_function)(int status_code));

Using our method of stripping away the braces and * we get a function pointer that refers to a function that accepts an int but returns nothing.

Another example of where function pointers can be utilized is event programming. Event programming in its simplest form is the idea when an event happens, do this. A perfect place for function pointers!

Let's say we have a GUI widget library and we have a function that sets up a callback that is called when a click has been detected on a button.

struct Button;

void button_set_click_event(Button *button, void (*on_click)(Button *button));

I'm sure by now you can parse what the callback is pointing to.

Summary

The concept of function pointers is easy to learn, but the syntax isn't the greatest and can leave someone confused when trying to analyze them. I hope this article helped and that any confusion you might have is now gone.

Double Pointers in C/C++

Noah11012 — Sat, 12 Jan 2019 18:14:47 +0000

One source of confusion among new C programmers is pointers. At first glance, there doesn't seem to be much usefulness in using them. But, it is crucial to understand pointers as it is a useful tool and any project bigger than a "Hello, World" program will have pointers. Once beginners start to grasp the concept and applicability of pointers, another wave of terror strikes deep into their hearts: double pointers.

Before moving on any further, let's recap what a pointer is.

In C and other languages like C++, a pointer is something that holds the memory address of an object. They are a numeric value and when outputted to the console they are usually presented in hexadecimal. This means, essentially, pointers are just fancy integers.

Now back to double pointers.

Upon seeing a double pointer, a beginner begins to shift uncomfortably, sweat running down their forehead all the way to their chin. Like everything else in life that is new or foreign, people feel awkward and uneasy even just slightly at the prospect of facing something they have never encountered before. But as you learn more, you start to feel confident in your new understanding of anything you desired to conquer. The same goes with double pointers.

So, what is a double pointer? Well, if a regular pointer is to refer to an object in memory, then a double pointer is a variable that points to another pointer which in turn, points to an object in memory.

Examples:

#include <stdio.h>

int main(void)
{
    int value = 100;
    int *value_ptr = &value;
    int **value_double_ptr = &value_ptr;

    printf("Value: %d\n", value);
    printf("Pointer to value: %d\n", *value_ptr);
    printf("Double pointer to value: %d\n", **value_double_ptr);
}

Output:

~/Desktop 
➜ clang main.c

~/Desktop 
➜ ./a.out     
Value: 100
Pointer to value: 100
Doublue pointer to value: 100

~/Desktop 
➜

When dereferencing a double pointer, we do not get the final object, but what is expected: a pointer that must be dereferenced one more time to retrieve the final value. It would be similar to the code below.

int *ptr = *value_double_ptr;
int final_value = *ptr;

Now I'm sure that most who are new to double pointers must be asking themselves the question, "Where will I ever use this?". Probably the best way to present the usefulness of double pointers is to remember one of the practical uses of regular pointers. This is to say, regular pointers can be used as an output parameter in functions. An output parameter, if you happen to not know, is a parameter that is filled with a result. Why you would use output parameters is subject to several factors and is beyond the scope of this article but I felt this is where double pointers can be utilized.

A function that we will take a look at is the POSIX getline() function. Its purpose is to read one line from a file. When the line is read, one might suspect it to be returned, but, this is not the case as the return value is used for something different. Instead, the first argument, which takes a double pointer, is filled with the buffer that contains the line.

Why does it take a double pointer? So, that it can allocate enough memory to hold the entire line plus the null terminator character. If memory allocation and reading the one line is successful, then the pointer supplied is modified to point to the new and filled buffer. They could have only achieved this if they were using a double pointer.

When passing anything to a function, a copy is passed and not the actual object. The same goes for a pointer. If we passed a regular pointer, we could only modify the contents that the pointer points to. If we changed the pointer itself, the change would not reflect outside of the function because it is a copy.

If we want to change where the pointer points to, we have to add another indirection and take a double pointer.

An example of using getline() might be the following.

#include <stdio.h> 

int main(void)
{   
    FILE *file = fopen("test", "r");

    char *line = 0;
    int   line_length = 0;
    getline(&line, &line_length, file);

    printf("%s\n", line);
    printf("Line length: %d\n", line_length);
}

getline() has two output parameter: one for the buffer and the other for the length of the line that was read in.

Summary

Double pointers are a challenge to many beginners immediately when first learned. As you become more comfortable with the idea of double pointers and use them when necessary in your own code, you start to think how silly that once you were afraid of double pointers.

And now I send you off with your new knowlegde!

Reading and Writing Files in C: Part 3

Noah11012 — Thu, 10 Jan 2019 02:10:56 +0000

In the last section of the previous article, I promised that we would discuss some of the different errors that potentially could happen. While it is not necessary to learn about the different errors that could pop up, it is, however, educational and informative to know about the different errors that might come up when working with files.

Moved/Deleted

For some programs, a file is used to record the date and time of certain operations committed by the program and errors. If a user or some other program moves the file to another location or deletes it, then write operation, in theory, could fail and the program will (hopefully) recover gracefully. This usually involves recreating the file and writing all new entries that the program chooses to record. This most likely won't happen with files that are shortlived because, well the name implies, will not be around for very long for a user to move or delete. In Windows, if a file is opened by a process, you are not allowed to move or delete it. On Unix based OSes, a move or deletion of a file is considered acting upon the directory where the file resides. If open and deleted, it will remain on disk until closed.

Operations After Closing

Each operating system exposes an API for us to get resources that only it can provide. One of these resources is files. On Unix based OSes like Linux, the system call open() exists. Before allowing us to open the file, the OS must make sure that we have the permission to do so and, of course, exists on the hard drive. Once the OS has concluded that we are not in any violation of any permissions and can locate the file on the disk, it will return an ID for us to use. This ID is a numeric value and in the context of our program is assigned to an opened file. When we're done with the file, we have to let the OS know to close the file. For Unix basic OSes like Linux, close() does this. In the C standard library file I/O library, this is fclose(). Doing any operations with a file that has been closed will result in an error.

Example:

#include <stdio.h>

int main(void)
{
    FILE *file = fopen("test", "r");
    fclose(file);
    char buffer[100];
    if(fgets(buffer, 5, file) == 0)
    {
        printf("Error reading file!\n");
        return 1;
    }
    printf("%s\n", buffer);
}

Output:

~/Desktop 
➜ clang main.c 

~/Desktop 
➜ ./a.out 
Error reading file!

~/Desktop 
➜

Full Storage

If the storage medium that is currently being used is at maximum storage capacity then there isn't much to do except for freeing space up by deleting files.

Faulty Hardware

Failing hard drives can and will cause file I/O operations to fail. Because of the unstable nature of a deteriorating storage medium, you may not even get an error from the OS, but is still an error nonetheless because the data that is read/written might be corrupted.

For the next part, we will discuss how to save more than just text in a file.