Patrice Ferlet
Patrice Ferlet
Créateur de ce blog.
Publié le juin 29, 2009 Temps de lecture: 6 min

Me suivre sur Mastodon

OOC ou le C Objet

Découvert sur DLFP, je ne peux que m’empresser de vous montrer ce tout nouveau compilateur ou plutôt “meta compilateur” qu’est “ooc”. A la manière de ObjectiveC, ooc permet de travailler sur un langage objet simple et efficace, tout en proposant une compilation binaire. Le principe de ooc est de parser votre code, le transformer en C puis le compiler avec GCC.

La technologie ne faisant pas tout, le langage proposé est très important. Et ici, le ooc est un plaisirs des yeux. Typage, pointeur par défaut sur objets, réflexions, transparence… tout y est! Et comme vous allez travailler vers du C, la plupart des librairies sont utilisables: gcc, sdl, opengl… que dire de plus ? Et bien nous pouvons voir quelques exemples ensemble.

En premier lieu, installons nous une version de ooc (v 0.0.2 ici) de cette manière:

su -
#ou pour ubuntu, sudo -s
cd /opt
wget http://ooc-language.googlecode.com/files/ooc-linux-bin-0.2.tar.bz2
tar jxvf ooc-linux-bin-0.2.tar.bz2
cd ooc
ln -s /opt/ooc/bin/ooc /usr/local/bin
#testons:
ooc -V
# ooc v0.2 codename ninja, built on 2009-06-26 00:40:03

exit 

Ok c’est bon nous avons notre compilateur. Passons maintenant à un bon vieux “hello world” comme nous savons les apprécier :)

On va se faire un répertoire dans notre dossier utilisateur afin de travailler, puis on y entre, et enfin, on va coder:

(Passer en utilisateur, si vous êtes encore root)

mkdir ~/ooc-tutorial
cd ~/ooc-tutorial
gedit tutorial1.ooc &

Dans gedit, sélectionnez une coloration syntaxique java, ou si vous préférez utiliser vim, taper “Echap :set ft=java”. C’est la coloration la plus proche.

func main { printf ("Hello World !!!\n"); }

Voilà… notre premier test est créé. Sauvez et allez dans votre console, on va le compiler:

ooc tutorial1.ooc

Dans votre répertoire apparait un binaire, c’est bel et bien votre programme. Essayez de le lancer:

./tutorial1
# Hello World !!!

Et voilà pour le premier test.

OOC permet aussi de travailler avec des objets. Attention, il n’existe pas d’encapsulation de variables dans OOC, au point de vue sécurité des API c’est un peu la fête du slip rouge, mais l’objectif est de coder rapidement. A vous, développeur, de faire en sorte de bien coder et de bien documenter votre code.

Créez un second fichier, nommons le tutorial2.ooc, puis éditez le: ` //On crée une classe Person

class Person { String first_name, name; Int age; }

//on va utiliser notre classe: func main { Person p = new Person; p.name = “Foo”; p.first_name = “Bar”; p.age = “28”;

//affichons voir quelques informations:
printf ("Person name is: %s\n", p.name);
printf ("Person first name is: %s\n", p.first_name);
printf ("Person age is: %d\n", p.age);

}

`

On le compile de la même manière, et on teste:

ooc tutorial2.ooc
./tutorial2
#Person name is: Foo
#Person first name is: Bar
#Person age is: 28

Sympa non ? moi je trouve ça chouette :)

Bon, parlons maintenant de quelques spécificités de ooc. D’abords, tout les objets sont des pointeurs… ce qui implique qu’une fonction qui reçoit un Object et le modifie manipule l’objet par référence. Regardons un exemple: ` //On crée une classe Person

class Person { String first_name, name; Int age; }

//cette fonction va manipuler un pointeur d’objet func modifyPersonName (Person pers){ printf (“Modification…\n”); pers.name = “Baz”; }

//on va utiliser notre classe: func main { Person p = new Person; p.name = “Foo”; p.first_name = “Bar”; p.age = “28”;

//affichons voir quelques informations:
printf ("Person name is: %s\n", p.name);
printf ("Person first name is: %s\n", p.first_name);
printf ("Person age is: %d\n", p.age);

//ici on change l'objet
modifyPersonName (p);

//Et on vérifie:
printf ("Person name is: %s\n", p.name);
printf ("Person first name is: %s\n", p.first_name);
printf ("Person age is: %d\n", p.age);

}

`

On compile, on teste:

ooc tutorial2.ooc
./tutorial2
#Person name is: Foo
#Person first name is: Bar
#Person age is: 28
#Modification...
#Person name is: Baz
#Person first name is: Bar
#Person age is: 28

C’est effectivement très simple.

On continue encore… ? non, je vous laisse aller voir la page du langage de référence qui est très fournie et pourtant rapide à lire. Vous y verrez comment utiliser des packages, des espaces de nom, comment utiliser des librairies, comment travailler avec des références de fonctions, etc…

Un petit clin d’oeil à Java ici: Table 1-1. Correspondance tables of types in C, Java, and ooc un “hahahaha” placé sur la cellule “pointer to function” inexistant en Java :)

L’auteur explique aussi pourquoi il développe ce langage en “opposition” à Java et C#. Je retiens un aspect important qui fait que je me penche sur ooc depuis quelques temps: -Java est tendu. Vous avez besoin d’une infrastructure imposante pour utiliser des programmes développés en Java. -C# mono est un bon système mais tout comme Java il impose une infrastructure de développement imposante

Niveau langage: -Java et C# sont de bons langages, puissant et solides. Mais les restrictions et les “wrappeurs” pour les librairies telles que GTK ou OpenGL sont compliqués à passer. -La notion Pointeur de Java est tout relative, et en C# elle est purement et simplement catastrophique à utiliser. Ici, la gestion de pointeur et de référence est assez simple à appréhender -Rien à dire en terme de possibilités sur OOC, et le fait d’être un meta langage vers le C permet d’utiliser toutes les librairies existantes

Par contre: -OOC ne gère pas l’encapsulation et cela peut devenir très gênant ! -OOC ne permet pas (pas encore) de créer des librairies paratagées et je vous avoue que j’adorerai… -les options de la ligne de commandes sont purement et simplement pas documentés !!! heureusement j’ai regarder le code source ici: CommandLineInterface.java pour trouver des options sympatiques comme “-noclean” qui me permet de voir le code C généré :)

Bref, il est clair que OOC est encore jeune, très jeune même. Il n’y a qu’un seul développeur actif pour le moment, mais l’avenir de OOC me parait de bon augure !

Ressources: -Site officiel -Blog officiel

Editions 29 juin

Comme le stipule l’auteur, une manière plus jolie permet de coder mon exemple: ` //On crée une classe Person class Person {

    String first_name, name;
    Int age;

    func new(=first_name, =name, =age);

//cette fonction va manipuler un pointeur d'objet
func setName(=name);

func print {
        printf("Person name is: %s\n", p.name);
        printf("Person first name is: %s\n", p.first_name);
        printf("Person age is: %d\n", p.age);
}

}

//on va utiliser notre classe: func main {

    Person p = new Person("Foo", "Bar", 28);

    //affichons voir quelques informations:
p.print();

    //ici on change l'objet
p.setName("Baz");

    //Et on vérifie:
p.print();

} `

Ici, l’auteur nous présente en fait la manière d’initialiser directement des valeurs lors de la construction ou de l’appel à setName.

Par contre, mon exemple qui permet de voir la modification par référence disparait :)

Je vous invite à lire le code ci dessus et d’apprécier à quel point la sémantique est instinctive.

comments powered by Disqus