Bonjour!

Je débute en programmation c++ et je suis depuis un peu de temps le cours de Mathieu Nebra et Mathieu Schaller,ici sur OC.

J'ai lu dans certains messages postés ici que ce cours était ancien,et donc....OBSOLÈTE et FAUX! Et je voulais m'en assurer, histoire de changer de cours.... si cela s'avère vrai.

Voici par un exemple de programme c++ que j'ai réalisé (un petit exercice sur les classes et objets(ainsi que l'héritage)).Je voudrais bien savoir s'il y a des erreurs, des lignes de codes mal écrites, bref....TOUT CE QUI POURRAIT CLOCHER et que je pourrais améliorer! 

nb: Le programme fonctionne bien.

Le but de l'exercice était de créer une classe Etudiant avec les attributs et méthodes ci-dessous et une classe Etudiant_en_maitrise qui en hérite:

Etudiant.h:

#ifndef DEF_ETUDIANT
#define DEF_ETUDIANT
#include <iostream>
#include <string>

class Etudiant
{
public:

	Etudiant();
	void Saisie();
	void affichage()const;
	double moyenne()const;
	int estAdmis()const;
	int exae_quo(Etudiant const& autre)const;


protected:

	std::string m_nom;
	std::string m_prenom;
	double m_tabNotes[10];
};

#endif 

Etudiant.cpp:

#include <iostream>
#include <string>
#include "Etudiant.h"

using namespace std;

Etudiant::Etudiant():m_nom(""),m_prenom("")
{
	
}

void Etudiant::Saisie()
{
	cout<<"Entrez votre nom de famille:"<<endl; cin>>m_nom;
	cout<<"Entrez votre prenom:"<<endl;cin>>m_prenom;

	cout<<"Saisissez vos notes"<<endl;

	int nNote(1);

	for(int i(0);i<10;i++)
	{
		cout<<"Note "<<nNote<<endl;

		cin>>m_tabNotes[i];

		nNote++;
	}
}


void Etudiant::affichage()const
{
	cout<<"Etudiant "<<m_prenom<<" "<<m_nom<<endl;

	cout<<"Notes:"<<endl;

	int numNote(1);

	for(int i(0);i<10;i++)
	{
		cout<<"Note"<<numNote<<":"<<" "<<m_tabNotes[i]<<endl;
		numNote++;
	}
}

double Etudiant::moyenne()const
{
	double sommeNotes(0);

	for(int i(0);i<10;i++)
	{
		sommeNotes+=m_tabNotes[i];
	}

	return(sommeNotes/10);
	
}

int Etudiant::estAdmis()const
{
	if(Etudiant::moyenne()>=10)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

int Etudiant::exae_quo(const Etudiant &autre) const
{
	if(Etudiant::moyenne()==autre.moyenne())
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

Etudiant_en_maitrise.h:

#ifndef DEF_ETUDIANT_EN_MAITRISE
#define DEF_ETUDIANT_EN_MAITRISE
#include <iostream>
#include <string>
#include "Etudiant.h"

class Etudiant_en_maitrise:public Etudiant
{
public:

    Etudiant_en_maitrise();
	void Saisie();
	void affichage()const;
private:

	std::string m_noteMemoire;
};

#endif 

Etudiant_en_maitrise.cpp:

#include <iostream>
#include <string>
#include "Etudiant_en_maitrise.h"

using namespace std;

Etudiant_en_maitrise::Etudiant_en_maitrise():m_noteMemoire("")
{
	Etudiant::Etudiant();
}

void Etudiant_en_maitrise::Saisie()
{
	Etudiant::Saisie();

	cout<<"Donnez votre avis sur notre etablissemnt avant de nous quitter!(un seul mot decrivant la qualite de notre enseignement)"<<endl;
	cin>>m_noteMemoire;
}

void Etudiant_en_maitrise::affichage()const
{
	Etudiant::affichage();

	cout<<"Note memoire de l'etudiant: "<<endl<<m_noteMemoire<<endl;
}

Main.cpp:

#include <iostream>
#include <string>
#include "Etudiant.h"
#include "Etudiant_en_maitrise.h"

using namespace std;

int main()
{
	Etudiant etudiant1;

	Etudiant etudiant2;

	etudiant1.Saisie();
	etudiant2.Saisie();

	system("cls");

	double moyEtud1=etudiant1.moyenne();
	double moyEtud2=etudiant2.moyenne();

	etudiant1.affichage();

	cout<<"Moyenne des notes: "<<moyEtud1<<endl<<endl;


	etudiant2.affichage();

	cout<<"Moyenne des notes: "<<moyEtud2<<endl<<endl;;


	if(etudiant1.estAdmis()==1)
	{
		cout<<"Etudiant admis en classe superieure"<<endl;
	}
	else if(etudiant1.estAdmis()==0)
	{
		cout<<"Etudiant recale"<<endl;
	}

	Etudiant_en_maitrise etudiant3;

	etudiant3.Saisie();

	etudiant3.affichage();

	cout<<"Moyenne des notes: "<<etudiant3.moyenne()<<endl<<endl;

	

	
	





	system("PAUSE");
	return 0;
}

Salut,

oui, le cours d'OC est non seulement obsolète, mais aussi (et surtout) faux sur bien des points.

Je remarque cependant que tu as évité pas mal des problèmes qu'il peut poser dans ton code, dont la seule partie obsolète consisterait à utiliser double m_tabNotes[10]; au lieu de  std::array m_tabNotes; (à moins bien sur que tu ne veuilles pouvoir mettre un nombre inconnu de notes à tes élèves, les limites arbitraires n'étant jamais une bonne chose, au quel cas, il faudrait utiliser std::vector ).

Mais C'est surtout sur son approche orientée objets, sur l'approche qu'il a des classes intervenant dans les hiérarchies de classes et sur toute la gestion manuelle de la mémoire que ce cours pèche.  Le fait est "tout simplement" que tu n'as pas, actuellement, dans ton projet besoin de ces fonctionnalités, et que tu ne te rend donc pas compte des problèmes qu'il peut poser.

Dis toi bien que, même si tu avais recours à l'allocation dynamique de la mémoire, de la manière indiquée par le cours, tu n'aurais de toutes manières pas le recul suffisant que pour te rendre compte des problèmes qu'il pose, car c'est un processus complexe à appréhender dans son ensemble

Mais dis toi aussi que ceux qui "dénigrent" ce cours savent aussi de quoi ils parlent : beaucoup d'entre nous sont des professionnels actifs en C++, dans différents secteurs, avec différentes spécialisations.  Tu peux donc nous croire sur parole

T'as des dépendances inutiles, par example <iostream> dans Etudiant.h, <string> dans Etudiant.cpp, Etudiant_maitrise.cpp et main.cpp

type array_name[CONSTANTE]
//devient
std::array<type, CONSTANTE> array_name

int Etudiant::estAdmis()const
{
    if(Etudiant::moyenne()>=10)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//devient et de même pour exae_quo
bool Etudiant::estAdmis() const {
    return moyenne() >= 10;
}

double Etudiant::moyenne()const
{
    double sommeNotes(0);

    for(int i(0);i<10;i++)
    {
        sommeNotes+=m_tabNotes[i];
    }

    return(sommeNotes/10);

}
//devient
double Etudiant::moyenne() const{
    std::accumulate(std::cbegin(m_tabNotes), std::cend(m_tabNotes), 0.0) / m_tabNotes.size();
}

Dans ton code tu peux calculer la moyenne ou afficher les notes avant même de les avoir saisie. On peut créer une fonction qui renvoie un Etudiant et lance une exeption en cas d'erreur de saisie ou sinon renvoyer une std::optional<Etudiant>

Saisie()/affichage() auraient pu prendre un istream/ostream en argument pour les rendre plus fléxible. Non cohérence de nommage: Saisie() a une majuscule pas affichage().

Tu peux rajouter des noexcept et des override.

system("cls") n'est pas portable

for(int i(0);i<10;i++)

pour parcourir un conteneur en priorité on utilise les algo, puis les for-range loop, puis for + iterator et en dernier for + index. Dans le cas de for + index, l'index est rarement un entier signé mais plutot un std::size_t.  Et 10 est un nombre magic

Sinon ton code est correct dans le sens où il ne produit pas de fuite de mémoire et qu'il n'y a pas de dépassement de tableau. Le code est simple mais j'espère que dans le cas d'un programme demandant de faire des allocations dynamiques que t'aurais utilisé les conteneurs RAII (vector, {unique,shared,weak}_ptr)

-
Edité par Dichotoman 10 mai 2017 à 0:47:38

Salut. Mes critiques concerneraient 

1- le type des booleens, c'est bool et pas besoin du if. 

2- les I/O n'ont rien à faire dans les classes metier

3- le standard nous offre std::accumulate pour les moyennes

4- quel est le sens d'un heritage ici ? Où est la procédure commune et où sont les points de variation? Le seul bon exo que je connaisse pour travailler l'OO, c'est celui du javaquarium sur zeste de savoir. Les autres exo de modélisation font faire des choses qui n'ont aucun sens et qui sont bien bancales. 

5- quel est le sens d'un etudiant construit mais qui n'a pas de nom ? Comment éviter cette situation? (Question non triviale, mais dont les répercutions sont loins d'être anodines)

6- j'aurais renommé exaequo en est_exaequo_avec.

Sinon bien pour const et pour std::string. Presque parfait pour la structure du .h : tu n'as pas besoin d'y inclure iostream.

Merci à tous pour vos remarques! je vais essayer d'adapter mon code et prendre l'habitude d'écrire correctement!

Note:pour ce qui est des fonctions "estAdmis" ou encore "exae_quo" qui auraient bêtement pu être de type bool plutôt que int, en fait c'est juste l'énoncé de l'exercice que j'ai trouvé sur internet qui veut que ce soit ainsi!

Je compte bien sur changer de cours, pouvez-vous me proposer des cours plus complets et un peu plus récents?

-
Edité par TheLittlePolo 10 mai 2017 à 22:39:25

Le cours de guillaume belz est récent mais en cours de rédaction , il y a pas mal de chose à apprendre pour l'instant , le voici :

http://guillaume.belz.free.fr/doku.php?id=programmez_avec_le_langage_c

moi aussi j'étudie sur ce cours c++ , au début il y a des trucs mathématique avec un niveau assez élevé, je pense qu'il explique assez bien , mais quelque fois il faudra que tu t'informe par toi même  .

Bonne continuation .

Pour moi, ta classe Etudiant fait trop de choses.

La fonction estAdmis n'a pour moi rien à y faire (j'en ferais une fonction libre, probablement).
La fonction ex_aequo n'a rie à y faire non plus (pareil, j'en ferais une fonction libre prenant 2 étudiants).

Après, ces 2 points sont liés au fait qu'un étudiant possède ses notes (bonne chose, ou pas ?).

Enfin, estAdmis et ex_aequo => 2 conventions de nommage différentes. Choisis celle qui te convient le mieux, et tiens y toi.

Resalut! En lisant le nouveau cours que je suis (et dont je suis encore au tout début), je me suis rendu compte qu'il n'y a pas tant de différences que cela entre ce cours-là et celui d'OC (tout du moins au début....).

Je voudrais donc savoir SUR QUELS POINTS le cours d'ici est-il obsolète? quels éléments du c++ exactement seraient à revoir dans ce cours?

http://informaticienzero.com/c-avec-openclassrooms-ou-comment-perdre-son-temps/

Il y a même une liste de lien en bas.

Un exemple symptomatique des trucs odieux que ça contient : https://openclassrooms.com/forum/sujet/erreur-heritage-poo#message-88917734. Et j'insiste : cet exemple est tiré du "cours".

(Message copié collé d'une recherche sur le forum avec "cours C++ faux liens").

-
Edité par Ksass`Peuk 16 mai 2017 à 9:50:11

Le cours n'a pas changé, et 2017 (date du 1 message) < 2020 (aujourd'hui)

Zeste De Savoir sera un meilleur point de départ à cette date.

-
Edité par xakula 8 novembre 2020 à 21:42:39

xakula a écrit:

ok merci, je posais la question parce que sur la première page du cours, il était indiqué qu'une mise à jour datait du 03/06/2020 (juste en-dessous bandeau bleu, tout en haut). Du coup, par précaution...

-
Edité par xakula il y a 6 minutes

Un argument contre la mauvaise idée d'utiliser l'héritage (et les exemples à la con).

Un etudiant est une personne qui peut être successivement lycéen, étudiant en licence, en master, etc.

Ici il n'y a pas de moyen de faire passer un étudiant de licence en master, à part le supprimer et créer un nouvel étudiant.

Si on veut représenter des étudiants qui survivent à l'année scolaire, il faut leur donner un champ "inscription"  qui peut varier.

-
Edité par michelbillaud 8 novembre 2020 à 22:03:59

> ok merci, je posais la question parce que sur la première page du cours, il était indiqué qu'une mise à jour datait du 03/06/2020 (juste en-dessous bandeau bleu, tout en haut). Du coup, par précaution... > J'ai également vu ça, il me semble qu'ils remettent à jour de temps en temps le cours

Les tournures de phrase changent un peu de temps en temps (allez savoir pourquoi...), mais le fond reste le même. On peut toujours trouver le pdf de 2013 au moment du changement de nom du site (https://openclassrooms.com/fr/old-courses-pdf) et le contenu n'a pas vraiment changé depuis.

jo_link_noir a écrit:

> ok merci, je posais la question parce que sur la première page du cours, il était indiqué qu'une mise à jour datait du 03/06/2020 (juste en-dessous bandeau bleu, tout en haut). Du coup, par précaution... > J'ai également vu ça, il me semble qu'ils remettent à jour de temps en temps le cours

Les tournures de phrase changent un peu de temps en temps (allez savoir pourquoi...), mais le fond reste le même. On peut toujours trouver le pdf de 2013 au moment du changement de nom du site (https://openclassrooms.com/fr/old-courses-pdf) et le contenu n'a pas vraiment changé depuis.

Non, ça reste un ramassis de bêtises qui enseigne un C++ à des années lumières de ce qu'il faut faire. Il y a 10 ans le cours était déjà obsolète, alors qu'à côté le langage évolue. Le lire est une pure perte de temps. Et il est bien loin d'être complet, beaucoup de choses essentielles ne sont jamais évoquées.

Le cours de Zeste de savoir, même s'il est toujours en cours de rédaction est largement meilleur.

Bonjour xacula,

Les bonnes pratiques du forum te demande de ne pas déterrer un vieux sujet, mais d'en créer un nouveau, en faisant référence (lien hypertexte) à l'ancien message. Si non, tu vas te faire taper sur les doigts !

Cordialement.