Dans cette société, tout tend de plus en plus à être objet. Et pas seulement en informatique.
Mais ne nous égarons pas. En bons geek que je suis, vous devinez que je vais encore troller débattre sur les langages objet Vs pas objet.
Et comme à mon habitude, je vais vous parler du C. Eh oui, pour entretenir la roussitude irlandaise, il faut de la vitamine C !
Au cours de ma vie étudiante, on m'a souvent dit :
- Java : objet C : pas objet
Pour faire de l'objet en "C", faites du C++. Ok...
Et puis en entreprise, t'apprends que toute façon, le Java, caylebien, et y paraîtrait même que certains iraient dire que le .SALE c'est encore mieux. Le développeur il a plus rien à faire, c'est pas magnifique ça ?
Bon, je simplifie, parce que pour dire vrai. Les langages qui assistent les développeurs. ça permet de gagner du temps pendant la phase de développement, et donc, gagner de l'argent. Et attention, c'est pas fini ! Quand l'application est enfin en prod, et qu'un bug survient, on peut facturer la résolution. Et comme dans beaucoup de cas, l'erreur sera induite par un comportement inexpliqué de l'application, la résolution durera longtemps (en général une durée inversement proportionnelle au temps gagné durant la phase de développement). Bref, au final, $$$$$$ !
Mais pour moi qui ne suis pas plus développeur, la programmation, c'est un peu comme de l'art.
Et puis tous ces arguments du "Ouay, mais en C faut maîtriser les pointeurs, caynul.", "P'tain, faut faire des malloc et des free, c'est chiant.", etc. Bah c'est du vent.
Et je vais tenter de vous montrer comment avoir moins peur du C face au Java.
On commence par le classique :
/* Exemple en Java */
public class Hello {
public static void main (String[] argv) {
System.out.println ("Hello World !");
}
}
/* Exemple en C */
#include <stdio.h>
#include <stdlib.h>
int main (int argc, char *argv[]) {
fprintf (stdout, "Hello World !\n");
return EXIT_SUCCESS;
}
Jusqu'ici, rien de bien méchant.
Maintenant, voyons donc ce que sont ces ci précieux "objets".
/* Exemple en Java */
public class Personnage {
public String nom;
public String prenom;
public int age;
}
/* Exemple en C */
typedef struct _Personnage Personnage;
struct _Personnage {
char[256] nom;
char[256] prenom;
int age;
};
Vous êtes toujours là ? Je sais pas vous, mais ici je ne vois pas vraiment de différences...
Ouais, mais là ton code est useless !
Passons donc à quelque chose d'un peu plus remplit.
/* Exemple en Java */
public class Personnage {
public String nom;
public String prenom;
public int age;
public Personnage (String _nom, String _prenom, int _age) {
this.nom = _nom;
this.prenom = _prenom;
this.age = _age;
}
public void presentation () {
System.out.println ("Bonjour, je m'appelle "+this.prenom+" "+this.nom+", et j'ai "+this.age+(this.age > 1 ? "ans" : "an")+".");
}
public static void main (String[] argv) {
Personnage michu = new Personnage ("Michu","Madame",72);
michu.presentation();
}
}
/* Exemple en C */
#include <stdio.h>
#include <stdlib.h>
typedef struct _Personnage {
char[256] nom;
char[256] prenom;
int age;
void(*presentation) (Personnage *this);
} Personnage;
Personnage* new_Personnage (char[256] _nom, char[256] _prenom, int _age) {
Personnage *ret = malloc (sizeof(*ret));
if (ret != NULL) {
ret->nom = _nom;
ret->prenom = _prenom;
ret->age = _age;
}
return ret;
}
void presentation (Personnage *this) {
if (this != NULL) {
fprintf (stdout, "Bonjour, je m'appelle %s %s, et j'ai %d%s.\n", this->prenom, this->nom, this->age, this->age > 1 ? "ans" : "an");
}
}
int main (int argc, char *argv[]) {
Personnage *michu = new_Personnage ("Michu","Madame",72);
if (michu == NULL)
return EXIT_FAILURE;
michu->presentation(michu);
free (michu);
return EXIT_SUCCESS;
}
Je vous accorde ici que le code C est un peu plus conséquent que son homologue en Java. Ceci est du au fait qu'on gère manuellement la mémoire. Cependant, ce n'est rien d'autre qu'un réflexe à prendre.
Si on y regarde de plus près, la gestion de la mémoire implicite en Java ne l'est pas tant que ça.
Prenons le code suivant :
/* Exemple en Java */
public class Test {
public void fonction1() {
System.out.println ("test");
}
public static void main (String[] argv) {
Test toto;
toto.fonction1(); // Null.Pointer.Exception !!!
}
}
En C, ça se traduit par un Segmentation Fault.
On peut donc assimiler le new de Java à un malloc en C.
C'est pareil pour les pointeurs et les références ! Quand vous faites un toto.mafonction(), que croyez-vous faire ?
Je vous ai ici présenté une très petite partie de la façon de faire du C "objet". Mais sachez qu'il existe des bibliothèques C orientées objet, comme la GLib.