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

int main(int argc, char *argv[])
{
    :

    if (need to restart this program) {
        execlp(argv[0], argv[0], NULL);
        fprintf(stderr, "%s: Cannot restart: %s.\n", argv[0], strerror(errno));
        return 1;
    }

    :
}

For check if the new instance already run, I try to delete a file which is opened by the new instance

#ifndef GAMEDIR
#define GAMEDIR ".mygame"
#endif

{   const char *const home = getenv("HOME");
    const char *const gamedir = GAMEDIR;
    int               result;

    if (home && *home)
        do {
            result = mkdir(gamedir, 0700); /* drwx------ */
        } while (result == -1 && errno == EINTR);

    do {
        result = chdir(gamedir);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
        fprintf(stderr, "Missing directory '%s': %s.\n", gamedir, strerror(errno));
        exit(1);
    }

    /* Working directory is now the per-user game directory,
     * so you can use relative paths for per-user files,
     * and compile-time absolute paths for fixed data files,
     * for example /usr/share/games/mygame/.
    */
}

#include <unistd.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>

/* Open the named file in read-write mode, creating the file
 * (mode -rw-------) if necessary, and apply for an advisory
 * exclusive lock.
 *
 * If successful, the function will return an open file handle.
 * Otherwise, it will return NULL with errno set to indicate
 * the error; EAGAIN if the file is already locked.
 *
 * To release the lock, just close the file.
 *
 * The lock will persist over an exec(). You will want to
 * release the lock before an exec() call.
 *
 * When the program exits (this or the program exec()'d!)
 * the lock will be automatically released.
 *
 * If you fork child processes, they will share the file handle.
 * The lock will be released when all processes have either closed
 * the handle, or exited; i.e. when there are no open handles left.
*/
FILE *fopen_exclusive(const char *const filename)
{
    int   descriptor, result, saved_errno;
    FILE *handle;

    if (!filename || !*filename) {
        /* Empty or NULL filename. */
        errno = EINVAL;
        return NULL;
    }

    /* Save errno, so we keep it unchanged if we are successful. */
    saved_errno = errno;

    /* Open the file. Create it (-rw-------) if necessary. */
    do {
        descriptor = open(filename, O_RDWR | O_NOCTTY | O_CREAT, 0600);
    } while (descriptor == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
    if (descriptor == -1)
        return NULL;

    /* Apply for an exclusive advisory lock. */
    do {
        result = flock(fd, LOCK_EX | LOCK_NB);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
        if (errno == EAGAIN || errno == EWOULDBLOCK || errno == EACCES)
            saved_errno = EAGAIN;
        else
            saved_errno = errno;

        do {
            result = close(descriptor);
        } while (result == -1 && errno == EINTR);

        errno = saved_errno;
        return NULL;
    }

    /* Convert descriptor to actual file handle. */
    do {
        handle = fdopen(descriptor, "r+b");
    } while (!handle && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
    if (!handle) {
        saved_errno = errno;

        do {
            result = close(descriptor);
        } while (result == -1 && errno == EINTR);

        errno = saved_errno;
        return NULL;
    }

    /* Success! */
    errno = saved_errno;
    return handle;
}

/* Flush the specified file to disk, then rename from saving to actual.
 * Returns 0 if successful, errno code otherwise.
 * The handle will be closed in all cases, and saving removed.
*/
int fsave(FILE *const handle, const char *const saving, const char *const actual)
{
    int result, saved_errno;

    if (!handle)
        return errno = EINVAL;

    if (!saving || !*saving || !actual || !*actual) {
        do {
            result = fclose(handle);
        } while (result == -1 && errno == EINTR);
        return errno = EINVAL;
    }

    saved_errno = errno;

    if (ferror(handle)) {
        saved_errno = EIO;
        goto fail_close;
    }

    /* Flush unwritten data to disk. */
    do {
        result = fflush(handle);
    } while (result == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
    if (result == -1) {
        saved_errno = EIO;
        goto fail_close;
    }

    /* Sync data; make sure it hits the storage device. */
    do {
        result = fdatasync(fileno(handle));
    }*while (result == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
    if (result == -1 && errno == EIO) {
        saved_errno = EIO;
        goto fail_close;
    }

    /* Close file. Check for delayed write errors. */
    do {
        result = fclose(handle);
    } while (result == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
    if (result == -1) {
        saved_errno = errno;
        goto fail_unlink;
    }

    /* File is successfully flushed to disk and closed. */

    /* Replace existing file with the new one. */
    do {
        result = rename(saving, actual);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
        saved_errno = errno;
        goto fail_unlink;
    }

    /* Success! */
    errno = saved_errno;
    return 0;

fail_close:
    /* Close file. */
    do {
        result = fclose(handle);
    } while (result == -1 && errno == EINTR);

fail_unlink:
    /* Remove saving file. */
    do {
        result = unlink(saving);
    } while (result == -1 && errno == EINTR);

    /* Return failure. */
    return errno = saved_errno;
}

    FILE  *output;

    output = fopen("highscores.new", "wb");
    if (output) {
        /* We can save highscores. */

        /* Write the highscore content to output */
        fprintf(output, "Highscores:\n");
        /* ... */

        /* Try saving the highscore file. */
        if (fsave(output, "highscores.new", "highscores"))
            fprintf(stderr, "Warning: Cannot save highscores: %s.\n", strerror(errno));

    } else {
        /* We cannot save highscores. Do we need to exit?
           The user might be running this from a CD-ROM or something.
        */
    }

    pid_t  child, pid;

    child = fork();
    if (child == (pid_t)-1) {
        fprintf(stderr, "Cannot fork a child process: %s.\n", strerror(errno));
        exit(1);
    }

    if (child) {
        /* Only the parent process will run this code */


        /* Reap the child before exiting */
        do {
            pid = waitpid(child, NULL, 0);
        } while (pid != child);

        exit(0);
        
    } else {
        /* Only the child process will run this code */

        exit(0);
    }

    pid_t  pid;
    int    exitstatus;

    /* See if any child process has exited. */
    pid = waitpid((pid_t)-1, &exitstatus, WNOHANG);
    if (pid != (pid_t)0 && pid != (pid_t)-1) {
        /* Child process 'pid' has exited (or stopped or continued). */
        if (WIFEXITED(exitstatus)) {
            /* It exited with status WEXITSTATUS(exitstatus) */
        } elif (WIFSIGNALED(exitstatus)) {
            /* It died from signal WTERMSIG(exitstatus) */
        }
    }

    pid_t pid, child1, child2;

    child1 = fork();
    if (child1 == (pid_t)-1) {
        fprintf(stderr, "Cannot fork first child process: %s.\n", strerror(errno));
        exit(1);
    }

    if (!child1) {

        /*
         * First child process.
        */

        exit(0);
    }

    child2 = fork();
    if (child2 == (pid_t)-1) {
        fprintf(stderr, "Cannot fork second child process: %s.\n", strerror(errno));
        exit(1);
    }

    if (!child2) {

        /*
         * Second child process.
        */

        exit(0);
    }

    /* This is the original parent process.
     * Since it exits now, the children will be reparented,
     * and reaped automatically when they exit.
    */
    exit(0);

~/sandbox/49381$ cat opendir.cc
#include <cstdio>
#include <sys/types.h>
#include <dirent.h>
#include <vector>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>
using namespace std;
int main (int c, char **argv)
{
  puts(argv[0]);
  auto d = opendir ("/proc/self/fd/");
  vector<int> v;
  while (auto e = readdir (d))
    if (e->d_name[0] != '.' && atoi (e->d_name) > 2)
      v.push_back (atoi (e->d_name));
  for (auto fd:v)
    printf ("close(%d)==%d\n", fd, close (fd));
  if (argv[1])
    exit (0);
  puts ("restarting");
  char me[255];
  me[readlink("/proc/self/exe",me,255)]=0;
  execl("/proc/self/exe", me, "--restarting",0);
  perror("execl");
  return 0;
}
~/sandbox/49381$ make CXXFLAGS=--std=c++0x opendir
g++ --std=c++0x    opendir.cc   -o opendir
~/sandbox/49381$ ./opendir 4<opendir.cc
./opendir
close(3)==0
close(4)==0
restarting
/home/jthill/sandbox/49381/opendir
close(3)==0
~/sandbox/49381$

#define _POSIX_C_SOURCE 200809L
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <dirent.h>
#include <errno.h>

static int close_all(void)
{
    size_t               fd_size = 0;
    size_t               fd_used = 0;
    int                 *fd_list = NULL, *fd_temp;

    const struct dirent *ent;
    DIR                 *dir;
    const char          *name;
    int                  saved_errno, fd, result, err;

    saved_errno = errno;

    do {
        dir = opendir("/proc/self/fd/");
    } while (!dir && errno != EINTR);
    if (!dir)
        return errno;

    while (1) {
        errno = 0;
        ent = readdir(dir);
        if (!ent)
            break;

        if (!(ent->d_name[0] >= '0' && ent->d_name[0] <= '9'))
            continue;

        fd = ent->d_name[0] - '0';
        name = (const char *)&(ent->d_name[1]);

        while (*name >= '0' && *name <= '9')
            fd = 10*fd + *(name++) - '0';

        if (fd == STDIN_FILENO || fd == STDOUT_FILENO || fd == STDERR_FILENO)
            continue;

        if (fd_used >= fd_size) {
            fd_size = (fd_used | (size_t)255) + (size_t)257;
            fd_temp = realloc(fd_list, sizeof(int) * fd_size);
            if (!fd_temp) {
                if (fd_list)
                    free(fd_list);
                do {
                    result = closedir(dir);
                } while (result == -1 && result == EINTR);
                return errno = ENOMEM;
            }
            fd_list = fd_temp;
        }

        fd_list[fd_used++] = fd;
    }

    if (errno) {
        err = errno;
        if (fd_list)
            free(fd_list);
        do {
            result = closedir(dir);
        } while (result == -1 && errno == EINTR);
        return errno = err;
    }

    fd = dirfd(dir);

    do {
        result = closedir(dir);
    } while (result == -1 && errno == EINTR);
    if (result == -1) {
         err = errno;
         if (fd_list)
             free(fd_list);
         return errno = err;
    }

    err = 0;
    while (fd_used-->0)
        if (fd_list[fd_used] != fd) {
            do {
                result = close(fd_list[fd_used]);
            } while (result == -1 && (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK));
            if (result == -1)
                err = errno;
        }

    if (fd_list)
        free(fd_list);

    if (err)
        return errno = err;

    errno = saved_errno;
    return 0;
}