Si des tas d’usine à gaz existent et vous proposent des patrons MVC tout prêt vous aurez peut-être besoin de développer vous même votre propre moteur.

fig. 1 – Principe du MVC

Les éléments doivent être indépendant les uns des autres et la communication s’effectue avec l’aide d’événements. Pour y arriver un mécanisme d’événements et d’écouteurs doit être mis en place selon le patron de conception (Design Pattern ou DP) « Observateur ». Avant d’aller plus loin, il est important de comprendre le fonctionnement de ce patron. Vous trouverez toute la documentation nécessaire à son implémentation sur wikipedia.

L’idée est donc ici d’implémenter des classes qui s’inspirent du DP Observer. En me basant sur mon expérience avec AS3, j’ai tenté une approche avec la modélisation suivante :

fig 2. – Diagramme de classes : Evénements personnalisés

Pour illustrer ma gestion d’événements, j’ai choisi d’implémenter un pseudo modèle MVC : « ViewClass » et « ModelClass » étant des classes d’événements et « ControllerClass » étant l’écouteur. Pour produire un événement, les classes d’événements doivent préciser, au travers de la méthode « dispatchEvent », le type l’événement qui s’est produit. Pour écouter, « ControllerClass » doit appeler la méthode « addEventListener » sur chacun des objets, être lui-même l’objet de retour et implémenter la méthode « eventPerformed » qui sera appelé à chaque événements (grâce à MyEventListener).

Plutôt que des mots, démo, passons au code avec tout d’abord l’ensemble des classes de gestion des écouteurs/événements :

public interface MyEventListener {
	public void eventPerformed(MyEvent e);
}

public interface MyEventEnum {}

public class MyEvent {
    private transient Object eventSource;
    private MyEventEnum eventType;

    // forcer la création d'événements avec une source et un type
    public MyEvent(Object eventSource, MyEventEnum eventType) {
        this.eventSource = eventSource;
        this.eventType = eventType;
    }

    public Object getEventSource() {
        return eventSource;
    }

    public MyEventEnum getEventType() {
        return eventType;
    }

    public String toString() {
        return eventSource.getClass().toString();
    }
}

import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;

public abstract class MyEventDispatcher {
	// Tableau associatif : MyEventEnum => Tableau de MyEventListener
	private Hashtable<MyEventEnum, ArrayList<MyEventListener>> listeners = new Hashtable<MyEventEnum, ArrayList<MyEventListener>>();

	public synchronized void addEventListener(MyEventEnum eventType, MyEventListener list) {
		// si l'eventType est déjà présent dans le tableau associatif
		if (listeners.containsKey(eventType)) {
			listeners.get(eventType).add(list);

		// sinon :
		} else {
			// création
			ArrayList<MyEventListener> t = new ArrayList<MyEventListener>();
			listeners.put(eventType, t);
			// puis appel récursif
			addEventListener(eventType, list);
		}

	}

	public synchronized void removeEventListener(MyEventEnum eventType, MyEventListener list) {
		if (listeners.containsKey(eventType)) {
			listeners.get(eventType).remove(list);
		}
	}

	protected boolean dispatchEvent(MyEvent e) {

		// si le type est bien présent dans la liste
		if (listeners.containsKey(e.getEventType())) {

			// on récupère tous les écouteurs
			Iterator<MyEventListener> l = listeners.get(e.getEventType()).iterator();
			while(l.hasNext()) {
				MyEventListener gl = l.next();

				// pour chaque écouteur, on invoque la méthode eventPerformed
				gl.eventPerformed(e);
			}

			return true;
		}

		return false;
	}
}

Maintenant, voici le code d’implémentation MVC utilisant le système :

public enum MyEventEnumModel implements MyEventEnum {
	MODEL_EVENT1, MODEL_EVENT2;
}

public enum MyEventEnumView implements MyEventEnum {
	VIEW_EVENT1, VIEW_EVENT2;
}

public class ModelClass extends MyEventDispatcher {

	// exemple d'utilisation...
	public void foo() {
		// ToDo....
		event1();
	}

	private void event1() {
		dispatchEvent(new MyEvent(this, MyEventEnumModel.MODEL_EVENT1));
	}

	private void event2() {
		dispatchEvent(new MyEvent(this, MyEventEnumModel.MODEL_EVENT2));
	}
}

public class ViewClass extends MyEventDispatcher {

	// exemple d'utilisation...
	public void foo() {
		// ToDo....
		event1();
	}

	private void event1() {
		dispatchEvent(new MyEvent(this, MyEventEnumView.VIEW_EVENT1));
	}

	private void event2() {
		dispatchEvent(new MyEvent(this, MyEventEnumView.VIEW_EVENT2));
	}
}

Pour finir par le contrôleur :

// contrôleur
public class ControllerClass implements MyEventListener {
	private ModelClass model;
	private ViewClass view;

	public ControllerClass() {
		model = new ModelClass();
		view = new ViewClass();

		model.addEventListener(MyEventNumModel.MODEL_EVENT1, this);
		model.addEventListener(MyEventNumModel.MODEL_EVENT2, this);

		view.addEventListener(MyEventNumView.VIEW_EVENT1, this);
		view.addEventListener(MyEventNumView.VIEW_EVENT2, this);
	}

	// gestion des événements du modèle de la vue
	public void eventPerformed(GameEvent e) {

		// si l'événement est levé par le modèle
		if (e.getEventSource() instanceof ModelClass) {

			// quel est l'événement ?
			switch((MyEventNumModel)e.getEventType()) {

				case MODEL_EVENT1:
					break;

				case MODEL_EVENT2:
					break;
			}

		// sinon si l'événement est levé par la vue
		} else if (e.getEventSource() instanceof ViewClass) {

			// quel est l'événement ?
			switch((MyEventNumView)e.getEventType()) {

				case VIEW_EVENT1:
					break;

				case VIEW_EVENT2:
					break;
			}
		}

	}
}

Cette implémentation fonctionne très bien. Toutefois on pourrait lui reprocher le fait que les objets qui émettent des événements, à savoir ViewClass et ModelClass, soient si fortement liés à la classe MyEventDispatcher que cela bloque tout autre héritage. Des solutions existent, mais me concernant cela fera l’objet d’un prochain article

Références:
http://rom.developpez.com/java-listeners/

Le redimensionnement dynamique de l’animation flash : de plus en plus de site l’utilise. Que ce soit pour un bandeau de publicité ou pour afficher un catalogue de produit, d’abord surprenante, on s’aperçoit vite que cette technique est diablement efficace.

Par quelle magie peut-on arriver à ce résultat ? Une première partie de la réponse est qu’en pratique il ne faut pas chercher à redimensionner l’animation Flash mais plutôt l’objet HTML dans lequel l’animation est imbriqué. Afin que l’animation se redimensionne automatiquement, il faut définir la largeur et la hauteur de l’animation à 100%. Ainsi l’animation prend 100% de l’objet HTML dans lequel il est imbriqué et si on change la taille de cet objet, Flash se redimensionnera tout seul.

Concrètement, si on utilise une balise « div », cela se traduit par le code suivant :

<div id="animationID" style="width: 200px; height: 300px;">
   <object id="monanimation" width="100%" height="100%">
       <param name="src" value="monanimation.swf" />
       <param name="name" value="monanimation" />
       <embed id="monanimation" width="100%" height="100%" src="monanimation.swf" name="monanimation"></embed>
   </object>
</div>

L’autre partie de la réponse se trouve dans la capacité de Flash à communiquer avec le code HTML qui l’héberge et plus particulièrement avec  le code JavaScript présent sur la page. En effet pour changer les propriétés d’une balise HTML, il conviendra d’implémenter des interfaces JavaScript afin d’assurer la communication entre l’animation et le code HTML. Dans Flash cette fonctionnalité s’appelle « FSCommand ».

Ainsi pour activer FSCommand dans une animation Flash et définir la taille à 100% dans le code HTML, il suffit de choisir comme modèle d’exportation HTML le modèle : « Flash avec FSCommand » et de définir les dimensions dans les paramètres de publication du format HTML.

L’utilisation de FSCommand se fait forcement par le biais de la programmation Flash. Si d’un côté nous avons le langage JavaScript, dans Flash le langage utilisé est ActionScript.

Créé en 1998 l’ActionScript a eu 3 itérations. Avec l’avènement de la version 3 en 2009, le langage a complètement changé de logique. Dorénavant orienté objet, ce langage est devenu plus mature, plus normalisé et son appréhension devient plus naturel pour ceux qui développe en POO (Programmation Orienté Objet).

Dans Flash, la communication avec la page qui l’héberge se fait par l’appel de fonctions déclarées en JavaScript. Cet appel se réalise en utilisant la méthode de classe :

ExternalInterface.call(nom_fonction, param1, param2, ...).

Ainsi en écrivant ceci dans le code de l’animation Flash :

ExternalInterface.call("setSWFHeight", 400);

J’appel l’interface implémenté dans la page HTML ci-dessous :

<script type="text/javascript" language="JavaScript">
    function setSWFHeight(_height) {
        alert("Ca marche : " + _height + " !");
    }
</script>

Une fois la communication assuré, il ne manque plus que d’implémenter la fonction setSWFHeight correctement.

Pour conclure vous trouverez ci-dessous le code final réalisant le redimensionnement dynamique d’une animation Flash.

// Ajout du package ExternalInterface
import flash.external.ExternalInterface;

// code actionscript... //

// à utiliser dans un évènement onClick, etc...
ExternalInterface.call("setSWFHeight", 1000);

<script type="text/javascript" language="JavaScript">
	function setSWFWidth(_width){
		document.getElementById("animationID").style.width = _width+"px";
	}

	function setSWFHeight(_height){
		document.getElementById("animationID").style.height =_height+"px";
	}
</script>
<div id="animationID" style="width:200px; height:300px;">
   <object classid="clsid:d27cdb6e-ae6d-11cf-96b8-444553540000" codebase="http://fpdownload.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=10,0,0,0" id="monanimation" width="100%" height="100%" align="middle">
      <param name="allowScriptAccess" value="always" />
      <param name="movie" value="monanimation.swf" />
	  <param name="quality" value="high" />
	  <embed src="monanimation.swf" quality="high" width="100%" height="100%" swLiveConnect=true id="monanimation" name="monanimation" align="middle" allowScriptAccess="always" type="application/x-shockwave-flash" pluginspage="http://www.adobe.com/go/getflashplayer_fr" />
   </object>
</div>

En admettant simplement que le réel est ce qui existe effectivement par opposition à l’imagination, on peut dire alors que intrinsèquement la couleur n’existe pas.

En réalité, la couleur n’est qu’une perception subjective de l’oeil. Sans ce dernier, il n’y aurait pas de couleur. Toutefois cette perception induit qu’un élément fondamental est à l’origine : la lumière blanche. En effet, cette lumière est composé de plusieurs ondes avec des fréquences et des amplitudes différentes. Ce sont ces ondes que notre oeil interprète comme une couleur.

fig. 1 – La lumière blanche peut être décomposé et recomposé à l’aide de prisme

Ce spectre est vaste et l’oeil humain n’est pas capable d’en percevoir la totalité. D’ailleurs chaque individu possède son propre spectre visible. Effectivement, nous ne percevons pas tous la même fourchette de couleurs en raison de l’âge, de la cornée, etc. Malgré cela, on est capable d’affirmer que chez l’Homme, le spectre visible varie entre 400nm et 700nm, ce qui se traduit par une variation de la couleur du violet au rouge. Au dessous se trouve alors les ultra-violets et au dessus les infra-rouges.

fig. 2 – Le spectre visible de l’oeil humain

Si l’oeil est par conséquent le seul outil de perception, on peut alors se poser la question de savoir si d’autres espèces l’interprète de la même façon. Mark L. Winston dans son ouvrage « La biologie de l’Abeille » annonce que le spectre visible de l’abeille est différent du notre et qu’il s’étend dans les basses fréquences des ondes. Grâce à cela l’abeille serait capable de voir le soleil caché derrière un nuage !

fig. 3 – Comparaison entre le spectre visible chez l’homme et l’abeille

La couleur des objets

Maintenant que nous savons que l’oeil et la lumière blanche sont à l’origine des couleurs, on est en droit de se demander comment on perçoit les couleurs des objets, comment cela fonctionne ?

Si nous projetons une lumière blanche (qui correspond à l’ensemble des ondes du spectre y compris le spectre visible) sur un objet, ce dernier va absorber tout ou partie les ondes et renvoyer les autres. Notre oeil va alors percevoir les ondes réfléchis et ainsi déduire une couleur. Si un objet nous apparait de couleur blanche, c’est parce qu’il n’absorbe aucune onde alors qu’un objet qui les absorberais toutes nous paraîtrait de couleur noire.

D’une autre manière : si nous éclairons le même objet mais avec une lumière qui n’est pas blanche : une lumière d’un projecteur comme ceux que l’on peut trouver dans les salles de concert. De quelle couleur va apparaître mon objet ? Si je prend comme exemple un cube d’origine bleu (sous la lumière blanche) que j’éclaire avec un projecteur rouge, celui-ci apparaîtra violet. Cette expérience, toute bête, qui fonctionne exactement de la même façon qu’avec de la lumière blanche, démontre une chose importante : il est possible de changer la couleur de l’objet ! A la vue de ces caractéristiques, nous pouvons en déduire que ni le cube et ni aucun objets autour de nous possède une « propriété » couleur : seule la source lumineuse et une certaine propriété d’absorption sont à l’origine de ce que notre oeil interprète comme une couleur.

fig. 4- Couleur bleu d’un objet

La représentation d’une couleur

Si la couleur n’existe pas, comment peut-on la mesurer et la reproduire ? La colorimétrie est la science qui tente d’apporter des réponses. Tout d’abord il faut être capable de définir les caractéristiques d’une couleur. Il existe plusieurs méthodes de représentation. Pour l’exemple je n’en citerais que deux, les plus connus :

• la synthèse additive et le format de codage RVB (rouge, vert et bleu) utilisé en vidéo ;
• la synthèse soustractive avec le CMJ (cyan, magenta et jaune) utilisé notamment en peinture.

fig. 5 – Les synthèses additive et soustractive

Toute deux se basent sur la trichromie en utilisant les couleurs que l’on appelle primaires dans la synthèse additive, et les couleurs secondaires pour la synthèse soustractive (cf. la figure 5 pour le fonctionnement de ces méthodes). Toutefois si l’on devait retenir un système qui se rapproche le plus de notre perception des couleurs on utiliserait le modèle TSL composé :

• d’une teinte (angle sur le cercle des couleurs) ;
• d’une saturation (intensité de la teinte) ;
• d’une luminosité (pourcentage de blanc apporté à la teinte).

fig. 6 – Le modèle TSL

Mais alors pourquoi parle-t-on souvent de RVB dans la vie de tous les jours alors que le modèle TSL se rapproche plus de la réalité ? La réponse se trouve dans la composition de l’oeil humain.

L’oeil humain est composé de 3 types de cônes : le cône erytholabe, le cône chlorolabe et le cône cyanolabe. Chaque cône est respectivement sensible aux couleurs : rouges/oranges, verts et bleus/violets. Le modèle RVB est facilement exploitable d’autant plus que finalement c’est de cette façon que notre oeil fonctionne. RVB est la méthode la plus utilisé notamment dans la représentation des couleurs en photo/vidéo : les tubes cathodiques de nos anciennes télévisions, les écrans LCD mais aussi l’imprimerie ou les pellicules de cinéma. De recherches laissent penser que chez certaines personnes il existerait un quatrième cône qui serait sensible aux oranges.

fig. 7 – Correspondance entre les cornées de l’oeil humain et le spectre visible

Le mot de la fin

En résumé et pour finir, tous ces modèles ne définissent en aucun cas les propriétés d’une couleur. Elle ne sont que des méthodes pragmatiques permettant d’apporter une « certaine » compréhension de notre monde.

Références : http://www.colorimetrie.net, http://fr.wikipedia.org, http://www.profil-couleur.com

Voici un de mes premiers tutorial du net. J’espère qu’il vous aidera dans votre apprentissage du C.

Le langage C a été mis au point par D.Ritchie et B.W.Kernighan au début des années 70. Leur but était de permettre de développer un langage qui permettrait d’obtenir un système d’exploitation de type UNIX portable. D.Ritchie et B.W.Kernighan se sont inspirés des langages B et BCPL, pour créer un nouveau langage: le langage C. La première définition de ce langage a été donnée dans leur livre commun « The C programming language ». Toutefois, suite à l’apparition de nombreux compilateurs C, l’ANSI (abréviation de American National Standards Institute) a décidé de normaliser ce langage pour donner ce que l’on appelle le C-ANSI. Suite à cette norme, Ritchie et Kernighan ont sorti une deuxième édition du livre en intégrant les modifications apportées par l’ANSI. Le langage C reste un des langages les plus utilisés actuellement. Cela est dû au fait que le langage C est un langage comportant des instructions et des structures de haut niveau (contrairement à l’assembleur par exemple) tout en générant un code très rapide grâce à un compilateur très performant. Les performances du langage C sont en réalité dues au fait que les instructions du langage sont proches du langage machine, ce qui se traduit par un programme compact (donc rapide) dans la mesure où le programmeur respecte une syntaxe proche des spécifications… Ainsi, les programmes en C sont très peu longs. En contrepartie le langage C reste un langage assez compliqué.

Qu’est-ce qu’un programme ? Un programme est tout simplement une suite d’instructions qui s’exécutent. Ces instructions sont envoyées au microprocesseur, qui se charge de les traiter, et de contrôler l’ensemble de votre Unité Centrale (UC). Comme il s’agit d’un dialogue avec le microprocesseur, il donc faut un langage de communication. Ce langage se nomme le langage machine. Il faut savoir que le langage machine est fait de 0 et de 1 (binaire). Pourquoi du binaire ? La simplicité même. Comme le microprocesseur est fait de composants électroniques, il ne circule que du courant. Et donc par convention, faire passer du courant dans une certaine fourchette de Volts (par exemple entre 3V et 4V) équivaut à 1, en faire passer dans une autre fourchette (par exemple entre 1V et 2V) équivaut à 0. Ainsi avec notre assemblage de circuits électroniques, notre convention pour communiquer avec lui, bah on va pouvoir écrire des programmes avec des 0 et des 1 !!!! C’est pas génial ?! Hum oué, je vois que vous aimez pas ! C’est exactement ce que les développeurs se sont dis ! Afin de pouvoir contrôler un microprocesseur par programmation, les développeurs ont ajouté un jeu d’instructions permettant donc de mieux commander le sujet. Ces instructions sont appelées Assembleur. En voici un exemple :

add di, bx
mov es:[di], al
in al,dx
test al, 08h
jz 0011423

Il faut savoir que l’assembleur est le langage naturel de l’ordinateur et sa maîtrise vous permettra de faire beaucoup de choses. L’écrivain Rudy Rucker, dont je vous invite à lire sa page Wikipédia, disait : « Le langage Assembleur, c’est vraiment simple, c’est comme de programmer en ADN ! ». Composé d’instructions basiques ce langage est très puissant, mais il rebute beaucoup de personnes car sa programmation est longue et complexe. Plus tard de nouveaux langages dis de « haut niveau » (c’est à dire plus proche du langage humain) font leur apparition : le Basic, le Fortran, l’Ada, le Cobol, le Pascal, le C… Mais comment fonctionnent tous ces langages ? Comment peut-on écrire des EXE (pour windows) à partir d’un langage ? Réponse : avec un ensemble d’outils proche des systèmes d’exploitation que l’on nomme : compilateurs. Les compilateurs, prennent un fichier avec du code écrit dans un langage spécifique, et vont le transformer les fichiers texte en un exécutable. Comme ce tutoriel s’oriente vers le langage C, je vais prendre pour exemple les compilateurs C. Voici les étapes de la « compilation » d’un fichier C :

Le compilateur prend le fichier C le compile en fichier OBJ : il le traduit en langage machine. Ce fichier en langage machine donc maintenant être prêt à être exécuté ? Pas tout à fait. Pour pouvoir être exécuté il faut transformer une nouvelle fois, ce binaire en un fichier lisible par le système d’exploitation. Je parle du format qu’on les fichiers EXE dans un système d’exploitation. Exemple, si je veux qu’il s’exécute sous Windows, il faut que je convertisse ce fichier OBJ dans le format EXE pour Windows. Cet étape s’appelle donc l’Édition de liens.

Expliquons maintenant les règles de programmations en C. Ce langage possède certains mot clé. Les mots clés sont des commandes déjà intégré au langage et par conséquent ils ne peuvent être qu’utilisé. Par exemple pour créé une nouvelle variable en C on procède comme suit :

int maVariable;

Ceci déclare une nouvelle variable. Une variable est comme une sorte de boite d’une certaine taille dans laquelle on va ranger une valeur. Si je parle de « taille » c’est parce que la mémoire d’un ordinateur à ses limites et on ne peut pas créer n’importe quelle boite avec n’importe quelle taille. Ainsi l’unité de mesure est l’octet. Il existe certains mots clés pour définir la taille et dans l’exemple précédent il s’agit du mot « int ». Une variable de type int, signifie qu’elle fait partie du domaine des nombres entiers et qu’elle prend en mémoire (dans la mémoire vive) 2 ou 4 octets (en fonction des compilateurs).

Le nom « maVariable » correspond à l’intitulé que je donne à ma boite. Bien évidemment on ne peut pas donner n’importe quel nom. Si par exemple j’écris en C ceci:

int main;

cela provoque une erreur. Pourquoi ? Parce que main est un mot clé du langage C et ne peux donc être utilisé ainsi (c’est à dire comme la définition d’une variable).

Le C différencie les majuscules des minuscules. Exemple:

// ces deux caractères définissent que ce qui suit sera un commentaire
int toto; // ok
int Toto; // ok
int tOto; // ok
int toto; // faux car int est un mot clé et il est défini en minuscule

La dernière commande est bien entendu fausse. Chaque ligne d’instructions en C fini par un ; afin d’indiquer d’indiquer au compilateur que la ligne est fini et qu’il faut passer à la suivante. Le texte qui suit et qui commence par « // » indique qu’il s’agit d’un commentaire.

Comme je vous sens impatient pour faire du code, je vais donc commencer avec un exemple connu à travers le monde entier, j’ai nommé : HELLO THE WORLD!

#include <stdio.h>

void main(void) {
     printf("Hello the World!\r\n");
}

Ce code source a pour but d’afficher le message: « Hello the World!« . Je vais tout d’abord commenter la commande  » void main(void) « .

Il s’agit en fait d’une déclaration d’une fonction. Une fonction exécute l’ensemble des instructions qu’elle contient. Ici cette fonction n’est pas n’importe laquelle, c’est le point d’entré du programme, c’est-à-dire que lorsque nous exécuterons notre programme (une fois compilé) il exécutera les instructions qui se trouveront en premier lieu dans cette fonction.

Vous pouvez remarquer que le symbole qui marque le début de ma fonction est « { » et celui qui marque la fin est « } ». La déclaration de fonctions sera traitée dans le chapitre « Fondements du C ». Ensuite dedans, on trouve un nom bizarre « printf « . Il s’agit en fait d’une fonction déjà existante dans le langage C ! En effet, dans tous les langages on trouve des fonctions primitives et des opérateurs permettant d’effectuer toutes les opérations possible de base. Ici la fonction « printf » a la capacité d’afficher en message le 1er paramètre que l’on va lui donner. Pour l’instant retenez que chaque fonction a cette syntaxe: <nom_de_la_fonction>(param1, param2, …). Ici le 1er paramètre est : « hello the world! ».  Ce 1er paramètre est une chaine de caractères. On le remarque notamment grâce aux guillemets  »  » qui l’entoure. Pour indiquez à C qu’une instruction est terminée et qu’il doit passer à l’instruction suivante, on la termine par le caractère point-virgule  » ; « .

Enfin, tout en haut vous voyez l’instruction :  » #include <stdio.h>« . Il s’agit d’une commande dite commande préprocesseur. Elle indique tout simplement à C d’ouvrir le fichier « stdio.h » qui se trouve dans le dossier « include » ou « h » de votre compilateur. Ce fichier est en fait une librairie qui contient des définitions de types, de fonctions, et beaucoup d’autres choses. On peut donc en déduire, que « stdio.h » nous permet d’utiliser la fonction « printf « . Sans l’inclusion de ce fichier, le compilateur ne trouverais pas la définition de la fonction « printf« .

Toutes les fonctions de base sont définies dans des fichiers « h« . Ainsi tout appel à une fonction de base, nécessite d’indiquer à C où chercher sa définition. Les commandes préprocesseur seront traités dans le chapitre « Préprocesseur ».

Qu’est-ce qu’un commentaire ? Il s’agit d’une ou plusieurs ligne où l’utilisateur pourra saisir tout ce qu’il lui passe par la tête ! En bref, les commentaires, sont des messages en français qui vont vous aidez dans votre tâche de programmeur. Lorsque vous créez des programmes qui font plus de 10 000 lignes de code, insérer quelques commentaires par-ci, par-là dans le code vous permettra de bien comprendre ce que vous faites. Comment écrire un commentaire ? En C il existe deux facons de déclarer des commentaires. Si votre commentaire doit tenir sur 1 seule ligne, on utilisera alors : « // « , sinon pour un commentaire sur plusieurs ligne, on utilisera pour marquer le début : « /*« , et pour marquer la fin : « */ « .

Voici un exemple dans le programme « HELLO THE WORLD! »:

// ceci est un commentaire sur une ligne
/* ceci est un commentaire sur
plusieurs
lignes
*/

// définition du point d'entrée
void main(void) {
    printf("Hello the World!\\r\\n");
}

Le compilateur, lorsqu’il traite votre fichier C ignore ces commentaires, et s’occupe uniquement de votre code. Les commentaires servent énormement à tous bon programmeur, alors sachez en abuser, car c’est gratuit !!

Dans tous langages, lorsque vous programmez, vous devez manipuler des données, afin de traiter des informations. Toutes ces données, doivent être ranger dans des types de données codé sur ce que l’on appelle « Octet ». Voici un schéma sur la codification d’un octet en mémoire :

Un octet équivaut à 8 Bits (0 ou 1). Avec un octet on possède 256 façons de placer des 1 et des 0, on peut donc obtenir alors un nombre compris entre 0 et 255, soit 256 nombres possibles. Si on doit déclarer le type de donnée, c’est pour que C puisse réserver la mémoire dans une certaine taille, et sa forme de mémorisation. En C, il existe deux types de données : celles qui sont standard (prédéfinis) ou celle que les utilisateurs crée (définis).

En résumé, on trouve :

Type Entier (sans décimales)

• type char : défini un type entier occupant 1 octet en mémoire ;
• type short : défini un type entier occupant 2 octets en mémoire ;
• type int : défini un type entier occupant 2 ou 4 octets en mémoire ;
• type long : défini un type entier occupant 4 octets en mémoire.

Tous les types peuvent être déclarés soit signed (par défaut) soit alors unsigned. Dans le premier cas, la donnée est signée, c’est à dire que sa valeur peut être négative. Tandis que dans le deuxième cas, la valeur sera positive. On obtient donc le résultat suivant :

• type signed char : la valeur de cette donnée sera comprise entre -128 et 127 ;
• type signed short : la valeur de cette donnée sera comprise entre -32 768 et 32 767 ;
• type signed int : la valeur de cette donnée sera soit de type signed short, soit de type signed long ;
• type signed long : la valeur de cette donnée sera comprise entre -2 147 783 648 et 2 147 483 647 ;
• type unsigned char : la valeur de cette donnée sera comprise entre 0 et 255 ;
• type unsigned short : la valeur de cette donnée sera comprise entre 0 et 65535 ;
• type unsigned int : la valeur de cette donnée sera soit de type unsigned short, soit de type unsigned long ;
• type unsigned long : la valeur de cette donnée sera comprise entre 0 et 4 294 967 295.

Mais alors pourquoi selon que le type soit signée ou pas, la fourchette de nombre diffère pour un même type ??? On va prendre le type le plus simple: Le type char.

char occupe en mémoire un et un seul octet, et en binaire il n’existe pas de nombre négatif. Alors comment peut-on dire que le type signed char existe ? Le type signed, réserve simplement le 8ème bit pour dire si notre type est positif ou négatif. Si le 8ème bit vaut 1 alors notre nombre est négatif, sinon il est positif. Donc si on refais nos calculs pour connaitre le nombre de possibilités d’un type, le fait qu’on réserve tout le temps le 8ème bit pour le signe, alors il ne nous reste plus que 7 bits pour notre nombre ! Soit 2^7 = 128 possibilités. On obtient donc pour le type signed char (7 bits) : -128 à +127. Tandis qu’avec le type unsigned char (8 bits) : 0 à +255. C’est le même principe pour tous les autres type entiers.

En C, le type par défaut est signed (c’est à dire sans préciser si il est signed ou unsigned). Bien alors dans la 1ère partie nous avons pu voir de manière général le fonctionnement du C et son histoire. Nous allons un peu récapituler tout cela.

• Le C est un langage de haut niveau procédural (il s’exécute ligne par ligne) ;
• Pour terminer chaque instructions (autres que logiques) il faut saisir « ; » ;
• C fait la différence entre les minuscules et majuscules ;
• Le point d’entrée de tout programme commence par (définition par défaut) : void main(void) ;
• Dans Visual C++ par exemple les mots clés sont écris en BLEU. Ces mots clé font partie intégrante du noyau même de C ;
• On peut placer des commentaires dans le code afin de s’y réperer plus tard ;
• Il existe 4 grand type d’entier (dans l’ordre du plus petit en place mémoire au plus grand) char, short, int et long. Toutefois on peut préciser si ils sont signé ou pas (si ils peuvent prendre des valeurs négative ou pas).

Un compilateur c’est quoi ? Il s’agit d’un ensemble de fichiers regroupant des éxecutables et des librairies. Prenons l’exemple de Visual C++. Ouvrons son dossier d’installation, puis allons dans le dossier « VC98″ (dossier ou est installé le compilateur VC++). Vous devriez avoir quelque chose comme l’écran suivant :

Vous avez trois dossier spécifique au compilateur Visual C++ 6.0 et auxquels l’on ne va pas s’interesser il s’agit de : « ATL », « CRT » et « MFC ».

• Le dossier BIN va regrouper tout les exécutables (les programmes) du compilateur, celui qui va compiler, celui qui va faire l’édition des liens et beaucoup d’autres. Son nom BIN est tiré de Binaire ;
• Le dossier Include va regrouper tous les fichiers h (fichiers d’en-têtes) qui vont servir de déclarations des fonctions déjà existantes en C (par exemple math.h pour les fonctions mathématique) ;
• Le dossier Lib va regrouper tous les fichiers lib (fichiers librairies) qui eux servent de fichier de définitions. Contrairement aux fichiers h les fichiers lib, ne sont pas en texte clair. Ils contiennent toutes les définitions les fonctions elle même.

Prenons un exemple pour mieux comprendre : la fonction printf(). Dans le fichier stdio.h on trouvera :

_CRTIMP int __cdecl printf(const char *, ...);

Comme on peut le voir il s’agit juste d’une déclaration de la fonction printf() on ne voit pas les détails de cette fonction, c’est-à-dire les instructions saisies dedans pour obtenir l’affichage à l’écran. En effet la définition de cette fonction se trouve dans un fichier lib associé. Laquelle ? Avec Visual C++ 6.0 je ne sais pas ! Le logique du C veut que pour un fichier h on ait un fichier lib équivalent avec un même nom. Cependant comme il s’agit des fichiers prédéfinis par le compilateur, cette logique n’est pas vraiment respecté.

Une variable est comme une boîte ou l’on range une certaine valeur. Cette boite possède un certain « format ». Comme on a pu le voir dans la 1ère partie. Ces formats sont en fait le type d’une variable. Etant codé de 1 à 4 octects on peut y ranger une valeur plus ou moins importante. Par exemple, une variable de type char non signé (codé sur 8 bits avec aucun bit réservé pour le signe +/-) peut prendre une valeur de 0 à 255. Si l’on souhaite ranger la valeur 257 dans cette variable cela ne marchera pas. La syntaxe pour déclarer une variable est la suivante : <type_de_la_variable> nom_de_la_variable; Cette déclaration est vrai pour toute les formes de déclaration d’une variables que ce soit comme ca en globale, en locale dans une fonction ou encore en tant que paramètre. En ce qui concerne des types, j’en ai omis un volontairement car beaucoup plus compliqué pour l’explication de son codage en mémoire : il s’agit du nombre réel (avec décimal). Pour ranger des nombres à virgule dans une variable il faut utiliser les types : float, double ou long double selon le nombre de décimal que l’on souhaite. double étant plus précis et long double encore plus précis. Toutefois c’est très rare que l’on utilise le type double et long double (car lent). Exemple :

float Pi;
Pi = 3.14159

Pour attribuer une valeur à une variable il suffit de faire par exemple :

myVar = 10;

On peut attribuer une valeur par défaut à une variable lors de sa création :

int myVar = 10;

Les opérations concernant les variables sont :

• + (addition)
• - (soustraction)
• / (division)
• % (modulo : reste d’une division)
• * (multiplication)

Exemple :

char myVar = 0;

myVar = myVar * 5 + 6 - 2;
myVar = myVar + 1;

(Les ordres de priorités sont les mêmes qu’en mathématiques.) Il existe certains « raccourci » aussi pour effectuer plus rapidement des opérations. Vous allez comprendre :

myVar *= 5;  // égal à myVar = myVar * 5;
myVar /= 3;  // égal à myVar = myVar / 5;
myVar -= 10; // égal à myVar = myVar - 10;
myVar += 1;  // égal à myVar = myVar + 1;
myVar++;     // égal à myVar = myVar + 1;
myVar--;     // egal à myVar = myVar - 1;

On peut toutefois effectuer des opérations binaires sur les nombres à l’aide des commandes suivantes :

• & (ET logique)
• | (OU inclusif)
• ^ (OU exclusif)

Les tableaux sont identiques aux variables sauf qu’ils prennent plusieurs « cases » mémoire et permettent de ranger plusieurs valeurs dans une même variables à l’aide d’un index. Exemple :

char monTablo[10];

Ici on à déclaré un tableau appellé monTablo de 10 cases de type char. C’est-à-dire que chaque case du tableau prendra 1 octet mémoire. Pour accéder à une case donné il suffit de lui passer en index (entre crochet) son numéro de case. ATTENTION ! La numérotation des cases se fait TOUJOURS à partir de 0 :

monTablo[0] = 1; // ok 1ère case mémoire
monTablo[9] = 2; // ok 10ème case mémoire
monTablo[10] = 3; // erreur car la case numéro 10 n'existe pas !

Qu’est-ce qu’une fonction ? Une fonction est un ensemble d’instructions regroupé dans un sous programme nommé. La facon la plus compréhensible par tous est sans aucun doute celle de faire l’analogie avec les maths ! En maths on décrit la fonction affine comme ceci : y = f(x) = ax+b. Ici la fonction s’appelle F. Cette fonction est un peu différente d’une fonction simple. En effet il s’agit d’une fonction paramétrable. A quoi le voit-on ? Il s’agit du x entre parenthèses. En passant dans x une valeur quelconque la fonction va effectuer un traitement. Ce traitement est : a * x + b. a et b ne sont pas défini mais on pourrait très bien l’imaginer. Une fois ce traitement fait que ce passe-t-il ? Et bien F (notre fonction) va renvoyer le résultat de ce traitement, et c’est y qui va la recevoir. Et donc on retombe sur ce que l’on nous a appris : f(x) = ax + b, permet pour une valeur x d’obtenir son image y. Il s’agit des coordonnées x, y dans un plan cartésien. Alors les maths c’est beau, mais ce n’est pas tout. Cet exemple nous permet de bien voir que la notion de « fonction » ne nous est pas inconnu. Voici la syntaxe d’une fonction en C :

void nom_de_la_fonction(void) {
   // instructions
}

Il s’agit d’une fonction sans paramètres, et cette fonction ne renvoi aucune valeur. On appelle en général ce type de fonction : une procédure. Une procédure est un simple sous programme pour faire des tâches (en lui passant des paramètres ou pas) mais à la différence d’une fonction elle ne renvoie rien. Alors on peut se demander à quoi ca sert d’écrire une procédure simple comme celle ci (sans paramètres) ? Et bien imaginez que vous souhaitez afficher par exemple un message et qu’ensuite vous souhaitez attendre que l’utilisateur presse une touche. Ceci prendra donc plusieurs lignes d’instructions. Imaginez ensuite que vous souhaitez faire ce processus à plusieurs reprise dans votre programme (dans void main(void)). Vous allez réecrire toutes les lignes à chaque fois ? Non, le mieux c’est d’écrire une fois ce traitement dans une simple procédure et ensuite de l’appeller à chaque fois que vous en aurez besoin.

Détaillons à présent la syntaxe de la déclaration de cette procédure. Le premier mot que vous voyez est void. « void » correspond au type de de la valeur qui sera renvoyé par notre fonction (cf. y = f(x)). Comme il s’agit d’une simple procédure (qu’on ne veux rien renvoyer), on utilise le mot clé : void. Ce mot clé défini le type de valeur VIDE. Si on aurez voulu renvoyer une valeur de type entier codé sur 2 octets, il aurait fallu saisir :

short nom_de_la_fonction(void)

Ensuite entre parenthèse c’est ici que l’on va définir les paramètres que l’on souhaite avoir pour notre fonction. Ici on en veut pas, on a donc mis une nouvelle fois : void. La syntaxe concernant les paramètres est la suivante : <type> nom_de_la_variable1, <type> nom_de_la_variable2, …

Pour exemple on peut écrire la fonction CARRE qui va calculer la valeur carré d’un nombre et la renvoyer :

int carre(int valeur) {
    return valeur * valeur; // renvoi une valeur de type int, car int * int = int
}

Le mot clé return permet de renvoyer un résultat (du même type que la fonction) et de sortir de la fonction aussitôt.

Qu’est-ce que le préprocesseur ? Il s’agit de commandes bien spécifique qui vont s’exécuter avant la compilation du code source. Je dirais même que la compilation se détermine en fonction justement des commandes préprocesseur. Sans entrer pour l’instant dans les détails, je vous explique ici la commande préprocesseur la plus utilisé dans la programmation C : #include. Comme on l’a vu dans la 1ère partie, #include va servir de référence sur certaine fonctions déjà écrite en C. Par exemple la fonction printf() qui écrit un message texte à l’écran à besoin du fichier stdio.h. Lorsqu’on appelle cette fonction dans notre programme, le compilateur ne va pas savoir d’ou viens cette fonction printf(). Rappellons que le compilateur ne connait que les mots clé, la syntaxe général du C et les commandes préprocesseur. C’est pourquoi il faut alors préciser dans quelle fichier se trouve ce que l’on appelle la « déclaration » de cette fonction. Pour printf(), celle-ci se trouve dans le fichier STDIO.H. Nous savons ou ce trouve les fichiers .H et nous savons qu’en regardant dedans on va trouver la déclaration de la fonction printf(). Donc voila la commande à rajouter tout en haut de notre fichier pour utiliser la fonction printf():

#include <stdio.h> // pour printf

Mais la commande #include ne s’arrête pas la. On peut voir que notre fichier .H se trouve entre < et > et parfois dans notre programme on pourrait très bien écrire la syntaxe suivante : #include « monfichier.h ». Où est la différence ? La différence est que l’on met le nom du fichier d’en-têtes entre  » et  » lorsque ce fichier se trouve dans le même dossier du projet que l’on travaille, et on met le nom du fichier d’en-têtes entre < et > lorsque ce fichier se trouve dans le dossier par défaut du compilateur. Il existe une autre commande préprocesseur souvent utilisé, il s’agit de la commande #define. Cette commande est ce que l’on appelle une macro en général. Elle permet entre autres de définir certains mots. Ces mots correpondront à une valeur.
Par exemple:

#define MAX_MESH 60

void affiche(void) {
    if (MAX_MESH == 60) printf("ok");
}

Ici on peut voir la définition d’un mot clé : MaxMesh qui à pour valeur 60. Cette commande est traité avant la compilation du code (car c’est une commande préprocesseur). Que va faire alors le compilateur ? Et bien c’est simple, il va remplacer TOUT les mots MaxMesh du code source par 60.

Donc dans notre exemple ca deviendra :

void affiche(void) {
   if (60 == 60) printf("ok");
}

Ce qui est con dans ce cas la je vous l’accorde mais c’est à titre d’exemple.

Les commandes préprocesseurs ne sont pas influencé par la casse (majuscules/minuscules), contrairement au reste du code.

Un programme c’est quoi ? C’est des instructions qui s’exécute… c’est des données que l’on manipule, en résumé c’est beaucoup de choses. Tout ceci n’est pas fait sans ordre, mais avec une LOGIQUE. Cette logique c’est à vous de la définir à l’aide de différentes opérations et de CONDITIONS. La conditions la plus simple est sans aucun doutes le IF (traduction si). Si ceci alors cela… sinon si ceci alors cela… sinon faire ceci… Voila comment se résume le IF. Comment marche le IF ? Le IF fonctionne selon une table de vérité. Si ceci est vrai… alors tu fait ca… sinon tu fait ca… Comment cette table ce fait-elle ? En comparant. Exemple :

if (myVar == 3) {
printf("myVar vaut 3");
} else {
printf("myVar est différent de 3");
}

Examinons ce code. « if (myVar == 3) » se lie : si myVar est bien égale à 3. La comparaison myVar = 3 renvoi VRAI si c’est vérifié et FAUX si il y a erreur. Si cette condition est vrai alors le programme va executer ce qui suit ENTRE ACCOLADES. Ces accolades comme pour les fonctions définissent le début et la fin d’un bloc. Le mot clé suivant : ELSE va traiter TOUS LES AUTRES CAS si la condition précédente est fausse. C utilise une syntaxe particulière en ce qui concerne la comparaison, donc voici l’énumération :

• var1 == var2 (égal à) ;
• var1 != var2 (différent de) ;
• var1 <= var2 (inférieur ou égal à) ;
• var1 < var2 (inférieur à) ;
• var1 >= var2 (supérieur ou égal à) ;
• var1 > var2 (supérieur à).

Toutefois les conditions ne dépendent pas forcement que d’un seul paramètre on peut très bien avoir deux variables de tester. Exemple:

if (var1 == var2 && var2 == var3) {
}

On trouve ici un nouveau mot clé. Il s’agit d’opérateur de condition. Ici les deux comparaison doivent être VRAI pour entrer dans le if. Il existe plusieurs opérateur logique que j’énumère ici :

• && (ET logique : l’un doit être VRAI et l’autre aussi) ;
• || (OU logique : soit l’un doit être VRAI soit l’autre ou même les deux) ;
• ^^ (OU exclusif : soit l’un doit être VRAI soit l’autre MAIS PAS LES DEUX).

Il existe un mot clé spécial aussi pour définir la négation d’une condition, il s’agit de ! Par exemple:

// rentre dans le if si var1 == var2 est FAUX
// ce qui équivaut à if (var1 != var2)
if ( !(var1 == var2)) {
}

Toutes ces notions relève de la logique BOOLEENE. Il faut savoir que chaque comparaison possède un contraire exprimable avec ! ou même sans. IF n’est pas la seule conditions qu’il existe en C. Il en existe d’autres, toutefois elles servent de boucles. Il existes 3 type de boucles: WHILE (TANT QUE), DO WHILE (FAIRE TANT QUE) et le FOR (POUR UNE VALEUR DONNE REPETEE TANT QUE…) While est peut être la plus simple. La boucle s’execute TANT que la condition est vérifié. Exemple :

// ici on donne la valeur 3 à la variable myVar
myVar = 3;

// ici on rentre dans la boucle en faisant un premier test : si myVar = 3 alors on rentre
while ( myVar == 3 ) {
    // on exécute le code qu'on veut faire...

} // et la on remonte à while en haut et on refais un test si myVar est toujours égal à 3 alors on rerentre

// on arrive ici lorsque myVar est devenu différent de 3.

La boucle DO WHILE est identique à WHILE sauf qu’elle rentre au moins une fois dans la boucle sans faire de test Exemple :

// ici on donne la valeur 3 à la variable myVar
myVar = 3;

do {
} while (myVar == 3); // et on fais un test si myVar est égal à 3 alors on remonte à do et on recommence

// on arrive ici lorsque myVar est devenu différent de 3.

La dernière boucle est la boucle FOR. Cette boucle permet de partir d’un point à un autre. Elle est idéale pour parcourir une tranche d’un tableau.

// on initialise au début i à 0, et boucle tant que i est inférieur à 10
// a chaque boucle i s'incrémente de 1
for (i = 0; i < 10; i++) {
}

Voila pour ce premier tutorial que j’ai réédité. J’espère qu’il vous aura aidé dans votre démarche sur l’apprentissage du C.

Après pas mal d’années de réflexion, BlackSmurf.net renait de ses cendres !

Ce n’est pas sans une certaine émotion que je réouvre blacksmurf.net. En effet, après une très longue traversé du désert remplie de doutes et de remises en question, je m’efforce aujourd’hui à m’impliquer d’avantage sur la toile,  pour atteindre de nouveaux objectifs : réinvestir le web quant à mes projets de développement de jeux vidéo, reprendre confiance en moi, mais aussi travailler mon point faible : la communication. C’est avec vous, qu’aujourd’hui je souhaite relever ce défi et j’espère y arriver.

En attendant l’alimentation du contenu de ce site, soyez les bienvenues, vous êtes ici chez moi.

Rédigé par Mark McGuinness, cet ouvrage tente d’apporter de la méthode sur une des plus grande problématique dans le monde du travail : l’organisation de la journée de travail.

Cliquez sur le lien ci-dessous pour télécharger l’ebook gratuitement.

Time Management for Creative People