Archives par mot-clé : constructeur

Injection de dépendances en C++

Publié dans C / C++ | Laisser un commentaire

L’injection de dépendances, que l’on retrouve généralement sous le terme de dependency injection (DI pour les intimes) est un concept de programmation très simple.

Pistolet à injection

Pistolet à injection (de dépendances of course)

L’idée de base c’est de ne pas faire ça :

class Foo {
    private Bar bar;

    public Foo() {
        bar = new Bar();
    }
}

Mais ça :

class Foo {
    private IBar bar;

    public Foo(IBar bar) {
        this->bar = bar;
    }
}

Continuer la lecture

Problèmes de mémoire ?

Petit point sur C++ et la gestion mémoire

Publié dans C / C++ | Un commentaire

Différents types de données

En terme de mémoire, il existe différents types de donnée en C++.

  • Donnée statique : emplacement alloué une fois pour toute la durée du programme
  • Donnée automatique (pile) : emplacement alloué à l’entrée d’un bloc (exemple : une fonction, une boucle, …) et libéré à sa sortie
  • Donnée dynamique (tas) : emplacement alloué et libéré à la demande du programme, donc du développeur à l’aide des opérateurs new et delete Bref à l’aide de pointeurs.

On parle ainsi de trois classes d’allocation : statique, automatique, dynamique.
Dans cet article, nous allons étudier un peu plus en détails l’allocation / destruction de données dynamiques.
Continuer la lecture

Singleton(s) !

Publié dans PHP objet | Commentaires fermés sur Singleton(s) !

Voilà bien longtemps que je n’avais pas fait de billets sur le PHP Objet. A vrai dire, je suis en train d’apprendre la programmation orientée objet en cours (au travers du Java et du C++), donc ça fixe vraiment les idées et permet de comprendre pas mal de petites choses, notamment l’utilité de certaines notions, comme les singletons, qui me paraissait bien douteuse auparavant. Un singleton, c’est une classe que l’on ne peut instancier qu’une seule fois. Par exemple, en cours on a créé une classe liste dont hérite la classe liste vide, et la classe listeNonVide. Clairement, il n’existe qu’une et une seule liste vide (sinon, on ne s’en sort pas), donc cette classe ne peut être instanciée qu’une seule fois, donc c’est un singleton. Je n’ai pas encore trouvé d’exemples plus parlant, par contre sur Apprendre-PHP, l’exemple est celui d’une classe PresidentDeLaRepublique qui, en effet, ne peut être instanciée qu’une seule fois)

Comment faire ?

L’idée est la suivante : le constructeur de la classe est private, on ne peut donc instancier la classe en passant directement par lui. Par contre, une variable static possède un accessor (getMachin()) qui est public et qui appelle le constructeur si la classe n’est pas encore instanciée (variable static == null), ou retourne l’instance sinon. En somme, voilà ce que ça donne :
Continuer la lecture

Classes abstraites et finales

Publié dans PHP objet | 2 commentaires

Les notions de classes abstraites et classes finales permettent de sécuriser notre programmation PHP, dans le sens qu’elles permettent d’éviter qu’un programmeur, reprenant notre code, n’en contourne la logique et s’égare ainsi sur une fausse piste.
En effet :

  • Class abstraite : class qui ne peut être instanciée, il est donc OBLIGATOIRE de créer une class héritante de cette class pour s’en servir. Utile lorsque l’on créé une class générique qui ne servira qu’à créer des sous class et non à être instanciée. Une telle class ne contient donc pas de __construct() puisqu’elle n’est pas instanciée. Mot clef : abstract.
  • Class finale : class qui NE PEUT PLUS avoir de sous-class, c’est-à-dire de class héritante. Les méthodes de cette class ne pourront être surchargées (réécrites, redéfinies). Mot clef : final. De la même manière, on peut aussi déclarer des méthodes abstraites et finales.
  • Méthode abstraite : méthode qui doit OBLIGATOIREMENT être surchargée (réécrite, ou redéfinie). Une class contenant une méthode abstraite doit aussi être abstraite. Mot clef : abstract.
  • Méthode finale : méthode qui NE PEUT ÊTRE surchargée (réécrite, redéfinie). Une class finale s’applique sur toutes les méthodes ou attributs de la classe, alors qu’ici on ne touche qu’à une seule méthode. Mot clef : final. Pour bien comprendre ces 2 notions et en saisir mieux l’intérêt voici plusieurs exemples, un pour chaque cas.

Class et méthodes abstraites

 abstract class Site {
	protected $type;
	protected $name;
	public function getType()
	{
		return $this->type;
	}
	public function getName()
	{
		return $this->name;
	}
}
$monSite = new Site();
echo $monSite->getType(); // Erreur : on tente d'instancier une classe abstraite

Continuer la lecture

Quelques méthodes et constantes magiques ou prédéfinies

Publié dans PHP objet | Laisser un commentaire

Attributs ou méthodes qui n’existent pas ?

Avant de faire un petit récapitulatif magique ou déjà défini (mouahaha), voyons une petite notion importante du PHP objet : il est possible de modifier et de lire la valeur d’un attribut qui n’existe pas (ah horreur), par contre, on ne peut utiliser une méthode qui n’existe pas (ah bah ça tombe bien alors !). Je m’explique en codant :

class Chat { }
$unChat = new Chat();
$unChat->couleur = 'noir';
$unChat->etat = 'sorti ses griffes';
echo 'Mon chat '.$unChat->couleur.' a '.$unChat->etat.'.';

Eh oui, ce petit exemple affichera bien : « Mon chat noir a sorti ses griffes . ». C’est horrible, n’est-ce-pas ? Heureusement avec __set() et __get(), on va pouvoir empêcher ce types d’actions et en profiter pour vérifier le type des valeurs que l’on assigne à nos attributs.
Par contre :

class Chat { } 
$unChat = new Chat();
$unChat->etreGentils();

Nous renverra une jolie petite erreur ! (heu, oui, je n’aime pas tellement les chats. Enfin, cela dit, je n’ai rien contre eux non plus) Heureusement la méthode magique __call() va nous permettre de rattraper ce petit bémol. Mais tout cela est très bien expliqué sur Apprendre PHP, alors sans plus tarder voilà une liste des méthodes et des constantes magiques, ainsi que des fonctions prédéfinies avec à chaque fois une explique, ou des exemples tiré du manuel PHP, de tutoriels sur le Web ou de mes propres mot.
Continuer la lecture

Rendre __construct() comptatible PHP 4

Publié dans PHP objet | Laisser un commentaire

La méthode magique __construct() est apparue dans PHP5, par conséquent PHP4 (ou inférieur) ne la reconnait pas. Auparavant, au lieu d’utiliser __construct(), on utilisait une méthode qui portait le même nom que la classe elle-même. Donc pour avoir une compatibilité PHP4 et PHP5, on peut utiliser le code suivant :

<?php
class MaClass
{
  var $app;

  function MaClass($app)
  {
    $this->__construct($app);
  }

  function __construct($app)
  {
    $this->app = $app;
  }
}

Ainsi, si on est en PHP5, le __construct() est bien compris et utilisé. Si on est en PHP4 (ou inférieur), on utilise MaClass() qui utilise une nouvelle méthode que l’on définie : __construct().
Alors pourquoi ne pas laisser tomber __construct() et n’utiliser que MaClass()__construct() c’est l’avenir le présent. Un développeur de la boîte où j’ai effectué un stage m’a appris que si on est en PHP5, ce dernier va sauter sur le __construct() et lira ensuite plus tard le MaClass() (et donc le zappera), on gagne un peu de temps pour une exécution en PHP5. Par conséquent ce bout de code utilise les avantages du PHP5 et est compatible PHP4 (et inférieur) 😀

Apparation de la visibilité de méthodes prédéfinies en PHP 5

Publié dans PHP objet | Laisser un commentaire

La programmation orientée objet existe dans PHP depuis sa version 3, son implémentation a été amélioré dans la version 4, mais c’est seulement depuis la récente version 5 que l’on peut réellement parler de PHP objet. J’ai commencé à lire la partie objet du cours de PHP 5 de Developpez.com et c’est très intéressant. Il existe par exemple une méthode prédéfinie nommée __construct() qui sert de constructeur d’une classe. Cela permet de changer le nom d’une class sans changer le constructeur associé.

<?php
class Blog {
  var $nom;
  var $description;
  function __construct($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
}
$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
echo $blogDeBN->nom.'<br />';
echo $blogDeBN->description;

Il existe aussi des mots clés comme private, public, protected qui permettent de définir les droits d’accès à des attributs ou à des méthodes. On les utilise à la place du var ou devant le mot clé function.

  • private : l’attribut ou la méthode ainsi définie ne pourra être utilisée que dans la class parente.
  • protected : l’attribut ou la méthode ainsi définie ne pourra être utilisée que dans la class parente et ses dérivées.
  • public (valeur par défaut) : l’attribut ou la méthode ainsi définie ne pourra être utilisée par n’importe qui.

Pratique pour clarifier du code ! Un autre mot clé est static et il permet de rendre un attribut ou une méthode identique pour tous les objets d’une classe. En somme si je change la valeur d’un attribut ou d’une méthode static dans un objet, alors tous les autres objets de cette class auront la même valeur pour cet attribut ou cette méthode. Il y a aussi une histoire de parent, self, static à utiliser avec l’opérateur double points ::, mais je n’ai pas encore bien assimilé.

Constructeur et notion d’héritage

Publié dans PHP objet | Laisser un commentaire

Continuons avec les bases en nous intéressant au constructeur et à la notion d’héritage.

Constructeur

Dans mon dernier billet, je me suis amusé à remplir mes attributs à la main, pourtant, en utilisant un constructeur, tout serait bien plus simple. Un constructeur est une méthode qui a le même nom que la class. Elle prend en paramètre les attributs que l’on souhaite remplir.

<?php
class Blog {
  var $nom;
  var $description;
  var $url = 'http://url.fr';
  function Blog($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
// On peut afficher les attributs
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Description du blog : '.$blogDeBN->description.'<br />';
echo 'Url du blog : '.$blogDeBN->url.'<br />';
// On utilise les méthodes
$blogDeBN->ajouter_billet();
$blogDeBN->ajouter_categorie(); ?>

Attribut objet

En PHP objet, il est tout à fait possible de créer un attribut qui sera un objet (une instance d’une class), tout comme cet attribut aurait pu être un int, un string, … Il nous faudra donc utiliser deux sélecteurs flêches -> pour accéder aux attributs de cet objet.

<?php
class Categorie {
  var $nom;
  var $description;
  var $sousCat;
  function Categorie($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
}

class Blog {
  var $nom;
  var $description;
  var $categorie;
  var $url;
  function Blog($nom, $description, $categorie) {
    $this->nom = $nom;
    $this->description = $description;
    $this->categorie = $categorie;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

// --- Un attribut peut être un objet
$catCMS = new Categorie('CMS', 'Quelques lignes sur les CMS');
$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.', $catCMS, 'http://30minparjour.la-bnbox.fr');
// On peut afficher les attributs
echo 'Catégorie : '.$catCMS->nom.'<br />';
echo 'Description de la catégorie : '.$catCMS->description.'<br /><br />';
echo 'Nom du blog : '.$blogDeBN->nom.'<br />';
echo 'Description du blog : '.$blogDeBN->description.'<br />';
echo 'Catégorie du blog : '.$blogDeBN->categorie->nom.'<br />';
echo 'Description de la catégorie : '.$blogDeBN->categorie->description.'<br />';
echo 'Url du blog : '.$blogDeBN->url.'<br /><br />';
// --- Un attribut peut aussi être une instance de la même classe que son objet parent
$catDotclear = new Categorie('Dotclear', 'Parlons de Dotclear');
$catCMS->sousCat = $catDotclear;
// On affiche les attributs
echo 'Catégories du blog : '.$blogDeBN->categorie->nom.' / '.$blogDeBN->categorie->sousCat->nom.'<br />';
echo 'Description de la catégorie : '.$catCMS->sousCat->description.'<br />'; ?>

Notion d’héritage

On peut aussi construire des class qui hériteront des attributs et méthodes d’une autre classe. Prenons un exemple. Un blog photo est bien un blog, il a bien un nom, une description, un url, on peut ajouter un billet ou une catégorie. Mais il serait assez pratique de pouvoir préciser aussi le nombre de photos qu’il contient, ou alors une méthode pour ajouter une photo, … tout un tas de choses qu’un blog classique n’a pas besoin. Au lieu de réécrire deux class grandement similaire, on va dire que la class BlogPhoto va hériter de tous les attributs et méthodes de la class Blog grâce au mot clé extends.

<?php
class Blog {
  var $nom;
  var $description;
  var $url;
  function Blog($nom, $description) {
    $this->nom = $nom;
    $this->description = $description;
  }
  function ajouter_billet() {
     echo 'Ceci est mon premier billet pour blog '.$this->nom.'.<br />';
  }
  function ajouter_categorie() {
    echo 'Ceci est ma première catégorie pour blog '.$this->nom.'.<br />';
  }
}

class BlogPhoto extends Blog {
  var $nbDePhoto;
  function ajouter_photo() {
    echo 'J\'ajoute une magnifique photo...';
  }
}

$blogDeBN = new Blog('30 minutes par jour', '30 minutes par jour au coeur de l\'informatique.');
$blogPhoto = new BlogPhoto('Mes photos', '');
$blogPhoto->nbDePhoto = '10';
// On peut afficher les attributs
echo 'Nom du blog de BN : '.$blogDeBN->nom.'<br />';
echo 'Description du blog de BN : '.$blogDeBN->description.'<br />';
echo 'Nb de photos du blog de BN (erreur) : '.$blogDeBN->nbDePhoto.'<br />';
echo 'Nom du blog photo : '.$blogPhoto->nom.'<br />';
echo 'Description du blog Photo : '.$blogPhoto->description.'<br />';
echo 'Nb de photos du blog Photo : '.$blogPhoto->nbDePhoto.'<br />'; $blogPhoto->ajouter_photo(); 

Si je redéfinis un attribut ou une méthode dans ma class BlogPhoto, cet attribut ou cette méthode sera réécris et ce n’est plus celui de la class Blog qui sera utilisé. Bon, fini pour ajourd’hui. Le cours sur Developpez.com a l’air bien complet et plutôt bien expliqué. Par contre, j’ai cru comprendre que PHP 5 avait amené son lot de nouveautés et que du coup mes 2 derniers billets sont peut-être obsolètes. Il existe par exemple un mot clé __construct pour le constructeur. Bref, je vais lire ce cours et je pourrai en dire plus à ce moment là !