C++ - classe Polynome

Bonjour,
J'étudie toujours le C++ au travers d'un livre.
Aujourd'hui, je ne comprends pas une expression qui se trouve dans une classe. Celle-ci a pour but de modéliser l'affichage d'un polynôme. Le principe de fonctionnement de la classe est basé sur un tableau de 5 double dont la valeur de chaque élément constitue le coefficient d'un monôme et l'indice la puissance. Les variables constitutives sont représentées par un 'x'.
Je précise que je ne sais pas ce qu'est un polynôme mais que cette connaissance n'est pas indispensable à la compréhension de cette classe nommée polynôme bien sûr.

Pour l'instant le code n'est pas en adéquation avec le C++ moderne à des fins pédagogiques :
L'objectif est d'afficher le polynôme p(x) = 2x³ - x ² + 0.5x sous la forme +2x^3-x^2+0.5x.

  • Polynome.h :
#ifndef POLYNOME_H
#define POLYNOME_H
#include <iostream>
using namespace std;

class Polynome
{
    public:
        //Polynome();
        //virtual ~Polynome();
        double coeffs_[5];

        void imprimer(ostream& os);
    protected:

    private:
        bool imprimerMonome(ostream& os, double coeff, int deg);
};

#endif // POLYNOME_H

  • Polynome.cpp :
bool Polynome::imprimerMonome(ostream& os, double c, int deg)
{
    bool monomeNul = true;
    if (c != 0.0) // si c == 0, pas d'impression - monomeNul = true;
    {
     monomeNul = false;
     os <<  ((c < 0) ? '-' :'+'); //si 'c' est négatif on affiche '-' sinon '+'
     if (c < 0.0) c = -c ;  // si 'c' est négatif 'c' est égal '-c'
     if (c != 1.0 || deg == 0)  os << c;
     if(deg > 0)                os << 'x';
     if(deg > 1)                os << '^' << deg;
    }
    return monomeNul;
}
void Polynome::imprimer(ostream& os)
{
    bool polynomeNul = true;
    for (int i = 4; i >=0 ;--i)
    {
       polynomeNul =  imprimerMonome (os, coeffs_[i], i) && polynomeNul;
    }
    if(polynomeNul) os << "+0";
}

  • main.cpp :
include <Polynome.h>

using namespace std;

int main()
{
    Polynome p;

    p.coeffs_[4] = 0 ;
    p.coeffs_[3] = 2 ;
    p.coeffs_[2] = -1 ;
    p.coeffs_[1] = 0.5 ;
    p.coeffs_[0] = 0 ;

    p.imprimer(cout);
    cout << endl;

    p.coeffs_[4] = 0 ;
    p.coeffs_[3] = 0 ;
    p.coeffs_[2] = 0 ;
    p.coeffs_[1] = 0 ;
    p.coeffs_[0] = 0 ;

    p.imprimer(cout);
    cout << endl;

    return 0;

}

Je n'ai pas encore transformé ce code au format arduino pour aller plus vite dans ma compréhension, je la remets à plus tard lorsque la classe sera finalisée.

Mon incompréhension se situe uniquement au niveau de cette ligne de code dans le fichier CPP et la méthode void imprimer(ostream& os); :

polynomeNul = imprimerMonome (os, coeffs_[i], i) && polynomeNul;

Je comprends la méthode imprimerMonome (os, coeffs_[i], i) qu'elle invoque mais je ne comprends pas ce que veut dire && polynomeNul dans cette ligne de code ?

Merci par avance pour votre aide.
Bonne journée.

Tu vois que imprimerMonome renvoie un booléen : true s'il est nul, false sinon.
Dans ta boucle sur les degrés des monômes (les indices), cette ligne met à jour un booléen. A la fin de la boucle, si au moins un des monômes n'est pas nul, le booléen sera false.
Après la boucle, il y a

Ca affiche 0 si le booléen est true, c'est à dire si tous les monômes sont nuls.

Quand je dis 'imprimer', c'est plutôt une mise à jour de la variable os

Merci @lesept,

D'accord si tous les monômes sont nuls polynomeNul est vrai mais je ne comprends pas le lien de cause à effet entre ces expressions :

polynomeNul = true && true donne true
polynomeNul = false && true donne false

Ok à chaque incrémentation de la boucle :

for (int i = 4; i >=0 ;--i)
    {
       polynomeNul =  imprimerMonome (os, coeffs_[i], i) && polynomeNul;
    }

imprimerMonome () renvoie true ou false, du coup polynomeNul prend cette valeur mais polynomeNul n'est vrai que si tous les monômes sont nuls, c'est à dire si monomeNul est vrai 5 fois. Du coup je ne comprends pas ...

Je vais courir, j'aurai les idées plus claires après !

Merci.

Ok, j'ai compris :

A la fin de la boucle si tous les monomes sont nuls ça donne :
polynomeNul = true && true

oupsssssssssssssssssssssssssssssssssssssssssssssss

Merci

Edité 1 fois

J'ai mal formulé ma question en fait pourquoi ne pas formuler la valeur booléen comme ceci :

 polynomeNul =  imprimerMonome (os, coeffs_[i], i); //&& polynomeNul;

C'est plus cohérent non ?

Merci

Le principe de polynomeNul = newValue && polynomeNul dans une boucle est qu'il faut qu'a chaque passage toutes les valeurs newValue et polynomeNul sois vrai, pour que la variable au final soit aussi vrai.
Si tu utilisais un ou(||), un seul suffirais.

Si tu faisait polynomeNul = imprimerMonome (os, coeffs_[i], i), la valeur de ta variable serait égale au dernier passage dans ta boucle.

Merci @terwal, c'est parfaitement logique et bien expliqué.
En fait c'est tout simple mais bon.

Merci et bonne journée.

En fait, si on reprend les valeur du tableau coeffs_[5] sous sa première forme :

Voilà.

Bonne soirée et merci encore à @lesept et @terwal.

Pour aller plus loin sur cette partie, on peux regarder la définition Wikipédia des tables de vérité

Merci, c’était une évidence qui aurait du me sauter aux yeux. Parfois je devrais tout laisser tomber une journée puis recommencer mais c’est plus fort que moi ! Je suis animé par le besoin permanent de comprendre à tout prix.
Quand j’ai vu qu’il me faudrait utiliser un polynôme (totalement inconnu pour moi) pour créer une classe, j’ai perdu pied. La vision du symbole epsilon dans la fonction mathématique qui me servirait de base pour créer cette classe m’a déstabilisé au point de ne plus voir l’évidence ! Ajouté à cela le pointeur this, les méthodes statiques, constantes… et tout ça dans un condensé de quelques pages !
Voilà il ne faut jamais jeter l’éponge, il faut toujours aller au bout de ses rêves !
Sans aucunes connaissances si ce n’est celle du MSX dans les années 85 et du VBA (Visual basic application) je me suis lancé dans l’aventure du C et du C++ et j’irai jusqu’au bout de ce que mes petites capacités intellectuelles me permettront d’aller.

Bonne journée.

Il y a aussi le python et sa déclinaison pour microcontrôleurs micropython. L'ESP32 et l'ESP8266 sont programmables avec ce langage.

Tu as alors un avantage il ne faut aucune capacité intellectuelles particulière pour faire du C++, la seul chose nécessaire est de la volonté :slight_smile:
Le plus dure pour moi est d'arriver à prendre du recule, lorsque l'on est confronté à un problème que l'on ne comprend pas.

@lesept , @terwal,
Un de vous deux ou d'autres peuvent me dire quel est le cursus de plus bas niveau qui permet à un étudiant d'aujourd’hui d'obtenir le statut de programmeur ? J'imagine qu'il y a des spécialités réseau, internet ...
Lorsque j'étais étudiant ce type d'études n'existait pas faute d'ordinateurs ...

Pour moi aucun diplôme n'ai vraiment nécessaire, tu peux encore être autodidacte.
Mais le premier diplôme que je connais est DUT d'information, je ne sais pas si il y a des BTS ou Bac pro pour le développement de logiciel.

Tu as bien connu Mathusalem ?
Dans mon école d'ingénieurs en 1975, j'ai commencé à programmer ... il y avait même une option "informatique" en 3ème année.

1 Like

Merci @terwal.

Bonjour @biggil,
Je suis né en 1961 et durant tout mon cursus scolaire, je n'ai jamais vu ni entendu parler du moindre ordinateur tout en sachant que ce concept existait déjà mais qu'il était encore loin de se démocratiser.
Je n'ai pas fréquenté les écoles d'ingénieurs.
Je n'ai aucune idée des langages que l'on pouvait enseigner à cette époque en 3ème année, option informatique?

FORTRAN IV, COBOL, et le super langage qui devait tout remplacer (mais qui a fait tchiiii) le PL1 (programming language 1). Le tout sur cartes perforées.

Sauf mauvaise interprétation de ma part, ce langage connaissait déjà l'allocation dynamique de mémoire, les pointeurs, le multithread ... Peut-être un ancêtre du B , du C et du c++.
Le multitasking et non pas le multithread pardon.

Edit 1 fois.

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.