Salut,
Avant de voir les commentaires sur ton code proprement dit, quelques remarques "générales":
l'inclusion de cstdlib n'est pas nécessaire, car elle est avantageusement remplacée par celle de iostream.
Par contre, pour pouvoir utiliser numeric_limits, tu devrait inclure <limits> 
Ensuite, plutôt qu'une phrase comme "Entrez deux entiers pour l'impression du triangle de Pascal : ", tu devrais être plu précis dans ce que tu souhaites que l'utilisateur introduise, et donc peut être travailler en deux temps:
introduisez la valeur de départ pour votre triangle de pascal" (récupérer cette valeur et la valider)
introduiez le nombre de lignes souhaité" (récupérer cette valeur et la valider)
En outre, si tu tiens à séparer correctement ton code en fichiers d'en-tête et fichiers d'implémentation, sache que le fichier d'en-tête (*.h ou *.hpp) ne devrait contenir que les déclarations de fonction et les définitions de classes.
Ton fichier d'en-tête ressemblerait donc à
... tout simplement...
et tu aurais un fichier d'implémentation (triangleDePascal.cpp) qui contiendrait l'implémentation de la fonction sous la forme (non corrigée) de
1
2
3
4
5
6
7
8
9
10
11
12
| int comb(int n, int k)
{
if(n < 0|| k < 0 || n < k )
return 0;
int c = 1, m = n + 1;
// m = n + 1;
for( int i = 1; i <= k; i++,m--)
{
c *= m/i;
}
return c;
} |
Toute la question étant ici de savoir s'il est intéressant de travailler ainsi pour une seule fonction 
Enfin, tu devrais prendre l'habitude d'utiliser des termes "auto commentés" pour tes différents identifiants (noms de fonction, d'arguments, de variables, etc)...
Une fonction représentant une action, tu pourrais envisager de renommer avantageusement comb en... combiner et tes variables n et k en vue de leur donner des noms qui représentent clairement ce à quoi il servent (depart et nombre_ligne 
)
Ces détails pratiques ayant été abordés, ne crois tu pas que les deux boucles imbriquées font partie de la logique qui permet de créer le triange de pascal
Si oui, il semble logique de les sortir de la fonction main et de les factoriser dans une fonction qui serait - par exemple - nommée AfficherPascal.
Cela "simplifierait" ta fonction main en:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| int main(/* int argc, char* argv[] ceci n'est nécessaire que si tu veux
* pouvoir passer des arguments lors de l'appel de l'exécutable...
* ici, ce n'est pas vraiment utile ;)
*/ )
{
int depart;
int nbLignes;
cout<<"Introduisez la valeur de départ :";
cin >>depart;
cout<<"introduisez le nombre de ligne :";
cin >> nbLignes;
AfficherPascal(depart, nbLignes);
return 0;
} |
En effet, le nombre de valeurs affichées par le triangle de pascal dépendra directement de la position de la ligne du triangle que l'on affiche:
- 1 pour la première
- 2 pour la deuxième
- 3 pour la troisième
- 4 pour la quatrième
- ...
De plus, nous remarquons que les valeurs affichées pour une ligne donnée dépendent directement... des valeurs affichées pour la ligne précédente.
La première idée qui vient à l'esprit est donc... qu'il serait intéressant de garder ces valeurs "quelque part"...
De cette manière, tu pourrais envisager de créer ton triangle de pascal d'une seule traite (éventuellement de manière récursive) et de l'afficher une fois qu'il a été créé...
En t'y prenant bien, si tu décide de permettre à la personne de demander l'affichage de plusieurs triangles de pascal, tu pourrais même envisager de ne recréer le triangle que si l'utilisateur demande l'affichage d'un triangle plus grand ou dont la valeur de début diffère...
En effet, si l'utilisateur demande la première fois l'affichage d'un triangle commençant à 1 et comprenant 9 lignes, et la deuxième fois celui d'un triangle commençant à 1 mais de 6 lignes à peine, tout ce que tu as à faire, c'est de n'afficher que les 6 premières lignes du triangle déjà calculé la première fois ...
Évidemment, si l'utilisateur demande la deuxième fois l'affichage d'un triangle de 10 ou 11 lignes ou dont la valeur de départ est 5, il faudra le recalculer
Mais cela peut te permettre de gagner énormément de temps
Je vais te laisser "cogiter" un peu sur la manière d'arriver à ces résultats, mais je vais te mettre sur la voie pour t'aider dans ta conception
Un triangle est composé de lignes, il te faut donc une "collection" dynamique de lignes.
Chaque ligne est de son coté... une "collection" dynamique de valeurs entières.
L'idéal est d'utiliser les conteneurs de la STL, tels que vector ou list.
Tu pourrais donc déclarer une ligne du triangle de pascal sous la forme de
std::vector<int> lignePascal;
et ton triangle de pascal sous la forme de
std::vector<lignePascal> triangePascal;
(les deux se satisferaient très bien d'utiliser std::list )
L'idéal serait alors de partir sur une structure qui contienne le triangle de pascal et qui soit en mesure de te rappeler le nombre de lignes et la valeur de départ utilisée, voire sur une classe qui "encapsulerait" toutes ces informations et qui fournirait les comportements adéquats
Affichage du Triangle de Pascal
Répondre avec citation
A méditer: La solution la plus simple est toujours la moins compliquée
J'aborderai ce chapitre après les tableaux! J'étudie en fait dans un livre ("Serie Schaum"). Là j'en suis encore aux fonctions).
Partager