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

Cliquez ici pour mettre ce site au démarrage de votre navigateur

AccueilCodesTutorielsForumsEmploiLivresConnexion

begin process at 2008 10 08 07:15:19

HELLO WORLD! par hamid

MSBUILD EXTENSION PACK SUR CODEPLEX par Miiitch

TCB : TRAVAILLER EN éQUIPE SANS RéSEAU par themit

ACCèS ANONYME ET LES PAGES FORMS / VIEWLSTS.ASPX... par Nicolas

L'ATELIER 4 DU COACH C# EST DISPONIBLE par bfedo

COMPILATION IMPOSSIBLE SOUS VISUAL C++ 2008 EXPRESS par AMokers

RE : RETOURNER UN TABLEAU D'UNE FONCTION par gamemonde

RE : QUEL LANGAGE PERMETTRAIT MON APPLICATION par gamemonde

RE : [HELP] PROJET DE LICENCE - WIIMOTE par dimland

RE : CURSEUR INVISIBLE AVEC SETCURSOR(NULL) par racpp

+ de logiciels à télécharger

1 257 844 membres
58 nouveaux aujourd'hui
14 401 membres club

Trouver une ressource

Trouvez une ressource parmi 38 804 codes, 1 184 303 messages d'aide etc...

Recherche: dans [ Dernières recherches ]

Filtre:Tous les codes.NET uniquementExclure .NET

Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

CONSTRUCTEURS ET OPERATEUR + HERITAGE SIMPLE

Information sur la source

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

Auteur : UKR6900

Ecrire un message privé

Note :
Aucune note

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

PETIT CODE DE LEÇON D'ANGLAIS par randriano

TRONQUER LES ZERO INUTILES D'UN NOMBRE A L'AFFICHAGE par neocoder

UTILISATION DES TOUCHES TAB, ENTREE ET ECHAP DANS UNE FENÊTR... par racpp

CALCULER NOMBRE DE MERSENNE AVEC BIBLIOTHÈQUE DE GESTION DE ... par mehdi7604

RECHERCHER LE CHEMIN OPTIMALE DANS UN GRAPHE ( ALGORITHME DE... par mehdi7604

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