// Méthode permettant de retourner le poids atomique
		// d'un composé chimique.
		public double CalculerPoids()
		{
			// Pile servant à faire le calcul.
			Stack unePile = new Stack();
			
			// Variables de manipulations pour faciliter la 
			// compréhension.
			string unJeton;
			double nombre=0;
			double nombreDépiler=0;
			double résultat=0;
			
			// Permet de parcourir chacun des jetons d'un composé
			// chimique et pour effectuer le calcul.
			foreach (string jeton in this)
			{
				// On vérifie si le jeton est une lettre (abréviation).
				// On conserve l'élément et on ajoute le poids dans 
				// la pile.
				if(Char.IsLetter(jeton,0))
				{
					if(tabPériode[jeton] != null)
					{
						élément = tabPériode[jeton];
						unePile.Push(élément.PoidsAtomique);
					}
					else
					{
						throw new NullReferenceException("Erreur: Élément " +
														 "chimique inexistant");
					}
				}

				// On vérifie si le jeton est une parenthèse fermante.
				// On empile la parenthèse.
				if(jeton[0] == '(')
				{
					unJeton = jeton[0].ToString();
					unePile.Push(unJeton);
				}
				
				// On vérifie si le jeton est un nombre. On dépile un
				// nombre que l'on place dans une variable. On envoie
				// le jeton actuel dans une autre variable et on multiplie
				// les deux variables entre elles. Ensuite, on empile le
				// résultat.
				if(Char.IsNumber(jeton,0))
				{
					nombreDépiler = (double)unePile.Pop();
					nombre = Double.Parse(jeton);
					résultat = nombre * nombreDépiler;
					unePile.Push(résultat);
				}
				
				// On vérifie si le jeton est une parenthèse fermante.
				// On dépile tant que l'on ne dépile pas une parenthèse
				// ouvrante. Ensuite, on fait la somme des éléments dépilés
				// et on empile le résultat de cette somme.
				if(jeton[0] == ')')
				{
					while (jeton[0] != '(')
					{
						unJeton= unePile.Pop().ToString();
						nombreDépiler = Double.Parse(unJeton);
						unJeton = jeton[0].ToString();
						nombre = Double.Parse(unJeton);
						résultat = nombre + nombreDépiler;
					}
					unePile.Push(résultat);
				}
			}
			
			// On fait la somme des éléments restant dans la pile tant que cela
			// est nécessaire. On obtient ainsi le résultat soit le poids
			// atomique du composé chimique.
			while(unePile.Count > 0)
			{
				résultat += (Double)unePile.Pop();
			}
			return résultat;
		}