Il y évidemment des solutions avec FTP, NFS, … Le problème avec ces solutions c’est qu’il faut faire tout un tas de configurations pour réussir à monter un simple dossier. Et sshfs fût créé !

sshfs ?

sshfs permet de monter un dossier en utilisant le protocole SFTP.
sshfs a de nombreux avantages. Les principaux sont qu’il ne nécessite pas d’être root et que les transfères sont sécurisés !

Installation sur Fedora

$ sudo yum install fuse-sshfs

Monter un dossier
Nous allons créer un dossier dans notre home et nous allons monter le serveur distant dans celui-ci

$ cd ~
$ mkdir folder
$ sshfs hôte:/home/toto folder

Cette suite de commande va monter le répertoire distant « /home/toto » dans le dossier local « folder »

Démonter un dossier

$ fusermount -u folder

Conclusion
Et voilà maintenant vous savez comment monter un dossier distant de manière sécurisée en ayant à faire le minimum de configuration côté serveur !

Les fonctions de tri ont une nomenclature bien particulière qui permet de savoir exactement ce que fait la fonction. Par défaut toutes les fonctions contiennent le mot « sort« . Ensuite certaines lettres sont ajoutées au début du nom de la fonction. Par exemple la lettre « k » (par exemple avec la fonction ksort) sert à trier sur les clefs. Il y a donc le « k » pour trier sur les clefs, le « a » pour garder la relation entre les clefs et les valeurs, le « r » pour trier en ordre inverse et le « u » pour trier avec une fonction personnelle.

bool sort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) :
Le premier paramètre que prend sort est le tableau que vous souhaitez trier. Le tri se fait par rapport aux valeurs. Comme pour toutes les fonctions de tri il faut éviter que le tableau passé en paramètre contienne des types de valeur différents sinon le résultat risque d’être imprévisible.
Le second paramètre, optionnel, est un flag qui permet de modifier le comportement du tri.

Nous allons voir quelques exemples d’utilisations

/* compare les éléments normalement */
$tableau = array('c', 'd', 'b', 'a');
sort($tableau);
var_dump($tableau);
//array
//  0 => string 'a' (length=1)
//  1 => string 'b' (length=1)
//  2 => string 'c' (length=1)
//  3 => string 'd' (length=1)
 
/* compare les éléments comme des chaînes de caractères */
$tableau = array('10', '1', '2', '20');
sort($tableau, SORT_STRING);
var_dump($tableau);
//array
//  0 => string '1' (length=1)
//  1 => string '10' (length=2)
//  2 => string '2' (length=1)
//  3 => string '20' (length=2)
 
/* compare les éléments comme des entiers */
$tableau = array('10', '1', '2', '20');
sort($tableau, SORT_NUMERIC);
var_dump($tableau);
//array
//  0 => string '1' (length=1)
//  1 => string '2' (length=1)
//  2 => string '10' (length=2)
//  3 => string '20' (length=2)

La doc pour la fonction sort est disponible ici

bool rsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) :
Cette fonction fonctionne exactement comme la fonction sort une différence près, la fonction rsort tri en ordre inverse.
Pas besoin de faire d’exemple, ce serait les mêmes que pour sort !
La doc pour la fonction rsort est disponible ici

bool asort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) :
Cette fonction, encore une fois, est presque identique à la fonction sort à la différence qu’elle garde la relation entre les index et les valeurs
On peut, comme pour la fonction sort, utiliser des flags pour modifier le comportement du tri.

<?php
/* compare les éléments normalement, gardant les relations entre les clefs et les valeurs */
$tableau = array('c', 'd', 'b', 'a');
asort($tableau);
var_dump($tableau);
//array
//  3 => string 'a' (length=1)
//  2 => string 'b' (length=1)
//  0 => string 'c' (length=1)
//  1 => string 'd' (length=1)

La doc pour la fonction asort est disponible ici

bool arsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) :
Fonctionne exactement comme la fonction asort à la différence qu’elle trie en ordre inverse.

La doc pour la fonction arsort est disponible ici

bool ksort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) :
Cette fonction de tri, contrairement aux autres, fait le tri en fonction des clefs. Elle maintient la relation entre les clefs et les valeurs.

Encore une fois on peut utiliser des flags pour modifier le comportement de la fonction de tri.

<?php
/* compare les éléments normalement*/
$tableau = array(1 => 'c', 0 => 'd', 3 => 'b', 4 => 'a');
ksort($tableau);
var_dump($tableau);
//array
//  0 => string 'd' (length=1)
//  1 => string 'c' (length=1)
//  3 => string 'b' (length=1)
//  4 => string 'a' (length=1)
 
/* compare les éléments normalement */
$tableau = array('n' => 'c', 'd' => 'd', 'a' => 'b', 'g' => 'a');
ksort($tableau);
var_dump($tableau);
//array
//  'a' => string 'b' (length=1)
//  'd' => string 'd' (length=1)
//  'g' => string 'a' (length=1)
//  'n' => string 'c' (length=1)

La doc pour la fonction ksort est disponible ici

bool krsort ( array &$array [, int $sort_flags = SORT_REGULAR ] ) :
Fonctionne exactement comme la fonction krsort à la différence qu’elle trie en ordre inverse.

La doc pour la fonction krsort est disponible ici

bool usort ( array &$array , callable $cmp_function ) :
Cette fonction permet de trier un tableau grâce à notre propre fonction de tri. Pour cela on passe en second paramètre une fonction qui doit retourner un booléen. Les fonctions lambda sont parfaites pour cela.
On utilise généralement cette fonction de tri pour des tableaux multidimensionnels.

Dans l’exemple nous avons un tableau multi-dimensionnel, plus exactement un tableau de tableau. Nous souhaitons trier le tableau en fonction de « l’id« . Pour résumer nous allons trier les sous-tableaux en fonction du contenu de ceux-ci (et plus particulièrement l’id dans notre exemple).

<?php
/* compare les éléments par rapport à l'id grâce à une fonction lambda */
/* Utilisation avec un callback */
$tableau = array(
  0 => array(
    'id' => 18,
    'name' => 'Roger'
  ),
	1 => array(
    'id' => 5,
    'name' => 'George'
  ),
	2 => array(
    'id' => 7,
    'name' => 'Mike'
  )
);
function my_compare_function ($a, $b)
{
  return $a['id'] > $b['id'];
}
usort($tableau, "my_compare_function");
var_dump($tableau);
//array
//  0 => 
//    array
//      'id' => int 5
//      'name' => string 'George' (length=6)
//  1 => 
//    array
//      'id' => int 7
//      'name' => string 'Mike' (length=4)
//  2 => 
//    array
//      'id' => int 18
//      'name' => string 'Roger' (length=5)

<?php
/* compare les éléments par rapport à l'id grâce à une fonction lambda */
/* Utilisation avec une fonction lambda */
$tableau = array(
  0 => array(
    'id' => 18,
    'name' => 'Roger'
  ),
	1 => array(
    'id' => 5,
    'name' => 'George'
  ),
	2 => array(
    'id' => 7,
    'name' => 'Mike'
  )
);
usort($tableau, function ($a, $b){ return $a['id'] > $b['id']; });
var_dump($tableau);
//array
//  0 => 
//    array
//      'id' => int 5
//      'name' => string 'George' (length=6)
//  1 => 
//    array
//      'id' => int 7
//      'name' => string 'Mike' (length=4)
//  2 => 
//    array
//      'id' => int 18
//      'name' => string 'Roger' (length=5)

La doc pour la fonction usort est disponible ici

bool uasort ( array &$array , callable $cmp_function ) :
Cette fonction fonctionne comme la fonction usort à la différence qu’elle garde la relation entre les clefs et les valeurs.

<?php
/* compare les éléments par rapport à l'id grâce à une fonction lambda */
/* Utilisation avec une fonction lambda */
$tableau = array(
  0 => array(
    'id' => 18,
    'name' => 'Roger'
  ),
	1 => array(
    'id' => 5,
    'name' => 'George'
  ),
	2 => array(
    'id' => 7,
    'name' => 'Mike'
  )
);
uasort($tableau, function ($a, $b){ return $a['id'] > $b['id']; });
var_dump($tableau);
//array
//  1 => 
//    array
//      'id' => int 5
//      'name' => string 'George' (length=6)
//  2 => 
//    array
//      'id' => int 7
//      'name' => string 'Mike' (length=4)
//  0 => 
//    array
//      'id' => int 18
//      'name' => string 'Roger' (length=5)

La doc pour la fonction uasort est disponible ici

bool uksort ( array &$array , callable $cmp_function ) :
Cette fonction fonctionne comme la fonction usort à la différence qu’elle trie en sur les clefs et non pas les valeurs.

La doc pour la fonction uksort est disponible ici

Conclusion

On a vu pas mal de fonctions avec beaucoup d’exemples. Evidemment, il y d’autres solutions pour trier un tableau en PHP. Cependant, nous avons fait le tour des fonctions qui vous servirons dans 90% des cas.

Comme d’habitude, n’hésitez pas à aller voir la doc lorsque vous avez des doutes !

Bien que la doc soit complète et comporte de nombreux exemples je vais me lancer dans un suite d’article composé uniquement d’exemples concrets d’utilisation de fonction PHP. Il arrive en effet parfois que les exemples ne soit pas assez nombreux et simple de compréhension.

Je vais essayer, si j’y arrive, de faire au moins deux articles par semaine. C’est pas gagné au vu de mon emploi du temps !

Le mode debug ?

CakePHP propose un mode debug qui permet d’afficher des informations bien intéressantes. Ce mode contient plusieurs outils.
Le premier est la fonction « debug(); » qui est plus ou moins équivalente à « var_dump(); ». Elle est très pratique pour l’affichage des tableaux.
Le deuxième outils est un tableau récapitulatif des requêtes effectuées par les modèles. C’est très utile pour vérifier que CakePHP ne fasse pas trop de bêtises !

En plus de cela le mode debug permet d’afficher les erreurs et warning, de rafraîchir les caches des modèles …
Il existe deux niveaux d’erreur qui permettent d’afficher plus ou moins d’informations.

Pour activer le mode debug il suffit d’aller dans le fichier app/Config/core.php et de passer le mode debug à 2 :

Configure::write('debug', 2);

On peut aussi activer temporairement le mode debug dans une fonction par exemple.

<?php
class UsersController extends AppController {
    public index () {
        /* ... Some code ...*/
        Configure::write('debug', 2);
        debug ($variable);
        Configure::write('debug', 0);
        /* ... Some code ...*/
    }
}

Dans cet exemple on active le mode debug pour pouvoir utiliser la fonction debug().

L’astuce du jour !

Le tableau s’affichant en bas de votre page n’est accessible que depuis le template par défaut. Par conséquent si vous utilisez votre propre thème vous n’aurez plus ces précieuses informations.
En faîte depuis la version 2 de CakePHP ce tableau à été déplacé dans un element qu’il faut donc inclure dans votre thème de la manière suivante :

<?php echo $this->element('sql_dump'); ?>

Et voilà grâce à ce changement vous avez de nouveau accès à ce tableau très utile !

Création d'un Makefile par azmimik

Voici la démarche pour installer Apache PHP MySQL sur un serveur CentOS5 [2/2] :

Maintenant que nous avons les bases d’un système LAMP installé nous allons commencer par créer des utilisateurs MySQL avec une base de données.

Nous allons créer un utilisateur qui s’appelle « toto ». Commençons par lancer l’invité de commande MySQL :

mysql> mysql -uroot -p

Maintenant créons l’utilisateur toto :

mysql> CREATE  USER 'toto'@'localhost' IDENTIFIED BY 'motdepasse';

Il faut changer ‘modepasse’ par celui voulu

Nous allons ensuite enlever tous les droits de l’utilisateur sur le serveur MySQL. Pour cela nous allons utiliser la fonction GRANT.

mysql> GRANT USAGE ON * . * TO 'toto'@'localhost' IDENTIFIED BY 'motdepasse';

Nous utilisons ici le droit « USAGE » qui enlève tous les droits. Pour la liste des droits : http://dev.mysql.com/doc/refman/5.0/fr/grant.html

Créons maintenant une base de données « tutorials ». Nous gérerons le cas ou la table exist déjà :

mysql> CREATE DATABASE IF NOT EXISTS `tutorials` ;

Pour finir avec MySQL nous allons donner à toto tous les droits sur la table « tutorials ». Nous utiliserons là encore la commande GRANT

mysql> GRANT ALL PRIVILEGES ON `tutorials` . * TO 'toto'@'localhost';

Dernière commande et pas des moindre :

mysql> FLUSH PRIVILEGES;

Maintenant il suffit de se connecter à PhpMyAdmin pour vérifier que l’utilisateur et la base ont bien été créés.
Dans la troisième et dernière partie de ce tutorial j’expliquerais comment créer des vHost Apache.

Voici déjà quelques questions à se poser avant de choisir un framework

Un framework est-il vraiment nécessaire ?
Si votre seul souhait est de faire uniquement des requêtes Ajax par exemple l’utilisation d’un framework n’est pas du tout obligatoire.

Vitesse de développement / Vitesse du programme ?
Dit autrement peut-on se permettre de perdre en exécution pour privilégier la vitesse de développement. C’est en effet le risque avec les frameworks. Bien souvent un framework qui propose une grande simplicité de développement impose de moins bonnes performances (bien que ça ne soit pas obligatoirement le cas).

La communauté est-elle importante ?
Jquery est un exemple de framework ayant une grosse communauté et il faut avouer que ça a pas mal d’avantage. Le nombre de tutoriaux sur le net est assez impressionnants, il y a pas mal de plugins et on trouve facilement de l’aide via les forums de discussions.

Compatibilité du framework
A vous de voire selon vos besoins, mais il est vrai qu’un framework qui tourne sur l’ensemble des navigateurs est à privilégier !

Que veux-je faire avec ?
Faire des animations ou faire une grosse webapps à la google docs n’a pas grand chose à voire. Le choix du framework va donc dépendre du type de projet sur lequel vous allez bosser.

Quelques liens qui pourront vous aider à choisir
Framework Matrix : Une comparaison d’utilisation des frameworks. A voir absolument !
SlicksSpeed : Comparatif de vitesse des selecteurs des différents frameworks. Attention cependant ce ne sont pas forcément les dernières versions des frameworks
TaskSpeed : Comparatif de vitesse de tâches simples des différents framworks. Attention ici encore ce ne sont pas forcéments les dernières versions des frameworks.

Conclusion
Ce sont en gros l’ensemble des questions que je me suis posées, et les liens que j’ai trouvés les plus intéressants. Mais je doit avouer qu’aujourd’hui je ne sais toujours pas lequel utiliser !

Lien de la doc sockets : http://docs.python.org/library/socket.html
Lien de la doc select : http://docs.python.org/library/select.html

Les commentaires sont nombreux, cependant si il y a un problème n’hésitez pas à m’en faire par en commentaire

# -*- coding: UTF-8 -*-
###############################################################################
##  @author : Mazikim                                                        ##
##  @file : Sockets.py                                                       ##
###############################################################################
 
import select
import socket
 
class Server:
 
	# Contructeur de la class Server.
	#
	# @param port Port de connexion
	# @param listen Nombre de connexion en attente max
	def __init__(self, port = 35890, listen = 5):
		# Initialisation of attr
		self.nbClients = 0	# Nombre de client connecté
		self.sockets = []	# Liste des sockets client
 
		# Création du socket serveur
		self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
		self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
		# On passe le socket serveur en non-bloquant
		self.socket.setblocking(0)
		# On attache le socket au port d'écoute. 
		self.socket.bind(('', port))
		# On lance l'écoute du serveur. "listen" est le nombre max de 
		# connexion quand la file d'attente
		self.socket.listen(listen)
 
 
 
	# Surcouche de la fonction socket.recv
	# On utilise le système d'exeption de recv pour savoir si il reste
	# des donnees a lire
	#
	# @param socket Socket sur lequelle il faut recuperer les données
	# @return Données envoyées par le client
	def receive(self, socket):
		buf = "" # Variable dans laquelle on stocke les données
		_hasData = True # Nous permet de savoir si il y de données à lire
		while _hasData:
			# On passe le socket en non-bloquant
			socket.setblocking(0)
			try:
				_data = socket.recv(256)
				if(_data):
					buf += _data
				else:
					# Déconnexion du client
					_hasData = False
			except:
				_hasData = False
		return buf
 
 
 
	# Fonction qui lance les sockets et s'occupe des clients
	def run(self):
		# On ajoute le socket serveur à la liste des sockets
		self.sockets.append(self.socket)
		# Go
		while True:
			try:
				# La fonction select prends trois paramètres qui sont la liste des sockets
				# Elle renvoie 3 valeurs
				# 	1- La liste des sockets qui ont reçus des données
				# 	2- La liste des sockets qui sont prêt à envoyer des données
				#	3- Ne nous interesse pas dans notre cas
				readReady ,writeReady, nothing = select.select(self.sockets, self.sockets, [])
			except select.error, e:
				break
			except socket.error, e:
				break
 
			# On parcours les sockets qui ont reçus des données
			for sock in readReady:
				if sock == self.socket:
					# C'est le socket serveur qui a reçus des données
					# Cela signifie qu'un client vient de se connecter
					# On accept donc ce client et on récupère qques infos
					client, address = self.socket.accept()
					# On incrémente le nombre de connecté
					self.nbClients += 1
					# On ajoute le socket client dans la liste des sockets
					self.sockets.append(client)
				else:
					# Le client a envoyé des données, on essaye de les lire
					try:
						# On fait appelle à la surchage que l'on a écrite plus haut
						data = self.receive(sock)
						if data:
							# On renvoi au client ce qu'il a envoyé
							sock.send(data)
						else:
							# Si data est vide c'est que le client s'est déconnecté
							# On diminu le nombre de client
							self.nbClients -= 1
							# On supprime le socket de la liste des sockets
							self.sockets.remove(sock)
					except socket.error, e:
						self.sockets.remove(sock)
 
server = Server(35890, 5)
server.run()

Généralement le problème c’est de commencer, trouver la bonne librairie et de trouver un exemple concret pour comprendre comment marche la librairie. C’est ce que je vous propose ici !

Il faut tout d’abord installer Python et MySQL-python. Sous fedora c’est très simple :

yum install python MySQL-python

Commençons simplement par inclure MySQLdb et nous connecter à la base de données :

import MySQLdb
 
db = MySQLdb.connect(host="", user="my_user", passwd="my_pass", db="my_db")

Maintenant comment fait-on une requête ? Et bien c’est assez simple :

import MySQLdb
 
db = MySQLdb.connect(host="", user="my_user", passwd="my_pass", db="my_db")
c = self.db.cursor()
c.execute("SELECT * FROM users WHERE active = 1")
rows = c.fetchall() #rows va contenir tout les résultats
c.close()
# Maintenant on va traiter les résultats de notre requête :
for row in rows:
	print(row[0]+"\n")

Ce bout de code va donc faire un SELECT dans la table users et récupérer tous les éléments dont le champs « active » = 1. Ensuite il va afficher le premier champ de notre table pour tous les éléments récupérer et effectuer un retour à la ligne pour chaque éléments.

Et voilà nous avons comment faire une requête basique avec MySQL et Python.
Pour plus d’infos :

• Manuel MySQL-python

Les includes :
Il faut utiliser les includes suivant pour pouvoir travailler avec les fichiers :

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

Type :
La manipulation des fichiers ‘haut niveau’ avec le C se fait via le type « FILE ». Voici la déclaration d’une variable de type fichier :

FILE *f = NULL;

Ouverture d’un fichier
L’ouverture d’un fichier se fait via la fonction suivante :

 FILE *fopen ( const char * filename, const char * mode );

Le premier paramètre est le chemin du fichier et le second est le mode d’ouverture que l’on souhaite utiliser (écriture, lecture …).
Voici une liste non exhaustive des modes d’ouverture :

• ‘r’ : Lecture seule. Le fichier doit déjà exister
• ‘w’ : Ecriture seule. Si le fichier n’existe pas il est créé.
• ‘a’ : Ajout. Vous commencé à écrire à la fin du fichier. Si le fichier n’existe pas il est créé.
• ‘r+’ : Lecture et écriture. Le fichier doit déjà exister
• ‘w+’ : Lecture et écriture avec suppression du contenu à l’ouverture. Si le fichier n’existe pas il est créé.
• ‘a+’ : Ajout en lecture/écriture à partir de la fin du fichier. Si le fichier n’existe pas il est créé.

Tous ces modes permettent d’ouvrir des fichiers textes. Pour ouvrir en mode binaire il suffit de rajouter ‘b’ (‘rb’, ‘rb+’ …).

La fonction fopen renvoie un pointeur du type FILE si l’ouverture c’est correctement déroulé, ou alors un pointeur NULL. Voici un exemple d’utilisation :

int main()
{
    FILE *f = NULL;
    // Ouverture en mode lecture seule
    f = fopen("mon_fichier.txt", "r");
    if ( f == NULL)
    {
        printf ( "Ouverture du fichier échoué!");
    }
    else
    {
        printf ( "Ouverture du fichier réussis !");
    }
    return 0;
}

Fermeture du fichier :
Il faut TOUJOURS fermer un fichier que l’on a ouvert. On utilise la fonction suivante :

int fclose ( FILE * stream );

On reprend l’exemple précédent :

int main()
{
    FILE *f = NULL;
    // Ouverture en mode lecture seule
    f = fopen("mon_fichier.txt", "r");
    if ( f == NULL)
    {
        printf ( "Ouverture du fichier échoué!");
        // Ici pas besoin de fermer car le fichier n'a pas 
        // été ouvert !
    }
    else
    {
        printf ( "Ouverture du fichier réussis !");
        fclose(f); // On ferme notre fichier
    }
    return 0;
}

Lire dans un fichier :
Avant tout il faut expliquer comment on se balade dans le fichier. La manière la plus simple va être d’utiliser les fonctions de lecture fournit par la librairie standard. Ces fonctions utiliserons un « pointeur » qui leur permet de savoir ou elles se trouvent dans le fichier.
Il existe 3 fonctions différentes pour lire dans un fichier.

// Retourne 1 caractère
int fgetc ( FILE * stream );

// Lit une ligne du fichier sur num caractère 
char * fgets ( char * str, int num, FILE * stream );

// Equivalent à scanf mais ur les fichiers
int fscanf ( FILE * stream, const char * format, ... );

Voici des exemples pour fgetc et fgets. Ces deux exemples font la même chose, ils lisent l’ensemble du fichier et l’écrivent dans la console.

/**
 * Pour la fonction fgetc
 */
int main()
{
    FILE* f = NULL;
    // La var c va contenir ce que revoie fgetc
    int c = 0;
    f = fopen("mon_fichier.txt", "r"); 
    // Ci-dessous on utilise une subtilitée du C
    // En effet NULL = (void *)0
    // Donc on peut remplacer if(f != NULL) par if(f)
    if (f)
    {
        c = fgetc(f);
        while (c != EOF)
        {
            printf("%c", c);
            c = fgetc(f);
        }
        fclose(f);
    }
    return 0;
}

/**
 * Pour la fonction fgetcs
 */
// On défini une valeur maximale de caractère
// à lire par ligne. Donc si une ligne fait 1050 caractères
// les 26 derniers caractères ne seront pas lus
#define LEN_LINE_MAX 1024
int main()
{
    FILE* f = NULL;
    // Variable qui va contenir la ligne
    char str[LEN_LINE_MAX] = "";
    f = f("mon_fichier.txt", "r");
    if (f)
    {
	    // fgets renvoie NULL quand elle arrive
        // en fin de fichier. Donc on utilise ici aussi
        // l'astuce précédente ou NULL = (void *)0
        while (fgets(str, LEN_LINE_MAX, f))
        {
            printf("%s", str);
        }
 
        fclose(f);
    }
    return 0;
}

fscanf une manière un peut différente de travailler, il faut en effet que le fichier est une forme bien précise. Par exemple le fichier contient deux nombres de la manière suivante :

1502 3560

Voici le code qui permet de récupérer ces deux valeurs dans deux variables différentes avec fscanf :

int main()
{
    FILE* f = NULL;
    // Les deux viriables dans lesquelles
    // on va sauver les valeurs
    int nombre_1;
    int nombre_2;
    f = fopen("mon_fichier.txt", "r");
    if (f != NULL)
    {
        fscanf(f, "%d %d", &nombre_1, &nombre_2);
	    printf("Les deux valeurs enregistrées dans 
                     le fichier sont : %d et %d",
                     nombre_1, nombre_2);
        fclose(f);
    }
    return 0;
}

Ecriture dans un fichier :
Pour écrire dans un fichier il y a trois fonctions importantes qui sont les équivalentes des fonctions que l’on a déjà vu pour la lecture.

// Ecrit un caractère dans le fichier
int fputc ( int character, FILE * stream );

// Ecrit une chaîne de caractère dans le fichier.
int fputs ( const char * str, FILE * stream );

// Equivalent à printf mais pour les fichiers
int fprintf ( FILE * stream, const char * format, ... );

Voici trois exemples de code qui utilise ces fonctions. Dans leur fonctionnements elles sont entièrement similaires au fonction de lecture.

int main()
{
    FILE* f = NULL;
    f = fopen("my_file.txt", "w");
    if (f != NULL)
    {
        // On écrit le caractère 'x'
        fputc('x', f);
        fclose(f);
    }
    return 0;
}

int main()
{
    FILE* f = NULL;
    f = fopen("my_file.txt", "w");
    if (f != NULL)
    {
        fputs("Coucou, ça code dure ?", f);
        fclose(f);
    }
    return 0;
}

int main()
{
    // valeur que l'on va sauver dans le fichier
    int age = 42;
    char *name = "Pascal";
    FILE* f = NULL;
    f = fopen("my_file.txt", "w");
 
    if (fichier != NULL)
    {
        // On l'écrit dans le fichier en utilisant
        // fprintf comme printf pour la console
        fprintf(f, "nom : %s \n age %d", name, age);
        fclose(f);
    }
 
    return 0;
}

Se déplacer dans un fichier :
Il existe trois fonctions qui permettent de se déplacer dans un fichier.

long int ftell ( FILE * stream );
int fseek ( FILE * stream, long int offset, int origin );
void rewind ( FILE * stream );

La première ftell renvoie la position du pointeur dans le fichier (la position courante). La deuxième fseek permet de déplacer ce pointeur pour changer la position courante. Enfin la dernière rewind permet de placer le pointeur en début de fichier, cette fonction pouvant être remplacer par fseek avec les paramètres qui vont bien.
Voici divers exemples avec des commentaires pour mieux comprendre.

int main()
{
    FILE* f = NULL;
    f = fopen("my_file.txt", "w");
 
    if (fichier != NULL)
    {
        // SEEK_SET indique l'origine du fichier donc
        // cette ligne positionne le pointeur à la 
        // cinquième positions du fichier
        fseek(f, 5, SEEK_SET);
        // SEEK_CUR indique la position du pointeur
        // cette ligne positionne le pointeur à la 
        // cinquième positions après la position courante
        fseek(fichier,  5, SEEK_CUR);
        // SEEK_END indique la fin du fichier donc
        // cette ligne positionne le pointeur à 
        // l'avant dernière position du fichier
        fseek(fichier, -1, SEEK_END);
        fclose(f);
    }
 
    return 0;
}

Supprimer, Renommer, Copier/Coller …
Pour supprimer un fichier :

// Retourne 0 si correctement supprimé
int remove ( const char * filename );
// exemple :
int main()
{
    return remove("my_file.txt");
}

Pour renommer :

// Retourne 0 si correctement renommé
int rename ( const char * oldname, const char * newname );
// exemple :
int main()
{
    return int rename ( "my_file.txt", "my_new_name_file.txt");
}

Pour copier/coller :
Il n’ya pas de fonction pour copier/coller ou couper/coller un fichier, mais vous pouvez faire votre propre fonction .

J’essaierais d’étoffer ce document d’ici quelques semaines. Cependant ce document est un bon début lorsque l’on souhaite travailler avec les fichiers en C !