C on BadproG

C - Type - Converting two uint8_t words into one of uint16_t and one of uint16_t into two of uint8_t

Thu, 18 Jul 2013 00:00:00 +0000

Sometimes you need to convert one uint16_t variable into two uint8_t.

As we manipulate binaries, it’s impossible to do something like that: 0xAB + 0xCD = 0xABCD.

Indeed, the result of 0xAB + 0xCD = 0x178 because 0xAB = 171 and 0xCD = 205.

So 0xAB + 0xCD = 376 in decimal but 0x178 in hexadecimal.

Furthermore, we cannot add more than 255 value inside a byte, because this is a 8-bit long number.

C - Binary - Operation with decimals

Mon, 18 Feb 2013 00:00:00 +0000

A good way to understand binary operations is to play with decimals.
What?!

Yes, if you can manipulate decimals like binaries, then you can say “OK! I’ve understood how binary works”.

Let’s check this with this binary-operation tutorial with decimal numbers.

Explanation

In the code below I’m starting with a XOR operation.
I’m doing number XOR mask.
number = 4.
mask = 7.

And the result is 3.

What happened exactly?

C - Type - What are uint8_t, uint16_t, uint32_t and uint64_t?

Thu, 14 Feb 2013 00:00:00 +0000

You are likely wondering what are uint8_t, uint16_t, uint32_t and uint64_t.
That’s a good question. Because it could be really helpul!

It turns out that they are equal respectively to: unsigned char, unsigned short, unsigned int and unsigned long long.
But what are ranges of all these types?

Let’s test it in this C type tutorial.

Explanation

We’re going to use a variable called testValue equal to 0xFFFFFFFFFFFFFFFF.

Notice that 0xFFFFFFFFFFFFFFFF is the same as 18**,446,744,073,709,**551,615 and this is the maximum value possible for an unsigned long long, depending on your processor architecture (as gineera said in its comment).

C - Tips'n Tricks - Creating a clock with six numbers after the decimal point

Thu, 05 Jul 2012 00:00:00 +0000

Everyone knows that a clock is essential in a video game.

And the more the clock is precise, the more we can do things.

That’s what we are going to see in this clock tutorial by creating a clock with six numbers after the decimal point.

The code

/* BadproG.com */
#include <stdlib.h>
#include <stdio.h>
#include <sys/time.h>
#include <time.h>

int clockTime();

int main(void)
{
    if (clockTime())
        return (1);
    return EXIT_SUCCESS;
}
/**
 * A clock with six numbers after the decimal point
 */
int clockTime()
{
    time_t t;
    struct timeval tv;
    double gtod;
    double theTime;
    theTime = 0;
    gtod = 0;
    t = time(NULL);
    while (t < 2000000000)
    {
        t = time(NULL);
        gtod = gettimeofday(&tv, NULL);
        if (gtod != 0)
        {
            fprintf(stderr, "Error: clockTime().\n");
            return (1);
        }
        theTime = (double)tv.tv_sec + (double)tv.tv_usec / 1000000;
        printf("theTime = %f\n", theTime);
    }
    return (0);
}

The result

...
theTime = 1341489768.809641
theTime = 1341489768.809655
theTime = 1341489768.809670
theTime = 1341489768.809684
theTime = 1341489768.809698
theTime = 1341489768.809712
theTime = 1341489768.809726
theTime = 1341489768.809740
theTime = 1341489768.809755
theTime = 1341489768.809769
theTime = 1341489768.809783
theTime = 1341489768.809798
theTime = 1341489768.809812
theTime = 1341489768.809826
theTime = 1341489768.809840
theTime = 1341489768.809855
theTime = 1341489768.809869
theTime = 1341489768.809884
...

You can now check an action more quickly than before. You made it, well done.

C - Tips'n Tricks - Retrieve temperature of hardware devices

Thu, 05 Jul 2012 00:00:00 +0000

The file from where we can retrieve temperature depends on the operating system.
For this tutorial I used Ubuntu 12.
The file on which I took temperature is /sys/class/thermal/thermal_zone8/temp.

So you can test temperature of each file present in /sys/class/thermal/thermal_zone[0-9]/temp.

On some GNU/Linux systems, files needed are sometimes in the /proc/acpi/thermal_zone/ directory.

In the example below the heart of the code is in the main() function.
All other functions are for testing that malloc(), open(), read(), close() and free() are called without any error.

C - Mathematics - Using the Luhn algorithm

Tue, 24 Apr 2012 00:00:00 +0000

Maybe you wonder if your credit card has a correct number?

How to know that?
With the Luhn formula!
This is what we are going to see in this Luhn tutorial.

This algorithm can say if it is a good or a bad credit card number.

Indeed, for that we first of all have to reverse the complete number.

For example, the number to test is 1234567897.

Once reversed, we have 7987654321.

C - Mathematics - Find prime numbers

Mon, 23 Apr 2012 00:00:00 +0000

If you have a good computer, you can maybe try to find the last prime number that nobody found yet.

Indeed, you can even win a prize for that!
But you have to find a number with more than millions of digits.

I’m sure you can do it.

For the moment, let’s see how to find these numbers in this prime number tutorial.

Arguments are a range: the minimum and the maximum numbers.

C - Mathematics - Fraction simplifier

Mon, 23 Apr 2012 00:00:00 +0000

Today, I inaugurate a new C section: mathematics.

The first tutorial is a way to simplify a fraction.

I put all data in a structure that I typedefined as t_bp.
I also made 3 files: main.c, misc.c and h.h.
There is also an error manager inside the code.

For example, the numbers allowed are 1 until 9. So if you type something else, it will generate an error.

And of course, you have to enter 2 arguments: the numerator and the denominator.
Notice that in this program you can use negative numbers.

C - Library functions - Using inet_ntoa()

Fri, 20 Apr 2012 00:00:00 +0000

The inet_ntoa() function C returns the address of a client side, for example.

We give to the unique inet_ntoa() parameter, a struct in_addr.
We can then retrieve the address of this parameter.

Let’s look it in this tutorial with an example of code.

Using inet_ntoa()

server.c

/* server.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>


#include "h.h"

void my_socket(t_s *s)
{
    s->name    = "TCP";
    s->domain    = AF_INET;
    s->type    = SOCK_STREAM;
    s->pe        = getprotobyname(s->name);
    s->fd        = socket(s->domain, s->type, s->pe->p_proto);
    check_error(s->fd, -1);
}

void my_bind(t_s *s, int port)
{
    s->sockfd                = s->fd;
    s->addr.sin_family        = s->domain;
    s->addr.sin_addr.s_addr = INADDR_ANY;
    s->addr.sin_port        = htons(port);
    s->addrlen                = sizeof(s->addr);
    s->bindValue            = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
    check_error(s->bindValue, -1);
}

void my_listen(t_s *s, int backlog)
{
    s->listenValue = listen(s->sockfd, backlog);
    check_error(s->listenValue, -1);
}

void my_accept(t_s *s)
{
    s->addrlenAccept = sizeof(s->addrAccept);
    s->acceptValue = accept(s->sockfd, (struct sockaddr *)&s->addrAccept, &s->addrlenAccept);
    check_error(s->acceptValue, -1);
    s->acceptAddr = inet_ntoa(s->addrAccept.sin_addr);
    check_null(s->acceptAddr);
}

int main(int ac, char *av[])
{
    t_s s;

    check_arg(ac, ARG_SIZE);
    my_socket(&s);
    my_bind(&s, atoi(av[1]));
    my_listen(&s, BACKLOG);
    my_accept(&s);
    debug(&s);
    check_error(close(s.acceptValue), -1);
    check_error(close(s.fd), -1);
    return 0;
}

debug.c

/* debug.c */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>

#include "h.h"

void debug(t_s *s)
{
    printf("\n===== socket() =====\n");
    printf("domain = %d\n", s->domain);
    printf("type = %d\n", s->type);
    printf("fd = %d\n", s->fd);
    printf("name = %s\n", s->name);
    printf("p_proto = %d\n", s->pe->p_proto);

    printf("\n===== bind() =====\n");
    printf("sockfd = %d\n", s->sockfd);
    printf("sin_family = %d\n", s->addr.sin_family);
    printf("sin_addr.s_addr = %d\n", s->addr.sin_addr.s_addr);
    printf("sin_port = %d\n", s->addr.sin_port);
    printf("addrlen = %d\n", s->addrlen);
    printf("bindValue = %d\n", s->bindValue);

    printf("\n===== listen() =====\n");
    printf("listenValue = %d\n", s->listenValue);

    printf("\n===== accept() =====\n");
    printf("addrlenAccept = %d\n", s->addrlenAccept);
    printf("acceptValue = %d\n", s->acceptValue);
    printf("s->acceptAddr = %s\n\n", s->acceptAddr);
}

void check_error(int test, int error)
{
    if (test == error)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}

void check_null(char *test)
{
    if (test == NULL)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}

void check_arg(int ac, int number)
{
    if (ac < number)
    {
        printf("Usage: ./server [PORT]\n");
        exit(EXIT_FAILURE);
    }
}

h.h

#ifndef H_H_
#define H_H_

#include <netdb.h>

/**
 * Define
 */
#define ARG_SIZE 2
#define BACKLOG 10
#define BUF_SIZE 255

/**
 * Structure
 */
typedef struct mystruct
{
    /* socket */
    int domain;
    int type;
    int fd;
    char *name;
    struct protoent *pe;

    /* bind */
    int sockfd;
    socklen_t addrlen;
    struct sockaddr_in addr;
    int bindValue;

    /* listen */
    int listenValue;

    /* accept */
    int acceptValue;
    socklen_t addrlenAccept;
    struct sockaddr_in addrAccept;
    char *acceptAddr;

    /* read & write */
    int readValue;
    int writeValue;
    char buf[256];
} t_s;

/**
 * Prototype
 */
void debug(t_s *);
void check_error(int, int);
void check_null(char *);
void check_arg(int, int);

#endif /* H_H_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Now that the server is launched, it’s waiting a connection from a client on the port 5000.

C - TCP/IP - Writing and reading on a socket

Fri, 20 Apr 2012 00:00:00 +0000

This tutorial will help us to understand how to write and read on a client side and display the result on the server side.

So, for that, we have to create a server and a client.
The client will be the nc tool (or telnet if you prefer, this is the same for this example).

Let’s see this with an example.

Writing and reading on a socket

server.c

/* server.c */
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <string.h>
#include "h.h"
void my_socket(t_s *s)
{
    s->name    = "TCP";
    s->domain    = AF_INET;
    s->type    = SOCK_STREAM;
    s->pe        = getprotobyname(s->name);
    s->fd        = socket(s->domain, s->type, s->pe->p_proto);
    check_error(s->fd, -1);
}
void my_bind(t_s *s, int port)
{
    s->sockfd                = s->fd;
    s->addr.sin_family        = s->domain;
    s->addr.sin_addr.s_addr = INADDR_ANY;
    s->addr.sin_port        = htons(port);
    s->addrlen                = sizeof(s->addr);
    s->bindValue            = bind(s->fd, (const struct sockaddr *)&s->addr, s->addrlen);
    check_error(s->bindValue, -1);
}
void my_listen(t_s *s, int backlog)
{
    s->listenValue = listen(s->sockfd, backlog);
    check_error(s->listenValue, -1);
}
void my_accept(t_s *s)
{
    s->addrlenAccept = sizeof(s->addrAccept);
    s->acceptValue = accept(s->sockfd, (struct sockaddr *)&s->addrAccept, &s->addrlenAccept);
    check_error(s->acceptValue, -1);
    s->acceptAddr = inet_ntoa(s->addrAccept.sin_addr);
    check_null(s->acceptAddr);
}
void my_write(t_s *s)
{
    const char *message = "Hello, please enter your name: ";
    s->writeValue = write(s->acceptValue, message, strlen(message));
    check_error(s->writeValue, -1);
}
void my_read(t_s *s)
{
    bzero(s->buf,256);
    s->readValue = read(s->acceptValue, s->buf, BUF_SIZE);
    check_error(s->readValue, -1);
}
int main(int ac, char *av[])
{
    t_s s;
    check_arg(ac, ARG_SIZE);
    my_socket(&s);
    my_bind(&s, atoi(av[1]));
    my_listen(&s, BACKLOG);
    my_accept(&s);
    my_write(&s);
    my_read(&s);
    debug(&s);
    check_error(close(s.acceptValue), -1);
    check_error(close(s.fd), -1);
    return 0;
}

debug.c

/* debug.c */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include "h.h"
void debug(t_s *s)
{
    printf("\n===== socket() =====\n");
    printf("domain = %d\n", s->domain);
    printf("type = %d\n", s->type);
    printf("fd = %d\n", s->fd);
    printf("name = %s\n", s->name);
    printf("p_proto = %d\n", s->pe->p_proto);
    printf("\n===== bind() =====\n");
    printf("sockfd = %d\n", s->sockfd);
    printf("sin_family = %d\n", s->addr.sin_family);
    printf("sin_addr.s_addr = %d\n", s->addr.sin_addr.s_addr);
    printf("sin_port = %d\n", s->addr.sin_port);
    printf("addrlen = %d\n", s->addrlen);
    printf("bindValue = %d\n", s->bindValue);
    printf("\n===== listen() =====\n");
    printf("listenValue = %d\n", s->listenValue);
    printf("\n===== accept() =====\n");
    printf("addrlenAccept = %d\n", s->addrlenAccept);
    printf("acceptValue = %d\n", s->acceptValue);
    printf("s->acceptAddr = %s\n", s->acceptAddr);
    printf("\n===== write() & read() =====\n");
    printf("s->buf = %s\n\n", s->buf);
}
void check_error(int test, int error)
{
    if (test == error)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}
void check_null(char *test)
{
    if (test == NULL)
    {
        fprintf(stderr, "ERROR: %s\n", strerror(errno));
        exit(EXIT_FAILURE);
    }
}
void check_arg(int ac, int number)
{
    if (ac < number)
    {
        printf("Usage: ./server [PORT]\n");
        exit(EXIT_FAILURE);
    }
}

h.h

#ifndef H_H_
#define H_H_

#include <netdb.h>

/**
 * Define
 */
#define ARG_SIZE 2
#define BACKLOG 10
#define BUF_SIZE 255
/**
 * Structure
 */
typedef struct mystruct
{
    /* socket */
    int domain;
    int type;
    int fd;
    char *name;
    struct protoent *pe;
    /* bind */
    int sockfd;
    socklen_t addrlen;
    struct sockaddr_in addr;
    int bindValue;
    /* listen */
    int listenValue;
    /* accept */
    int acceptValue;
    socklen_t addrlenAccept;
    struct sockaddr_in addrAccept;
    char *acceptAddr;
    /* read & write */
    int readValue;
    int writeValue;
    char buf[256];
} t_s;
/**
 * Prototype
 */
void debug(t_s *);
void check_error(int, int);
void check_null(char *);
void check_arg(int, int);
#endif /* H_H_ */

Compiling

$ gcc server.c debug.c -o server ; ./server 5000

Now that the server is launched, it’s waiting a connection from a client on the port 5000.

C - Character manipulation - Converting a char into an int

Tue, 10 Apr 2012 00:00:00 +0000

We can of course transform a char into an int with the atoi() function.

But what we are going to do now it’s to create our own function to transform a string (several char) into a number.

The string passed as the first argument will be our string.
We are going to choose “140” for this example.
To be sure we type a string, we had the double quotes around it.

C - Keyword - Using extern

Mon, 09 Apr 2012 00:00:00 +0000

The extern keyword is designed to explicitely tells someone, being watching a variable in a code, that this variable has been firstly declared in another file.

The extern keyword works also with C++.

Let’s take an example.
In the code below, I use 2 files.
The first main.c where I declared the global_var variable.
And file1.c where I redeclared it as an extern variable.

So we can see that I can change the value of this variable from both files.

C - SDL (Simple Directmedia Layer) - Creating a multicolored window

Thu, 22 Mar 2012 00:00:00 +0000

May you want to create a night club with the SDL library?

It is maybe possible.
With the code below of this tutorial, you can generate a different color every millisecond.

So, why waiting?
Let’s dance!

#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <dlfcn.h>
#include <unistd.h>
#include <sys/time.h>
#include <SDL/SDL.h>

typedef struct s_sdl
{
	SDL_Surface *screen;
	SDL_Surface *rectangle;
	SDL_Rect *position;
} t_sdl;

int creation_rect(t_sdl *sdl, int r1, int r2, int r3)
{
	sdl->rectangle = NULL;
	if (SDL_FillRect(sdl->screen, NULL, SDL_MapRGB(sdl->screen->format, r1, r2, r3)) == -1)
	{
		fprintf(stderr, "Error: %s\n", SDL_GetError());
		return (1);
	}
	if (SDL_Flip(sdl->screen) == -1)
	{
		fprintf(stderr, "Error: %s\n", SDL_GetError());
		return (1);
	}
	return (0);
}

int init(t_sdl *sdl)
{
	int i = 0;
	if (SDL_Init(SDL_INIT_EVERYTHING) == -1)
	{
		fprintf(stderr, "Error: %s\n", strerror(errno));
		return (1);
	}
	if ((sdl->screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE)) == NULL)
	{
		fprintf(stderr, "Error: %s", SDL_GetError());
		return (1);
	}
	SDL_WM_SetCaption("Night club! :D", NULL);
	if (SDL_FillRect(sdl->screen, NULL, SDL_MapRGB(sdl->screen->format, 255, 32, 45)) == -1)
	{
		fprintf(stderr, "Error: %s\n", SDL_GetError());
		return (1);
	}
	if (SDL_Flip(sdl->screen) == -1)
	{
		fprintf(stderr, "Error: %s\n", SDL_GetError());
		return (1);
	}
	while (i < 100)
	{
		creation_rect(sdl, my_random(), my_random(), my_random());
		++i;
	}
	SDL_FreeSurface(sdl->rectangle);
	return (0);
}

int my_random()
{
	double seed;
	int fp;
	time_t t1;
	struct timeval tv;
	gettimeofday(&tv, NULL);
	seed = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000;
	srand(seed);
	usleep(10000);
	return (rand() % 255);
}

int main()
{
	t_sdl sdl;
	sdl.screen = NULL;
	if (init(&sdl))
		return (1);
	return (0);
}

Of course, we need to run this:

C - SDL (Simple Directmedia Layer) - Creating a rectangle and moving it

Thu, 22 Mar 2012 00:00:00 +0000

We are going to see, with this tutorial, how to create a shape on a window and how to move it with keyboard arrows.

We need, for this example, three files that we are going to create to dispatch the code:

main.c
manager_sdl.c
h.h

Of course, you can add a Makefile to easily compile and link files.
But to link the .o, you need to add the -lSDL command.

1. main.c

#include <string.h>
#include <errno.h>
#include <stdlib.h>
#include <SDL/SDL.h>
#include "h.h"

int init(t_sdl *sdl)
{
  if (SDL_Init(SDL_INIT_EVERYTHING) == -1)
  {
    fprintf(stderr, "Error: %s\n", strerror(errno));
    return (1);
  }
  if ((sdl->screen = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE)) == NULL)
  {
    fprintf(stderr, "Error: %s", SDL_GetError());
    return (1);
  }
  SDL_WM_SetCaption("Hello World! :D", NULL);
  if (SDL_FillRect(sdl->screen, NULL, SDL_MapRGB(sdl->screen->format, 255, 32, 45)) == -1)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  if (SDL_Flip(sdl->screen) == -1)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  sdl->position->x = 0;
  sdl->position->y = 0;
  if (manager_event(sdl))
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  SDL_FreeSurface(sdl->rectangle);
  return (0);
}

int main ()
{
  t_sdl sdl;
  sdl.screen = NULL;
  if(init(&sdl))
    return (1);
  return (0);
}

2. manager_sdl.c

#include <stdio.h>
#include <string.h>
#include <SDL/SDL.h>
#include "h.h"

int manager_event(t_sdl *sdl)
{
  int gogogo;
  SDL_Event  event;

  gogogo = 1;
  while (gogogo)
  {
    SDL_WaitEvent(&event);
    if (event.type == SDL_QUIT)
      gogogo = 0;
    else if (event.type == SDL_KEYDOWN)
    {
      if (event.key.keysym.sym == SDLK_ESCAPE)
      {
        printf("ESC\n");
        gogogo = 0;
      }
      if (event.key.keysym.sym == SDLK_RIGHT)
      {
        printf("RIGHT\n");
        sdl->position->x += 10;
      }
      if (event.key.keysym.sym == SDLK_LEFT)
      {
        printf("LEFT\n");
        sdl->position->x -= 10;
      }
      if (event.key.keysym.sym == SDLK_UP)
      {
        printf("UP\n");
        sdl->position->y -= 10;
      }
      if (event.key.keysym.sym == SDLK_DOWN)
      {
        printf("DOWN\n");
        sdl->position->y += 10;
      }
    }
    creation_rect(sdl);
  }
  return (0);
}

int creation_rect(t_sdl *sdl)
{
  sdl->rectangle = NULL;
  if (SDL_FillRect(sdl->screen, NULL, SDL_MapRGB(sdl->screen->format, 255, 32, 45)) == -1)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  if ((sdl->rectangle = SDL_CreateRGBSurface(SDL_HWSURFACE, 220, 180, 32, 0, 0, 0, 0)) == NULL)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  if (SDL_FillRect(sdl->rectangle, NULL, SDL_MapRGB(sdl->screen->format, 255, 255, 45)) == -1)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  if (SDL_BlitSurface(sdl->rectangle, NULL, sdl->screen, sdl->position) == -1)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  if (SDL_Flip(sdl->screen) == -1)
  {
    fprintf(stderr, "Error: %s\n", SDL_GetError());
    return (1);
  }
  return (0);
}

3. h.h

#ifndef H_H_
#define H_H_

/**
* STRUCTURE
*/
typedef struct s_sdl
{
  SDL_Surface *screen;
  SDL_Surface *rectangle;
  SDL_Rect *position;
} t_sdl;

/**
* PROTOTYPE
*/
/* main.c */
int init(t_sdl *sdl);
/* manager_sdl.c */
int manager_event(t_sdl *sdl);
int creation_rect(t_sdl *sdl);

#endif /* H_H_ */

4. Compiling, linking, running, playing

$ gcc main.c manager_sdl.c -c ; gcc main.o manager_sdl.o -lSDL -o go ; ./go

Well done, you made it.

C - Library functions - Using srand() and rand()

Fri, 09 Mar 2012 00:00:00 +0000

Today a tiny tutorial to see how using srand() and rand() from the libc.

We will generate a number in a range between 0 and 2.
For that, we will use the functions:

time()
srand()
rand()
sleep()

The time() function because we want a random number that changes every second.
We will use it with the sleep() function.

We put a seed, generated by the time() function), into the srand() one.
Then we display this number with the rand() function.
And as we want a number between 0 and 2, we use the modulo operator (%).

C - Errors - Handling errors

Thu, 08 Mar 2012 00:00:00 +0000

In this tutorial we will how to easily manage errors in C programming language.

That is we will try to open a file and if this file doesn’t exist we will trigger an error.
If the file exists, we will tell its name with a message to say that the file really exist.

We have to notice that for handling errors correctly, we have to use the fprintf() function to indeed display error on the error output.
For the standard output, we will use the classical printf() function.

C - Errors / Warnings - After compiling

Sun, 08 Jan 2012 00:00:00 +0000

Errors and warnings generally encountered by a coder during his hard life of coder will be added here, in this special section.

I will not make difference between errors and warnings, because I always compile with CFLAGS such as -Wall -Werror -Wextra and thus warnings are treated as errors.

These errors will be those appearing after compiling a program.

So we assume that we will just try to compile and of course it will fail.

C - Recursion - Classical recursion of a factorial

Sun, 08 Jan 2012 00:00:00 +0000

A classical example of recursions is of course the factorial one.

If you want to know the result of a factorial, do not hesitate to use a recursive function.

Let’s see it:

#include        <stdio.h>

int     doIt(int nb) {
  if (nb <= 1)
    return 1;
  printf("nb = %d\n", nb);
  return nb * doIt(nb - 1);
}

int     main() {
  int first = 5;

  printf("Last = %d\n", doIt(first));
  return 0;
}

The render:

nb = 5
nb = 4
nb = 3
nb = 2
Final result = 120

C - Recursion - Finding a number until a variable reaches another one

Sun, 08 Jan 2012 00:00:00 +0000

The code below display the nb variable until it reaches the number ten.

But the recursion will display the phrase in the printf(), of the main(), at the end of the while inside the r() function.

So the code inside the r() function will be executed before the printf() of the main().

Let’s see this easy example:

#include        <stdio.h>

int     r(int nb) {
  while (nb < 10)
    {
      printf("nb = %d\n", nb);
      return r(++nb);
    }
  return 10;
}

int     main() {
  int first = 1;

  printf("Last = %d\n", r(first));
  return 0;
}

And the result:

C - SDL (Simple Directmedia Layer) - Errors

Fri, 25 Nov 2011 00:00:00 +0000

Here a list of errors from the SDL library.
These errors can be found from any circumstance, such as before compilation, after or during the linkage.

Error 1

Description Resource Path Location Type
undefined reference to `SDL_main’
line 315, external location:
\Users\hercules\trunk\SDL-1.2\src\main\win32\SDL_win32_main.c
C/C++ Problem

To resolve this error on Windows, you have to pass the classic arguments int argc and *char argv[] to your main() function, just like this:

int main(int argc, char *argv[]) {
	return 0;
}

C - SDL (Simple Directmedia Layer) - Hello World!

Thu, 17 Nov 2011 00:00:00 +0000

You probably already installed SDL library on your computer.
If not, you can follow this SDL tutorial setup on Eclipse .

Let’s test it with a Hello World! tutorial.

For Windows OS, do not forget to add the SDL.dll in the folder where there is your .exe.

To have an easy application than ever beginners can make, we need to follow five steps:

Include the right library

In our case, we have to include the SDL/SDL.h header.

C - Library functions - Using strcmp()

Tue, 07 Jun 2011 00:00:00 +0000

In this tutorial we will see how to use the strcmp() function.
It returns:

-1 if the first argument is less than the second
0 if the first argument is equal to the second
1 if the first argument is greater than the second

We need the string.h include to use this function.

Let’s see this example of the strcmp() function:

// compare.c

#include        <stdio.h>
#include        <string.h>

int     main(int ac, char *av[])
{
  char  *word;
  int   cmp;

  word = "badprog";
  cmp = strcmp(av[1], word);
  if (!cmp)
    printf("Match, indeed, strcmp = %d\n", cmp);
  else
    printf("Do not match, indeed, strcmp = %d\n", cmp);
  return (0);
}

Compiling and executing:

C - Recursion - Displaying a string

Tue, 07 Jun 2011 00:00:00 +0000

In this tutorial we will see how to display a string with the recursive method.

Let’s see this example of the recursive and the iterative method with the functions below:

// recursion.c

#include        <string.h>
#include        <stdio.h>
#include        <unistd.h>

void    displayString_iterative(char *str)
{
  int   i;

  i = 0;
  while (str[i])
    write(1, &str[i++], 1);
}

void    displayString_recursive(char *str)
{
  if (strlen(str) <= 0)
    return;
  write(1, &str[0], 1);
  displayString_recursive(str + 1);
}

int     main()
{
  displayString_recursive("Hello BadproG.com!\n");
  displayString_iterative("Hello BadproG.com!\n");
  return (0);
}

Let’s compile and execute it:

C - Character manipulation - Allocation memory

Wed, 18 May 2011 00:00:00 +0000

It is hard to understand conceptually what is happening when we create a string with and without malloc() allocation.
That is what we will see in this tutorial.

Let’s see some examples of allocation memory, with and without malloc(), and let’s see what is happening in the memory:

#include <stdio.h>
#include <stdlib.h>

int                     main()
{
  char                  *str1;
  char                  *str2;
  char                  *str3;
  char                  *str4;
  char                  *str5;

  str1 = "hell";
  str2 = "hello";
  str3 = "hello";
  str4 = "hello";

  str5 = malloc(sizeof(*str2) * 5 + 1);
  str5[0] = 'h';
  str5[1] = 'e';
  str5[2] = 'l';
  str5[3] = 'l';
  str5[4] = 'o';
  str5[5] = '\0';

  printf("str1 | %c - %c - %c - %c\n", str1[0], str1[1], str1[2], str1[3]);
  printf("str1 | %p - %p - %p - %p\n\n", &str1[0], &str1[1], &str1[2], &str1[3]);

  printf("str2 | %c - %c - %c - %c - %c\n", str2[0], str2[1], str2[2],str2[3], str2[4]);
  printf("str2 | %p - %p - %p - %p - %p\n\n", &str2[0], &str2[1], &str2[2], &str2[3], &str2[4]);

  printf("str3 | %c - %c - %c - %c - %c\n", str3[0], str3[1], str3[2],str3[3], str3[4]);
  printf("str3 | %p - %p - %p - %p - %p\n\n", &str3[0], &str3[1], &str3[2], &str3[3], &str3[4]);

  printf("str4 | %c - %c - %c - %c - %c\n", str4[0], str4[1], str4[2],str4[3], str4[4]);
  printf("str4 | %p - %p - %p - %p - %p\n\n", &str4[0], &str4[1], &str4[2], &str4[3], &str4[4]);

  printf("str5 | %c - %c - %c - %c - %c\n", str5[0], str5[1], str5[2],str5[3], str5[4]);
  printf("str5 | %p - %p - %p - %p - %p\n\n", &str5[0], &str5[1], &str5[2], &str5[3], &str5[4]);

  free(str5);

  return (0);
}

Let’s compile it and execute it:

C - Linked lists - Head and End

Sat, 16 Apr 2011 00:00:00 +0000

I hope you liked my fantastic simple example of linked list (OK it was not so exciting, but it works fine).

SO, let’s try today a tutorial of a linked list where we will able to add and display elements in our linked list, first by adding elements from the head and then from the queue (or the end).

Let’s start our example of this famous linked list by adding elements from the head and from the end:

C - Library functions - Using daemon()

Fri, 15 Apr 2011 00:00:00 +0000

In this tutorial we will see the daemon() function.
This function is designed to launch a program in background.

So when you exectute a program it will start and if you want to stop it, just make a Ctrl + C.

The program will stop instantly.

Now, with the daemon function, the program will not stop even with a Ctrl + C.
To stop it, you have to kill the process with the kill command.

C - General Programming - Return value of a if statement without any condition

Mon, 04 Apr 2011 00:00:00 +0000

To test a condition in a if statement without any condition, the result has to be other than 0 to test a true condition.

Let’s see an example of a if statement without any condition:

#include	<stdio.h>

int     checkIt()
{
  int	a;

  a = 0;
  if (a == 0)
    return (-1);
  return (0);
}

int     main()
{
  int   number;

  number = checkIt();
  if (number)
    printf("True - Value was %d.\n", number);
  else
    printf("False - Value was %d.\n", number);
  return (0);
}

Compile and execute it:

C - Bitwise operation - Bit shift in decimal

Sat, 26 Mar 2011 00:00:00 +0000

Let’s try to transform a binary into a decimal with a simple loop.

Let’s see this example of a bit shift into a decimal display:

#include        <stdio.h>

int     main()
{
  int   i;
  int   j;

  i = 0;
  j = 1;
  printf("%d\n", j);
  while (i < 32)
    {
      j = j << 1;
      printf("%d\n", j);
      i++;
    }
  return (0);
}

Let’s compile and execute it:

$ cc main.c && ./a.out

Result:

1
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
131072
262144
524288
1048576
2097152
4194304
8388608
16777216
33554432
67108864
134217728
268435456
536870912
1073741824
-2147483648
0

I’m seeing some of you saying : “Uh why?”

C - Character manipulation - Displaying a char

Tue, 22 Mar 2011 00:00:00 +0000

Today I will show you how to transform a decimal number, an hexadecimal number and a binary number into the same character.

And you will see that this transformation is made by the terminal, the shell and Linux (or UNIX ;).

Let’s see an example, with 3 files and after with printf():

First of all, you have to create 3 files named file1, file2 and file3.

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int                     main()
{
  int                   fd1;
  int                   fd2;
  int                   fd3;
  char                  i;
  char                  j;
  char                  k;

  i = 120;
  j = 0x78;
  k = 0b01111000;
  fd1 = open("file1", O_WRONLY);
  fd2 = open("file2", O_WRONLY);
  fd3 = open("file3", O_WRONLY);
  write(fd1, &i, 1);
  write(fd2, &j, 1);
  write(fd3, &k, 1);
}

Compile and execute it:

C - Linked lists - Simple example

Sun, 13 Feb 2011 00:00:00 +0000

Below, certainly the most easy example of the linked lists.

Let’s see this example as a FILO, meaning First In Last Out:

#include        <stdlib.h>
#include        <stdio.h>

/*
** STRUCTURE
*/
typedef struct s_list
{
  int   nb;
  struct s_list *next;
} t_list;

/*
** ADD
*/
t_list  *add(t_list *element, int i)
{
  t_list        *link;

  link = malloc(sizeof(*link));
  link->nb = i;
  link->next = element;
  return (link);
}

/*
** DISPLAY
*/
void    display(t_list *toDisplay)
{
  while (toDisplay != NULL)
    {
      printf("toDisplay->nb = %d\n", toDisplay->nb);
      toDisplay = toDisplay->next;
    }
}

/*
** MAIN
*/
int     main()
{
  t_list        *new;
  int   i;

  new = NULL;
  i = 0;
  while (i < 18)
    new = add(new, i++);
  display(new);
  return (0);
}

Result:

C - Pointers - Some examples

Wed, 26 Jan 2011 00:00:00 +0000

We can see with examples below that myString[0] == *myString == *(&myString[0]) == H.

Why?

Because myString[0] points the first character of the string “Hello World”, in this case “H”.

Same for *myString that is the value of the first character of the string. Finally &myString[0] is the address of the first character (H), and with the * before we retrieve the value of this address, in this case “H”.

C - Library functions - Using free()

Tue, 25 Jan 2011 00:00:00 +0000

The free() function is the sister of the malloc() function. As malloc() returns the address of the first byte of the allocated memory, free() accepts, as only parameter, the address of this first byte.

/*
** Made by BadproG
*/

#include	<stdlib.h>
#include	<stdio.h>

int     main()
{
  char	*myString;

  myString = malloc(sizeof(myString));
  if (myString == NULL)
    {
      printf("Can not malloc(), not enough space in the memory!\n");
      exit(1);
    }
  else
    {
      printf("OK memory is allocated!\n");
      free(myString);
    }
  return (0);
}

C - Unary operators - Using sizeof()

Tue, 25 Jan 2011 00:00:00 +0000

The sizeof() unary operator is often used, so it is important to know some tricks that we can do with it.

It is used to calculate the sizes of datatypes and it takes one argument: the type.

The main purpose of sizeof() is of course to allocate memory in conjuction with malloc.

1. Displaying size of types

In the example below, we can note the 1 byte of the *myString.

C - General Programming - Beep function

Thu, 20 Jan 2011 00:00:00 +0000

In this tutorial we will see a simple beep function. Let’s take an example of the beep function:

/*                                                                              
** Made by BadproG.com                                                          
*/

#define	       	SOUND_IT(x)    (x-'@')
#include        <stdio.h>

void    beep(void)
{
  putchar(SOUND_IT('G'));
  fflush(stdout);
}

int     main()
{
  beep();
}

Just compile and each time you will execute it, you will hear a simple beep.