CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2010 03 12 22:23:13

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Astuces

> CONSTRUCTEURS ET OPERATEUR + HERITAGE SIMPLE

CONSTRUCTEURS ET OPERATEUR + HERITAGE SIMPLE

Information sur la source

Note :
Aucune note

Catégorie :Astuces Classé sous :constructeur, héritage, opérateur Niveau :Initié Date de création :26/05/2006 Vu :4 470

Auteur : UKR6900

Ecrire un message privé

Commentaire sur cette source (1)

Ajouter un commentaire et/ou une note

Description

Exemple de programmation avec des constructeurs,destructeur
Utilisation de quelques type opérateurs + exemple d'heritage simple
avec une classe coloré pour les opérateurs et constructeurs.
deux classe développé : Parent : Cl_point et Fille : Cl_PointColore
+ Programme test (compilé avec Borland C++ 5.5

Source

#include "Mylib.h"
//--------------------------------------------------------
// DEBUT CLASSE Cl_Point
//--------------------------------------------------------
class Cl_Point{
//accessible par les membres de la classe uniquement
private:
static int NbrPoints;
//accessible par les membres de la classe et par les classes dérivées
protected:
char nom;
int x;
int y;
//accessible par tout le monde (membres de la classe,
//classes dérivées et clients de la classe)
public:
Cl_Point();
Cl_Point(const char,const int,const int);
Cl_Point(const Cl_Point &);
~Cl_Point();
void affiche(void)const;
void nbrPoints(void)const;
friend ostream & operator << (ostream &,const Cl_Point &);
Cl_Point & operator + (const Cl_Point &);
Cl_Point & operator - (const Cl_Point &);
Cl_Point & operator = (const Cl_Point &);
Cl_Point & operator = (const Cl_Point *);
Cl_Point & operator += (const Cl_Point &);
Cl_Point & operator -= (const Cl_Point &);
Cl_Point & operator ++ (int);
Cl_Point & operator -- (int);
Cl_Point & operator ()(const int, const int);
};//end class
//--------------------------------------------------------
// FIN ClASSE Cl_Point
//--------------------------------------------------------
int Cl_Point::NbrPoints = 0;
//------------------------------------------------------------------------------
// FONCTION : Constructeur
// DESCRIPTION : Constructeur par défaut
//-------------------------------------------------------------------------------
Cl_Point::Cl_Point(){
nom = 'A';
x = 0;
y = 0;
NbrPoints++;
printf("constructeur %c (par défaut) |Cl_Point| : %p\n",nom, this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : Constructeur
// DESCRIPTION : Constructeur par initilisation
//-------------------------------------------------------------------------------
Cl_Point::Cl_Point(const char _nom,const int _x,const int _y){
nom = _nom;
x = _x;
y = _y;
NbrPoints++;
printf("constructeur %c (par initilisation) |Cl_Point| : %p\n",nom,this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : Constructeur
// DESCRIPTION : Constructeur par recopie
//-------------------------------------------------------------------------------
Cl_Point::Cl_Point(const Cl_Point & _a){
nom = _a.nom;
x = _a.x;
y = _a.y;
NbrPoints++;
printf("constructeur %c (par recopie) |Cl_Point| : %p\n",nom,this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : Destructeur
// DESCRIPTION : Destructeur
//-------------------------------------------------------------------------------
Cl_Point::~Cl_Point(){
NbrPoints--;
printf("Destructeur %c |Cl_Point| : %p\n",nom,this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : affiche
// DESCRIPTION : Affichage des coordonnées du point à l'écran
//-------------------------------------------------------------------------------
void Cl_Point::affiche(void)const{
printf("%c=[%d,%d]\n",nom,x,y);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : nbrPoints
// DESCRIPTION : Affichage le nombre de points créé
//-------------------------------------------------------------------------------
void Cl_Point::nbrPoints(void)const{
cout << "Nombre de Point(s) créé(s) = " << NbrPoints << endl;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator <<
// DESCRIPTION : << Cl_Point
//-------------------------------------------------------------------------------
ostream & operator << (ostream & sortie,const Cl_Point & _P1){
sortie << _P1.nom << "=[" << _P1.x << "," << _P1.y << "]";
return sortie;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator =
// DESCRIPTION : Cl_Point = Cl_Point = Cl_Point...
//------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator = (const Cl_Point & _rPx){
Cl_Point tampon(_rPx);
nom = tampon.nom;
x = tampon.x;
y = tampon.y;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator +
// DESCRIPTION : Cl_Point + Cl_Point + Cl_Point...
//------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator + (const Cl_Point & _rPx){
Cl_Point tampon(_rPx);
x += tampon.x;
y += tampon.y;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator -
// DESCRIPTION : Cl_Point - Cl_Point - Cl_Point...
//------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator - (const Cl_Point & _rPx){
Cl_Point tampon(_rPx);
x -= tampon.x;
y -= tampon.y;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator =
// DESCRIPTION : Cl_Point = Cl_Point*
//------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator = (const Cl_Point * _Px){
*this=*_Px;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator +=
// DESCRIPTION : Cl_Point += Cl_Point
//-------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator += (const Cl_Point & _rPx){
*this = *this + _rPx;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator -=
// DESCRIPTION : Cl_Point -= Cl_Point
//-------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator -= (const Cl_Point & _rPx){
*this = *this - _rPx;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator ++
// DESCRIPTION : Cl_Point++
//-------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator ++(int){
x++;
y++;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator --
// DESCRIPTION : Cl_Point--
//-------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator --(int){
x--;
y--;
return *this;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator ()
// DESCRIPTION : Cl_Point()
//-------------------------------------------------------------------------------
Cl_Point & Cl_Point::operator ()(const int _x, const int _y){
x = _x;
y = _y;
return *this;
}//end procedure
//--------------------------------------------------------
// DEBUT CLASSE Cl_PointColore
//--------------------------------------------------------
class Cl_PointColore:public Cl_Point{
private:
char Color;
public:
Cl_PointColore();
Cl_PointColore(const char,const int,const int,const char);
Cl_PointColore(const Cl_PointColore &);
~Cl_PointColore();
void affiche_pointColore(void)const;
friend ostream & operator << (ostream &,const Cl_PointColore &);
};//end class
//--------------------------------------------------------
// FIN CLASSE Cl_PointColore
//--------------------------------------------------------
//------------------------------------------------------------------------------
// FONCTION : Constructeur
// DESCRIPTION : Constructeur par défaut
//-------------------------------------------------------------------------------
Cl_PointColore::Cl_PointColore():Cl_Point(){
Color = 'N';
printf("constructeur %c (par défaut) |Cl_PointColore|: %p\n",Cl_Point::nom, this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : Constructeur
// DESCRIPTION : Constructeur par initilisation
//-------------------------------------------------------------------------------
Cl_PointColore::Cl_PointColore(const char _nom,const int _x,const int _y, const char _Color='N'):Cl_Point(_nom,_x,_y){
Color = _Color;
printf("constructeur %c (par initialisation) |Cl_PointColore|: %p\n",Cl_Point::nom, this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : Constructeur
// DESCRIPTION : Constructeur de recopie
//-------------------------------------------------------------------------------
Cl_PointColore::Cl_PointColore(const Cl_PointColore & _S):Cl_Point(_S){
Color = _S.Color;
printf("constructeur %c (de recopie) |Cl_PointColore|: %p\n",Cl_Point::nom, this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : Destructeur
// DESCRIPTION : Destructeur
//-------------------------------------------------------------------------------
Cl_PointColore::~Cl_PointColore(){
printf("Destructeur %c |Cl_PointColore|: %p\n",Cl_Point::nom,this);
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : affiche_pointColore
// DESCRIPTION : Affichage des coordonnées et couleur
//-------------------------------------------------------------------------------
void Cl_PointColore::affiche_pointColore(void)const{
Cl_Point::affiche();
cout << "Couleur du point = " << Color ;
}//end procedure
//------------------------------------------------------------------------------
// FONCTION : operator <<
// DESCRIPTION : << Cl_Point
//-------------------------------------------------------------------------------
ostream & operator << (ostream & sortie,const Cl_PointColore & _P1){
_P1.affiche_pointColore();
return sortie;
}//end procedure
//------------------------------------------------------------------------------
// START PROGRAM TEST CLASS
//-------------------------------------------------------------------------------
typedef Cl_Point point;
typedef Cl_PointColore pointc;
void main(){
pointc a('A',5,5,'V');
pointc b('B',3,2);
a.nbrPoints();
cout << a << "\n" << b << "\n" ;
a + b;
cout << a << endl;
}
//------------------------------------------------------------------------------
// END PROGRAM TEST CLASS
//-------------------------------------------------------------------------------

#include "Mylib.h"

//--------------------------------------------------------
//                      DEBUT CLASSE Cl_Point
//--------------------------------------------------------
  class Cl_Point{
    //accessible par les membres de la classe uniquement 
    private:
      static int NbrPoints;
    //accessible par les membres de la classe et par les classes dérivées
    protected:
      char nom;
      int x;
      int y;
    //accessible par tout le monde (membres de la classe, 
    //classes dérivées et clients de la classe)
    public:
      Cl_Point();
      Cl_Point(const char,const int,const int);
      Cl_Point(const Cl_Point &);
      ~Cl_Point();
      void affiche(void)const;
      void nbrPoints(void)const;
      friend ostream & operator << (ostream &,const Cl_Point &);
      Cl_Point & operator + (const Cl_Point &);
      Cl_Point & operator - (const Cl_Point &);
      Cl_Point & operator = (const Cl_Point &);
      Cl_Point & operator = (const Cl_Point *);
      Cl_Point & operator += (const Cl_Point &);
      Cl_Point & operator -= (const Cl_Point &);
      Cl_Point & operator ++ (int);
      Cl_Point & operator -- (int);
      Cl_Point & operator ()(const int, const int);
  };//end class
//--------------------------------------------------------
//                      FIN ClASSE Cl_Point
//--------------------------------------------------------
  int Cl_Point::NbrPoints = 0;
//------------------------------------------------------------------------------
// FONCTION      : Constructeur
// DESCRIPTION   : Constructeur par défaut
//-------------------------------------------------------------------------------
  Cl_Point::Cl_Point(){
    nom = 'A';
    x = 0;
    y = 0;
    NbrPoints++;
    printf("constructeur %c (par défaut)         |Cl_Point|      : %p\n",nom, this);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : Constructeur
// DESCRIPTION   : Constructeur par initilisation
//-------------------------------------------------------------------------------
  Cl_Point::Cl_Point(const char _nom,const int _x,const int _y){
    nom = _nom;
    x = _x;
    y = _y;
    NbrPoints++;
    printf("constructeur %c (par initilisation)  |Cl_Point|      : %p\n",nom,this);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : Constructeur
// DESCRIPTION   : Constructeur par recopie
//-------------------------------------------------------------------------------
  Cl_Point::Cl_Point(const Cl_Point & _a){
    nom = _a.nom;
    x = _a.x;
    y = _a.y;
    NbrPoints++;
    printf("constructeur %c (par recopie)        |Cl_Point|      : %p\n",nom,this);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : Destructeur
// DESCRIPTION   : Destructeur
//-------------------------------------------------------------------------------
  Cl_Point::~Cl_Point(){
    NbrPoints--;
    printf("Destructeur %c                       |Cl_Point|      : %p\n",nom,this);
  }//end procedure
//------------------------------------------------------------------------------
// FONCTION      : affiche
// DESCRIPTION   : Affichage des coordonnées du point à l'écran
//-------------------------------------------------------------------------------
  void Cl_Point::affiche(void)const{
    printf("%c=[%d,%d]\n",nom,x,y);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : nbrPoints
// DESCRIPTION   : Affichage le nombre de points créé
//-------------------------------------------------------------------------------
  void Cl_Point::nbrPoints(void)const{
    cout << "Nombre de Point(s) créé(s) = " << NbrPoints << endl;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator <<
// DESCRIPTION   : << Cl_Point
//-------------------------------------------------------------------------------
  ostream & operator << (ostream & sortie,const Cl_Point & _P1){
    sortie << _P1.nom << "=[" << _P1.x << "," << _P1.y << "]";
    return sortie;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator =
// DESCRIPTION   : Cl_Point = Cl_Point = Cl_Point...
//------------------------------------------------------------------------------
   Cl_Point & Cl_Point::operator = (const Cl_Point & _rPx){
       Cl_Point tampon(_rPx);
       nom = tampon.nom;
       x = tampon.x;
       y = tampon.y;
       return *this; 
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator +
// DESCRIPTION   : Cl_Point + Cl_Point + Cl_Point...
//------------------------------------------------------------------------------
   Cl_Point & Cl_Point::operator + (const Cl_Point & _rPx){
       Cl_Point tampon(_rPx);
       x += tampon.x;
       y += tampon.y;
       return *this; 
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator -
// DESCRIPTION   : Cl_Point - Cl_Point - Cl_Point...
//------------------------------------------------------------------------------
   Cl_Point & Cl_Point::operator - (const Cl_Point & _rPx){
       Cl_Point tampon(_rPx);
       x -= tampon.x;
       y -= tampon.y;
       return *this; 
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator =
// DESCRIPTION   : Cl_Point = Cl_Point*
//------------------------------------------------------------------------------
   Cl_Point & Cl_Point::operator = (const Cl_Point * _Px){
       *this=*_Px;
       return *this; 
  }//end procedure


//------------------------------------------------------------------------------
// FONCTION      : operator +=
// DESCRIPTION   : Cl_Point += Cl_Point
//-------------------------------------------------------------------------------
  Cl_Point &  Cl_Point::operator += (const Cl_Point & _rPx){
    *this = *this + _rPx;
    return *this;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator -=
// DESCRIPTION   : Cl_Point -= Cl_Point
//-------------------------------------------------------------------------------
  Cl_Point &  Cl_Point::operator -= (const Cl_Point & _rPx){
    *this = *this - _rPx;
    return *this;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator ++
// DESCRIPTION   : Cl_Point++
//-------------------------------------------------------------------------------
  Cl_Point & Cl_Point::operator ++(int){
    x++;
    y++;
    return *this;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator --
// DESCRIPTION   : Cl_Point--
//-------------------------------------------------------------------------------
  Cl_Point & Cl_Point::operator --(int){
    x--;
    y--;
    return *this;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator ()
// DESCRIPTION   : Cl_Point()
//-------------------------------------------------------------------------------
   Cl_Point & Cl_Point::operator ()(const int _x, const int _y){
    x = _x;
    y = _y;
    return *this;
   }//end procedure



//--------------------------------------------------------
//                      DEBUT CLASSE Cl_PointColore
//--------------------------------------------------------
  class Cl_PointColore:public Cl_Point{
    private:
      char Color;     
    public:
      Cl_PointColore();
      Cl_PointColore(const char,const int,const int,const char);
      Cl_PointColore(const Cl_PointColore &);
     ~Cl_PointColore();
      void affiche_pointColore(void)const;
      friend ostream & operator << (ostream &,const Cl_PointColore &);
  };//end class
//--------------------------------------------------------
//                      FIN CLASSE Cl_PointColore
//--------------------------------------------------------
//------------------------------------------------------------------------------
// FONCTION      : Constructeur
// DESCRIPTION   : Constructeur par défaut
//-------------------------------------------------------------------------------
  Cl_PointColore::Cl_PointColore():Cl_Point(){
    Color = 'N';
    printf("constructeur %c (par défaut)         |Cl_PointColore|: %p\n",Cl_Point::nom, this);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : Constructeur 
// DESCRIPTION   : Constructeur par initilisation
//-------------------------------------------------------------------------------
  Cl_PointColore::Cl_PointColore(const char _nom,const int _x,const int _y, const char _Color='N'):Cl_Point(_nom,_x,_y){
    Color = _Color;
    printf("constructeur %c (par initialisation) |Cl_PointColore|: %p\n",Cl_Point::nom, this);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : Constructeur 
// DESCRIPTION   : Constructeur de recopie
//-------------------------------------------------------------------------------
  Cl_PointColore::Cl_PointColore(const Cl_PointColore & _S):Cl_Point(_S){
    Color = _S.Color;
    printf("constructeur %c (de recopie)         |Cl_PointColore|: %p\n",Cl_Point::nom, this);
  }//end procedure
//------------------------------------------------------------------------------
// FONCTION      : Destructeur
// DESCRIPTION   : Destructeur
//-------------------------------------------------------------------------------
  Cl_PointColore::~Cl_PointColore(){
    printf("Destructeur %c                       |Cl_PointColore|: %p\n",Cl_Point::nom,this);
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : affiche_pointColore
// DESCRIPTION   : Affichage des coordonnées et couleur
//-------------------------------------------------------------------------------
  void Cl_PointColore::affiche_pointColore(void)const{
    Cl_Point::affiche();
    cout << "Couleur du point = " << Color ;
  }//end procedure

//------------------------------------------------------------------------------
// FONCTION      : operator <<
// DESCRIPTION   : << Cl_Point
//-------------------------------------------------------------------------------
  ostream & operator << (ostream & sortie,const Cl_PointColore & _P1){
    _P1.affiche_pointColore();
    return sortie;
  }//end procedure

//------------------------------------------------------------------------------
//                      START PROGRAM TEST CLASS
//-------------------------------------------------------------------------------
  typedef Cl_Point point;
  typedef Cl_PointColore pointc;

  void main(){
    pointc a('A',5,5,'V');
    pointc b('B',3,2);

    a.nbrPoints();
    cout << a << "\n" << b << "\n" ;
    a + b;
    cout << a << endl;
  }
//------------------------------------------------------------------------------
//                      END PROGRAM TEST CLASS
//-------------------------------------------------------------------------------

Conclusion

Ceci n'est qu'un exemple de référence

Sources du même auteur

RÉCUPÉRATION DES DATES D'UN FICHIER EN CLAIR

GESTION DES SERVICES WINDOWS PAR LES API DANS UNE CLASSE

GESTION BASE DE REGISTRE (LOCAL OU DISTANTE)AVEC DES FONCTIO...

CRÉATION D'UNE CLASSE CL_STRING (GESTION DES CHAÎNES)

GESTION D'UN ARBRE BINAIRE PAR LES CLASSES

Toutes les sources de UKR6900

Sources de la même categorie

[C++] CLASS REGISTER par Miwik

SMART POINTEUR À COMPTEUR DE RÉFÉRENCE par nirgal76

POINTEUR INTELLIGENT par snpier wolf

ALIGNER TEXTE CONSOLE par CptPingu

QWERTY - AZERTY AVEC SDL, UNE ALTERNATIVE par Scheb

Toutes les sources de la catégorie Astuces

Sources en rapport avec celle ci

[SDL/C++] JEU SIMPLE POUR COMMENCER DANS LA PROGRAMMATION DE... par marmous

HÉRITAGE, COMPOSITION ET POLYMORPHISME par anadeveloppeur

BATAILLE NAVALE CONTRE IA (C++) par cali70

PARCOURS D'UN ARBRE par krissssss

UTILITÉ DU DESTRUCTEUR VIRTUEL par guilhemmartincpp

Commentaires et avis

Commentaire de laurent1024 le 28/05/2006 16:45:19

Tu devrais éviter de mélanger les printf et les cout, tu en choisit un (de preférence cout puisque tu fait du c++).
++

Ajouter un commentaire

Discussions en rapport avec ce code source dans le forum

Constructeur par recopie et Héritage [ par heleos ] Bonjour, J'ai un légé soucis avec un programme c++ Je n'arrive pas à faire un constructeur par recopie d'une sous classe. J'ai test&# Besoin d'un peu d'aide sur l'héritage et les constructeurs [ par neodelphi ] Bonjour tout le monde, j'ai deux petites question à propose du langage c++ sur l'héritage et les constructeurs:Tout d'abord, je voudrai savo question de "cours" : constructeurs de classe dérivée et classe de base [ par mhassine ]    Bonjour,j'ai une classe personne et une classe etudiant dérivée de personne.J'ai le constructeur Personne(string n)J'ai au Help!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! [ par Miss1 ] pb avec constructeur par recopie. il faut que je crée une classe tableau dans lequels je dois mettre un constructeur prenant en compte un paramétre ta voici mon code [ par Miss1 ] voici mon code mais je n'arrive pas a compiler class tableau { private: int taille; // variables// int *pointeur erreur dans la classe [ par Miss1 ] je n'arrive pas a compiler. le sujet est de crée une taille, un pointeur sur le 1er element du tableau, un constructeur, un constructeur par recopie , opérateur [ par mmuller57 ] Dans la source de factorielle, y'a ça :i*=j, je comprend pas a quoi sert le i* ? Qqun peut m'aider?Merci @+ Donner des valeurs au éléments d'un tableaux dans le constructeur d'une classe [ par ProGamer ] Dans la définition de ma classe, j'ai un tableau d'entiers. Dans le constructeur de la classe, j'ai besoin de donner des valeurs aux éléments du table copie contructeur [ par MrKribou ] Je voudrai avoir des sujet a propos des copie constructeur. J'avais faire un prog qui plantait pour une raison assez obscure et en tatonnant une bonne Constructeur sur un tableau de classes [ par Supo ] Lorsque je crée un tableau de classe, disons avecnomdelaclasse instance[10];et que j'ai un constructeur pour cette classe, comment je fait pour donner

Nos sponsors

Derniers Blogs

PB LORS DE L'INSTALLATION SHAREPOINT 2010. par Patrick Guimonet

[WF4] AJOUTER DES CONTRAINTES à UNE ACTIVITé (2/2) par JeremyJeanson

[WF4] AJOUTER DES CONTRAINTES à UNE ACTIVITé (1/2) par JeremyJeanson

[ASP.NET] NE PAS SE FAIRE AVOIR PAR IHTTPMODULE ET SA MéTHODE INIT() par tja

[MSTD10] SHAREPOINT 2010 ET TEAM FOUNDATION SERVER par phil

Forum

RE : FLEX /LEX BISON/YACC par alxidali

RE : FILTRAGE ANISOTROPIQUE POUR UNE IMAGE D'EMPREINTE DIGITALE par raboa

RE : GESTION DE STOCK D'UN MAGASIN par afaf1988

RE : FILTRAGE ANISOTROPIQUE POUR UNE IMAGE D'EMPREINTE DIGITALE par Pistol_Pete

RE : FILTRAGE ANISOTROPIQUE POUR UNE IMAGE D'EMPREINTE DIGITALE par raboa

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Site internet php
Budget : 350€
site formation reiki distance
Budget : 900€
Banniere Flash Drupal
Budget : 150€

Logiciels

Xilisoft Convertisseur Vidéo Ultimate (5.1.39.0305)
XILISOFT CONVERTISSEUR VIDéO ULTIMATE (5.1.39.0305)

Xilisoft Convertisseur Vidéo Ultimate est un outil puissant de conversion vidéo, facile à utilise...

Cliquez pour télécharger Xilisoft Convertisseur Vidéo Ultimate
Xilisoft DVD Ripper Ultimate (5.0.64.0304)
XILISOFT DVD RIPPER ULTIMATE (5.0.64.0304)

Xilisoft DVD Ripper Ultimate est un logiciel excellent pour copier et convertir DVD vers presque ...

Cliquez pour télécharger Xilisoft DVD Ripper Ultimate
Axalot, logiciel de sauvegarde de données en ligne (1.10.108.1)
AXALOT, LOGICIEL DE SAUVEGARDE DE DONNéES EN LIGNE (1.10.108.1)

Perdre tout le contenu de votre disque dur, vous imaginez ? Vos photos, vos musiques, votre compt...

Cliquez pour télécharger Axalot, logiciel de sauvegarde de données en ligne
Rigs of Rods (63.3)
RIGS OF RODS (63.3)

c'est un jeu de multi-simulation camions,autobus voitures, avions, bateaux, hélicoptère avec défo...

Cliquez pour télécharger Rigs of Rods
Konvertor (4.00)
KONVERTOR (4.00)

Le logiciel est un gestionnaire multimedia affichant, jouant et convertissant plus de 2000 format...

Cliquez pour télécharger Konvertor