Une méthode est une fonction membre d'une classe, c'est à dire qu'elle est "contenue" dans cette classe :

class MaClasse
{
      private:
      void FonctionPrincipale();
};

Dans cet exemple, la fonction FonctionPrincipale est une méthode de la classe MaClasse. Une méthode est une fonction mais une fonction n'est pas une méthode. Lorsque vous implémentez une méthode, vous voyez clairement son appartenance à une classe car précédant le nom de la méthode se trouve le nom de la classe. L'implémentation de la fonction précédente serait comme ceci :

void MaClasse::FonctionPrincipale()
{
	// Traitements effectués par la fonction
}

Dans cet exemple, le code MaClasse:: précédant le nom de la méthode spécifie que cette méthode appartient à la classe MaClasse.

Une variable est encapsulée lorsqu'elle n'est accessible que par les méthodes (fonctions membres) d'une classe. Ainsi, lorsque vous déclarez une classe, pour bien faire et respecter les principes de la POO, les membres des fonctions ne devraient être accessibles que par des méthodes :

class MaClasse
{
      private:
      int Age;
      AnsiString Nom;

      public:
      int GetAge(){return Age;}
      void SetAge(int _Age){Age = _Age;}

      AnsiString GetNom(){return Nom;}
      void SetNom(AnsiString _Nom){Nom = _Nom;}
};

Dans cette classe, pour accéder aux membres à moins d'être dans une méthode, vous êtes obligés d'utiliser les méthodes GetAge, GetNom, SetAge, SetNom. Pour des classes plus compliquées, l'usage de telles méthodes permet l'actualisation de toute la classe. Dans notre exemple, la modification de l'âge avec la fonction SetAge pourrait recalculer différents paramètres dans la fonction SetAge (date de naissance,...) Avec C++Builder, les propriétés permettent de faire cela plus facilement. Pour plus d'informations, consultez l'aide.

Pour plus d'informations, consultez l'article "Signification des indirections en C++" par Gilles Louise.

Si vous écrivez une fonction qui compare une valeur avec différentes constantes, évitez de comparer directement avec des constantes littérales, mais utilisez des énumérations.

void GestionErreur(int error)
{
    switch(error)
    {
    case 0: cerr << "Erreur de syntaxe\n"; 
            break;
    case 1: cerr << "Erreur : tentative de division par zéro\n";
            break;
    case 2: cerr << "Erreur fatale. Le programme se termine.\n";
            exit(1);
            break;
    default:cerr << "Erreur inconnue."
            break;
    }
}

Dans cet exemple, la variable entière error est directement comparée à des constantes : 0, 1, 2... Définissez plutôt des constantes à l'aide d'une énumération, ce qui permet de bien visualiser à quoi correspondent ces constantes, et d'être sûr de ne pas intervertir :

enum Erreur {SYNTAX_ERROR, DIVISION_0_ERROR, FATAL_ERROR};

//...

void GestionErreur(Erreur error)
{
      switch(error)
      {
      case SYNTAX_ERROR:    cerr << "Erreur de syntaxe\n"; 
                            break;

      case DIVISION_0_ERROR:cerr << "Erreur : tentative de division par zéro\n";
                            break;

      case FATAL_ERROR:     cerr << "Erreur fatale. Le programme se termine.\n";
                            exit(1);
                            break;

      default:		    cerr << "Erreur inconnue."
                            break;
      }
}	  	

En voyant ce code, vous n'avez pas besoin de vous demander à quelle erreur correspond telle constante puisque vous n'avez pas à connaître la valeur des constantes (théoriquement, on a SYNTAX_ERROR = 0, DIVISION_0_ERROR = 1 et FATAL_ERROR = 2). Si vous souhaitiez définir les valeurs des constantes, initialisez-les dans l'énumération :

enum Erreur {SYNTAX_ERROR = 11 , 
             DIVISION_0_ERROR = 12, 
             FATAL_ERROR = 13};

La fonction de gestion des erreurs étant écrite, pour l'appeller, il suffit de passer l'une des constantes en argument :

//...
int a, b;
cout << "Entrez deux nombres :\n";
cin >> a >> b;

if (b)	// Le diviseur n'est pas nul
     cout << double(a)/double(b);
else    // Le diviseur est nul
     GestionErreur(DIVISION_0_ERROR);
//...