<?php
class VerifierFormulaire
{
    // Propriétés
    private $donnees;
    private $erreurs;
    private $ListeErreurs;
    private $separateur;
    // Constructeur
    public function __construct( $donnees, $separateur = ',' )
    {
        $this->donnees    = $donnees;
        $this->erreurs    = array();
        $this->separateur = $separateur;
    }
    
    // Méthodes
    private function Recup_champs($champs)
    {
        $tableau = explode($this->separateur, $champs);
        return $tableau;
    }   
    
    
    public function TesterChampsVides($Champs)
    {
        $Champs = $this->Recup_champs($Champs);
        //... 

class VerifierFormulaire
{
// Propriétés
    private $donnees;
    private $erreurs;
    private $ListeErreurs;
	private $separateur = ',';
// Constructeur
    public function __construct( $donnees, $separateur = null )
    {
        $this -> donnees = $donnees;
        $this -> erreurs = array();
		if (isset($separateur)) $this->separateur = $separateur;
        //$this -> ListeErreurs = NULL;
    }
	
// Méthodes
	private function Recup_champs($champs)
	{
	$tableau = explode($this->separateur, $champs);
	return $tableau;
	}   
	
	
    public function TesterChampsVides($Champs)
    {
        $Champs = $this->Recup_champs($Champs);

  //...

Par exemple dans tes méthodes de test tu fais systématiquement

$Champs = explode( ',', $Champs );

Tu pourrais faire une fonction pour réaliser cette ligne, fonction qui serait appelée par chacune de tes méthodes de test. Ainsi il te suffirait de changer uniquement cette fonction si pour une raison quelconque tu devais changer de séparateur. Mais tu pourrais aussi aller plus loin, déclarer une variable pour le séparateur qui par défaut pourrait-être égal = ',' et à l'instanciation de ta classe ou dans l'appel de tes fonctions, passer en argument le nouveau séparateur s'il est différent de celui par défaut. Cela rendrait ton objet adaptable à plus de situations. Bon, ce n'est pas nécessairement utile, mais juste un exemple au passage.

[Note : ce message a été posté de manière anonyme avant d'être réattribué à son auteur]

$Champs = explode( ',', $Champs );

Pour les variables dans les méthodes, ton raisonnement est tout à fait valable.

Et si ça fonctionne à ta satisfaction, alors c'est très bien. Avec le temps, tu amélioreras petit à petit certains détails. Comme par exemple faire des boucles foreach non pas sur les données mais sur le tableau issu du paramètre. Et au fond pourquoi ne pas envoyer directement un paramètre... etc, etc... Tout te montrer maintenant ne serait pas très utile à mon sens. Tes propres raisonnement t'amèneront à optimiser progressivement.

<?php
/*
A rajouter : Test valeur numérique et test valeurs identiques ( pours champs mot de passe )
*/
class VerifierFormulaire
{
// Propriétés
	private $donnees;
	private $erreurs;
	private $ListeErreurs;
// Constructeur
	public function __construct( $donnees )
    {
		$this -> donnees = $donnees;
		$this -> erreurs = array();
		//$this -> ListeErreurs = NULL;
    }
// Méthodes   
    public function TesterChampsVides( $Champs )
    {
		$Champs = explode( ',', $Champs );
		foreach( $this -> donnees as $cle => $valeur )
		{
			if ( ( in_array( $cle, $Champs ) ) && ( $valeur == NULL ) )
			{
				$this -> erreurs[] = 'Le champ '.$cle.' est obligatoire';
			}
		}
    }
	public function TesterChampsEmail( $Champs )
    {
		$Champs = explode( ',', $Champs );
		foreach( $this -> donnees as $cle => $valeur )
		{
			if ( ( in_array( $cle, $Champs ) ) && ( !ereg( '.+(@.+)(\.[[:alpha:]]{2}([[:alpha:]]?))$', $valeur ) ) )
			{
				$this -> erreurs[] = 'Le champ '.$cle.' doit contenir une adresse email valide';
			}
		}
    }
	public function TesterChampsIdentiques( $Champs )
    {
		$Champs = explode( ',', $Champs );
		$i = 1;
		$x = NULL;
		$y = NULL;
		foreach( $this -> donnees as $cle => $valeur )
		{
			if ( in_array( $cle, $Champs ) )
			{
				if ( $i == 1 )
				{
					$x = $valeur;
					$xNom = $cle;
					$i++;
				}
				else
				{
					$y = $valeur;
					$yNom = $cle;
				}
			}
		}
		if ( $x != $y )
		{
			$this -> erreurs[] = 'Les champs '.$xNom.' et  '.$yNom.' doivent être identiques';
		}
    }
	public function AfficherErreurs()
	{
		$this -> ListeErreurs .= '<ul>';
		foreach( $this -> erreurs as $valeur )
		{
			$this -> ListeErreurs .= '<li>'.$valeur.'</li>';
		}
		$this -> ListeErreurs .= '</ul>';
		return $this -> ListeErreurs;
	}
}
?>

<?php
########## Vérification du formulaire

/*
##### Paramètres
- TestChampsVides : Retournera une erreur si les valeurs sont vides
- TestChampsEmail : Retournera une erreur si les valeurs ne sont pas du type [email protected]
*/
$TestChampsVides = 'Nom,Email'; // Entrez le nom des champs à vérifier ( Entre les '' et séparés par des virgules )
$TestChampsEmail = 'Email'; // Entrez le nom des champs à vérifier ( Entre les '' et séparés par des virgules )
$TestChampsIdentiques = 'Password,Confirmation'; // Entrez le nom des champs à vérifier ( Entre les '' et séparés par des virgules )
/*
##### Vérification
*/
if ( isset( $_POST ) )
{
	$VerifForm = new VerifierFormulaire( $_POST );
	$VerifForm -> TesterChampsVides( $TestChampsVides );
	$VerifForm -> TesterChampsEmail( $TestChampsEmail );
	$VerifForm -> TesterChampsIdentiques( $TestChampsIdentiques );
	$ListeErreurs = $VerifForm -> AfficherErreurs();
	echo $ListeErreurs;
}
?>

<form method="post" action="#">
<p><label>Nom</label><input type="text" name="Nom" /></p>
<p><label>Email</label><input type="text" name="Email" /></p>
<p><label>Password</label><input type="password" name="Password" /></p>
<p><label>Confirmation</label><input type="password" name="Confirmation" /></p>
<input type="submit" />
</form>

$VerifForm = new VerifierFormulaire( $_POST );

public function __construct( $donnees )

// ... Debut
public function __construct( $donnees )
    {
		$this -> donnees = $donnees;
		$this -> NbChampsVides = 0;
		$this -> erreurs = NULL;
    }

// ... suite

$VerifForm = new VerifierFormulaire( $_POST );

Ah j'ai compris, rien ne sert d'envoyer le paramètre donc.
Désolé j'ai mis du temps à capter

public function __construct( $donnees )

$this -> donnees = $_POST; 

$this -> donnees = $donnees; 

<?php
class VerifFormulaire
{
	private $NbChampsVides;
	private $cle;
	private $valeur;
	private $ErreursForm;

	public function __construct()
    {
		$this -> NbChampsVides = 0;
    }
    
    public function ChampVides( $test )
    {
		foreach( $test as $cle => $valeur )
		{
			if ( $valeur == NULL )
			{
				$this -> NbChampsVides++;
			}
		}
    }
	public function AfficherErreurs()
	{
		if ( $this -> NbChampsVides != 0 )
		{
			$this -> ErreursForm .= $this -> NbChampsVides.' champ(s) vide(s)';
		}
		return $this -> ErreursForm;
	}
}
?>

<?php
if ( isset( $_POST['Champ1'] ) )
{
	$VerifForm = new VerifFormulaire();
	$VerifForm -> ChampVides( array( $_POST['Champ1'] ) );
	$ErreursForm = $VerifForm -> AfficherErreurs();
	echo $ErreursForm;
}
?>

<?php
//... 
    public function __construct( $donnees )
    {
        $this -> donnees = $_POST;
        $this -> NbChampsVides = 0;
        $this -> cle = NULL;
        $this -> valeur = NULL;
        $this -> ErreursForm = NULL;
    }
//...