Bonjour

J'ai repris l'exercice de la POO avec le mini rpg en mode console, j'ai modifié mon arme en tant que pointeur et fait les modifications comme dans le cours mais ça ne compile pas, j'ai regardé plusieurs fois le cours et mon code mais étant débutant j'aurai besoin de quelqu'un qui puisse me dire ce qui coince.

Je comprends qu'il y a plein de message d'erreur car ma classe Arme n'est pas reconnu dans le classe Personnage. Pourtant il y a bien le Arme.h en include ds le Personnage.h

Je ne sais pas du tout d'ou ça peut venir donc je met la totalité du code ainsi que les messages d'erreurs du compilateur.

Voici les fichiers désolé pour la longueur du code...

Merci pour l'aide

main.cpp

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


using namespace std;


int main()
{
    // Création des personnages
    Personnage david("david"), goliath("goliath", "Epée aiguisée", 20), magicien("gandalf", 70, 200, "baguette magique brulante", 30);

    // Au combat !
    cout << "============= ETAT DE DEPART ==============" << endl;
    david.afficherEtat(); goliath.afficherEtat(); magicien.afficherEtat();

    cout << "============= DEROULEMENT DU COMBAT ==============" << endl;
    goliath.attaquer(david);
    david.boirePotionDeVie(20);
    goliath.attaquer(david);
    david.attaquer(goliath);
    goliath.changerArme("Double hache tranchante vénéneuse de la mort", 40);
    goliath.attaquer(david);
    magicien.attaquer(goliath);  // gandalf vient en ide à david

    // Temps mort ! Voyons voir la vie de chacun...
    cout << "================ ETAT APRES COMBAT ==============" << endl;
    david.afficherEtat();
    goliath.afficherEtat();
    magicien.afficherEtat();

    return 0;
}

Personnage.h

#ifndef DEF_PERSONNAGE
#define DEF_PERSONNAGE

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

class Personnage
{
    public:

    Personnage(std::string nom);
    Personnage(std::string nom, std::string nomArme, int degatsArme);
    Personnage(std::string nom, int vie, int mana, std::string nomArme, int degatsArme);
    Personnage(Personnage const& personnageACopier);
    ~Personnage();

    void recevoirDegats(int nbDegats);
    void attaquer(Personnage &cible);
    void bouleDeFeu(Personnage &cible);
    void boirePotionDeVie(int quantitePotion);
    void changerArme(std::string nomNouvelleArme, int degatsNouvelleArme);
    bool estVivant();
    void afficherEtat();

    Personnage& operator=(Personnage const& personnageACopier);

    private:

    std::string m_nomPersonnage;
    int m_vie;
    int m_mana;
    Arme *m_arme;
};

#endif

Personnage.cpp

#include "Personnage.h"



using namespace std;


Personnage::Personnage(string nom) : m_nomPersonnage(nom), m_vie(100), m_mana(100)
{
    m_arme = new Arme(); // apelle le constructeur de arme par défau
}

Personnage::Personnage(string nom, string nomArme, int degatsArme) : m_nomPersonnage(nom), m_vie(100), m_mana(100), m_arme(0) // Par sécurité on initialise le pointeur m_arme à 0
{
    m_arme = new Arme(nomArme, degatsArme); // appelle le construsteur de arme avec les paramètres
}

Personnage::Personnage(string nom, int vie, int mana, string nomArme, int degatsArme) : m_nomPersonnage(nom), m_vie(vie),
m_mana(mana), m_arme(0)
{
    m_arme = new Arme(nomArme, degatsArme);
}

Personnage::Personnage(Personnage const& personnageACopier)  // Constructeur de copie
   : m_vie(personnageACopier.m_vie), m_mana(personnageACopier.m_mana), m_arme(0)
{
    m_arme = new Arme(*(personnageACopier.m_arme)); // Pour eviter d'avoir la même arme pour 2 personnage qui sera supprimé si on des personnage est supprimé
}

Personnage::~Personnage()
{
    delete m_arme; // Notre Arme étant un pointeur, lorsque l'objet de type Personnageest supprimé, l'Arme ne disparaît pas toute seule
}

void Personnage::recevoirDegats(int nbDegats)
{
    m_vie -= nbDegats;

    if (m_vie < 0)
    {
        m_vie = 0;
    }
}

void Personnage::attaquer(Personnage &cible)
{
    cout << m_nomPersonnage << " attaque " << cible.m_nomPersonnage << endl;
    cible.recevoirDegats(m_arme->getDegats());                                  // Avec une fleche car m_arme est un pointeur
    cout << cible.m_nomPersonnage << " perd " << m_arme->getDegats() << " points de vie." << endl << endl;
}

void Personnage::bouleDeFeu(Personnage &cible)
{
    cout << m_nomPersonnage << " lance boule de feu sur " << cible.m_nomPersonnage << endl;
    cible.recevoirDegats(m_arme->getDegats());
    cout << cible.m_nomPersonnage << " perd " << m_arme->getDegats() << " points de vie." << endl << endl;
}

void Personnage::boirePotionDeVie(int quantitePotion)
{
    cout << m_nomPersonnage << " boit potion de vie et recupere " << quantitePotion << " points de vie." << endl << endl;
    m_vie += quantitePotion;

    if (m_vie > 100)
    {
        m_vie = 100;
    }
}

void Personnage::changerArme(string nomNouvelleArme, int degatsNouvelleArme)
{
    cout << m_nomPersonnage << " change d'arme pour " << nomNouvelleArme << " de " << degatsNouvelleArme
    << " points de dégats." << endl << endl;
    m_arme->changer(nomNouvelleArme, degatsNouvelleArme);
}

bool Personnage::estVivant()
{
    if (m_vie > 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

void Personnage::afficherEtat()
{
    cout << m_nomPersonnage << endl;
    cout << "Vie : " << m_vie << endl;
    cout << "Mana : " << m_mana << endl;
    m_arme->afficher();
    cout << '\n' ;
}

// Si l'on a besoin d'écrire un constructeur de copie, alors il faut aussi obligatoirement écrire une surcharge deoperator=.

Personnage& Personnage::operator=(Personnage const& personnageACopier)  // surcharge opérateur =
{
    if(this != &personnageACopier)
    //On vérifie que l'objet n'est pas le même que celui reçu en argument
    {
        m_vie = personnageACopier.m_vie; //On copie tous les champs
        m_mana = personnageACopier.m_mana;
	delete m_arme;
        m_arme = new Arme(*(personnageACopier.m_arme));
    }
    return *this; //On renvoie l'objet lui-même
}

Arme.h

#ifndef DEF_ARME
#define DEF_ARME

#include <iostream>
#include <string>

class Arme
{
    public:

    Arme();
    Arme(std::string nom, int degats);
    void changer(std::string nom, int degats);
    void afficher();
    int getDegats() const;

    private:

    std::string m_nom;
    int m_degats;
};

#endif

Arme.cpp

#include "Arme.h"

using namespace std;

Arme::Arme() : m_nom("Epée rouillée"), m_degats(10)
{

}

Arme::Arme(string nom, int degats) : m_nom(nom), m_degats(degats)
{

}

void Arme::changer(string nom, int degats)
{
    m_nom = nom;
    m_degats = degats;
}

void Arme::afficher()
{
    cout << "Arme : " << m_nom << " (Dégâts : " << m_degats << ")" << endl;
}

int Arme::getDegats() const
{
    return m_degats;
}

Erreur compilateur

||=== Build: default in Console application (compiler: GNU GCC Compiler) ===|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `___gxx_personality_sj0'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__Unwind_SjLj_Register'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSaIcEC1Ev'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1EPKcRKS3_'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSaIcED1Ev'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSaIcED1Ev'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__Unwind_SjLj_Resume'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__Unwind_SjLj_Unregister'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEC1ERKS4_'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEaSERKS4_'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZSt4cout'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZStlsIcSt11char_traitsIcESaIcEERSt13basic_ostreamIT_T0_ES7_RKNSt7__cxx1112basic_stringIS4_S5_T1_EE'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSolsEi'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSolsEPFRSoS_E'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSt8ios_base4InitD1Ev'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `__ZNSt8ios_base4InitC1Ev'|
/usr/bin/ld: .objs/Arme.o:Arme.cpp|| undefined reference to `_atexit'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::Personnage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)':|
Personnage.cpp|| undefined reference to `Arme::Arme()'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::Personnage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int)':|
Personnage.cpp|| undefined reference to `Arme::Arme(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int)'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::Personnage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int)':|
Personnage.cpp|| undefined reference to `Arme::Arme(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int)'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::attaquer(Personnage&)':|
Personnage.cpp|| undefined reference to `Arme::getDegats() const'|
/usr/bin/ld: Personnage.cpp|| undefined reference to `Arme::getDegats() const'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::bouleDeFeu(Personnage&)':|
Personnage.cpp|| undefined reference to `Arme::getDegats() const'|
/usr/bin/ld: Personnage.cpp|| undefined reference to `Arme::getDegats() const'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::changerArme(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int)':|
Personnage.cpp|| undefined reference to `Arme::changer(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, int)'|
/usr/bin/ld: .objs/Personnage.o||in function `Personnage::afficherEtat()':|
Personnage.cpp|| undefined reference to `Arme::afficher()'|
||error: ld returned 1 exit status|
||=== Build failed: 31 error(s), 0 warning(s) (0 minute(s), 1 second(s)) ===|

Ca ressemble a une erreur de fichiers non correctement ajouté dans le projet dans Code::Block. Verifies ton projet.

Lu'!

Changes de cours. Il apprend un sacré paquet d'âneries à ne pas faire, en plus de montrer des exemples de code buggés et d'être obsolète (quelques recherches sur le forum t'en diront plus). Prends plutôt le tutoriel disponible sur Zeste de Savoir. Ou encore le cours de C++ de @gbdivers, même s'il est encore en écriture il ne contient pas ce genre de bavures (et si tu as des problèmes de compréhension sur une partie et que ce n'est pas à cause d'un manque d'étude du cours, tu peux poster ici). Si tu préfères un cours déjà complet, tourne toi vers le C++ Primer de Lippman dans sa dernière édition (en anglais), il sera un poil moins à jour mais c'est un bon cours.

Concernant ton code, quelques remarques :

• n'utilise pas "using namespace std" (raison + que faire),
• tes classes ont une sémantique d'entité, elles devraient être non-copiable, non affectable par copie,
• n'utilise pas new et delete à moins de très bien savoir ce que tu fais (voir std::unique_ptr ici),

• if (m_vie > 0)
  {
      return true;
  }
  else
  {
      return false;
  }

  Ou plus simplement :

  return (m_vie > 0);

Concernant ton problème, c'est la configuration de ta compilation qui semble être à la masse.

Merci pour les retours,

En effet merci c'était juste un problème de compilation je pouvais toujours chercher l'erreur.

J'ai recréé le projet avec Qt Creator ça compile parfaitement, du coup pour corriger le probleme avec code Block j'ai supprimé le Arme.h qui était apparemment le fichier posant souci et j'ai rajouté un Arme.h tout neuf en faisant bien attention que ça soit intégré au projet. Mais bon ça compilait très bien avant les 2 ou 3 retouches faite sur le Arme en pointeur et je ne vois pas pourquoi entre 2 sauvegarde le fichier n'était plus dans les liens à la compilation.

Bref merci pour l'aide

Pour ce qui est de la qualité du cours, je suis d'accord cependant je tiens à la finir, dèja parce que je l'ai commencé dans ça serait dommage mais il faut avouer que pour un débutant en programmation ce cours est quand même EXTREMEMENT simple contrairement aux autre cours proposé. De plus il abord beaucoup de point sans entrer dans les détails ce qui permet de survoler pas mal de sujet et donc d'avoir un aperçu des possibilités du C++ et d'avoir du concret sous les yeux. 

Aucun cours ne présente par exemple Qt, avec des explications aussi simple et en français. Ce n'est pas mon metier et ça le sera jamais du coup certains cours vont un peu loin dans les détails et un peu dur à appréhender pour un débutant qui veut juste programmer qlq programme simple pour son usage personnel sans viser un poste de programmer à la NASA.

Ca ne m'empeche pas de lire en parallèle le Cours Penser en C++ de bruce Eckel qui au passage utilise aussi le namespace std, et vendu par cpp.developpez.com

J'ai lu une bonne parti du cours de gbdriver mais le cours est loin d'être terminé, très complet je l'avoue mais bcp moins simple, c'est pourquoi je continue aussi ce cours pour ne pas me décourager et le cours sur Zeste du savoir qui lui ne va pas très loin pour le moment.

Après avoir tourné sur qlq forum je lui loin d'être le seul avec ce sentiment et c'est pourquoi je pense que ce cours continuera de tourner qlq temps chez les débutant, d'être vendu et bien noté sur amazon malgré toutes les remarques de mauvaises habitudes et hérésie très souvent remarqué par les professionnels ou expert du C++... il n'existe tout simplement pas d'alternative à ce jour pour un débutant. Il faut bien se mettre dans la peau d'un débutant, les choses qui vous paraissent simples sont loin de l'être pour quelqu’un qui débute en programmation et pas simplement en C++, on a besoin d'explication pour installer Qt par ex ou comment installer code block ou tout simplement savoir que ça existe, sans ce cours je n'aurai jamais essayé Qt et créé des fenre avec plein de bouton alors que je trouve ça génial et que je m'amuse à lire la doc et à décortiquer les classes et essayer les différentes méthodes proposé pour tous les Widgets.

On n'a jamais dit qu'il n'était pas simple et pédagogique, c'est même précisément le problème, il apprend parfaitement à faire n'importe quoi. Et c'est bien plus problématique justement qu'un cours qui serait tout aussi mauvais mais peu pédagogique. Se défaire de mauvaises habitudes et de mauvais enseignements est beaucoup plus difficile qu'apprendre directement à faire ce qu'il faut pour avoir des programmes qui tiennent la route.

salessesmarc a écrit:

Pour ce qui est de la qualité du cours, je suis d'accord cependant je tiens à la finir, dèja parce que je l'ai commencé dans ça serait dommage mais il faut avouer que pour un débutant en programmation (1) ce cours est quand même EXTREMEMENT simple contrairement aux autre cours proposé. De plus il abord beaucoup de point (2) sans entrer dans les détails ce qui permet de survoler pas mal de sujet et donc d'avoir un aperçu des possibilités du C++ et d'avoir du concret sous les yeux.

(1) Par rapport au C++ Primer, really ?

(2) Le problème c'est que dans le cas de C++, c'est se voiler la face. Le code présent dans le "cours" d'OC est par endroit complètement buggé, complètement faux, et présenté comme exemple. Simplifier, oui, mettre du contenu faux, je pense que c'est difficilement défendable.

salessesmarc a écrit:

(1) Aucun cours ne présente par exemple Qt, avec des explications aussi simple et en français. (2) Ce n'est pas mon metier et ça le sera jamais du coup certains cours vont un peu loin dans les détails et un peu dur à appréhender pour un débutant qui veut juste programmer qlq programme simple pour son usage personnel (3) sans viser un poste de programmer à la NASA.

(1) Simplement parce qu'attaquer Qt sans une très bonne connaissance préalable de C++, c'est du suicide. On le constate tous les jours sur le forum. On a une pelleté de débutants qui se cassent les dents sur l'utilisation de Qt pour la simple et bonne raison qu'ils n'ont pas les bases suffisantes en C++ pour comprendre comment l'utiliser correctement. Du coup, les aides proposées sont bien plus souvent des pansements sur une jambe de bois.

(2) Dans ce cas, on peut se demander pourquoi se faire chier avec un langage aussi pourri de détails sordides dans tous les sens que C++ plutôt que n'importe quel langage qui aurait été designé de manière plus saine. Parce que bon il faut le dire, ça reste un langage bien dégueulasse et inutilisable si on ne fait pas hyper gaffe à ce qu'on fait dans tous les sens, et rien dans le langage n'est prévu pour te filer un coup de main. Si tu n'as pas le besoin de C++, c'est dommage de se casser le cul avec, c'est franchement pas le langage le plus agréable pour manipuler la programmation en tant qu'amateur.

(3) (Il y a pas grand monde qui développe en C++ à la NASA, principalement pour les raisons exposées juste avant ).

salessesmarc a écrit:

Ca ne m'empeche pas de lire en parallèle le Cours Penser en C++ de bruce Eckel qui au passage utilise aussi le namespace std, et vendu par cpp.developpez.com

Cours qui sont tout aussi obsolètes. Le langage a plus que changer en 15 ans. C'est pour ainsi dire pas le même langage qu'il y a 15 ans.

salessesmarc a écrit:

il n'existe tout simplement pas d'alternative à ce jour pour un débutant.

C++ Primer.

-
Edité par Ksass`Peuk 5 novembre 2018 à 14:49:17

salessesmarc a écrit:

Ca ne m'empeche pas de lire en parallèle le Cours Penser en C++ de bruce Eckel qui au passage utilise aussi le namespace std, et vendu par cpp.developpez.com

Ce livre est encore plus vieux que le cours C++ de openclassrooms... Et developpez.com a le même problème que openclassrooms pour avoir des cours a jour (voire pire, pour la rubrique C++... et je suis bien placé pour le savoir). De toute façon, globalement, ce sont les mêmes personnes qui aident sur Dvp et OC.

salessesmarc a écrit:

mais il faut avouer que pour un débutant en programmation ce cours est quand même EXTREMEMENT simple contrairement aux autre cours proposé.

Ce qui nous gêne n'est pas qu'il soit simple. C'est surtout qu'il contient beaucoup d'erreurs. Et que c'est plus simple pour toi au final de ne pas apprendre des erreurs, plutôt que d'apprendre des erreurs dans un premier temps, puis de corriger ce que tu as appris.

salessesmarc a écrit:

Ce n'est pas mon metier et ça le sera jamais du coup certains cours vont un peu loin dans les détails et un peu dur à appréhender pour un débutant qui veut juste programmer qlq programme simple pour son usage personnel sans viser un poste de programmer à la NASA.

C'est pour cela que l'approche "historique" (que l'on retrouve dans le cours d'OC ou de Dvp) est déconseillé en fait : à quoi ca sert d'apprendre des fonctionnalités avancées comme les pointeurs nus (très durs utiliser correctement, même pour un pro) alors que le C++ "moderne" permet de s'affranchir d'une bonne partie des pièges du C++ old school ? C'est un peu comme si tu disais que tu voulais apprendre a conduire une voiture tirée par des cheveux parce que c'est plus simple qu'une voiture moderne.

salessesmarc a écrit:

il n'existe tout simplement pas d'alternative à ce jour pour un débutant

Je suis d'accord sur ce point (en francais). Et effectivement, mon cours ne se veut pas être un remplaçant du cours d'OC. Parce qu'il y a une question qu'il faut se poser : si on ne souhaite pas prendre le temps d'apprendre correctement le C++, est-ce que c'est une bonne idée d'apprendre le C++ ?

Si tu survoles que les bases du C++ (comme c'est le cas avec le cours d'OC), TOUT ce que tu feras avec le C++, tu pourras le faire avec un autre langage. (On conseille souvent le Python pour les débutants).

Pour continuer dans les analogies foireuses, c'est comme si tu voulais apprendre a piloter un avion, mais juste les bases, c'est a dire uniquement rouler sur les pistes sans jamais décoller. Je te dirais aussi : est-ce une bonne idée de vouloir apprendre a piloter un avion si ce n'est que pour faire ca ?

Du coup, pourquoi le C++ ?

EDIT : grillé par Ksass'peuk Mais nos messages vont dans le même sens, a croire qu'on s'est concerté. Avec toujours cette question : pourquoi apprendre le C++ ???

-
Edité par gbdivers 5 novembre 2018 à 14:53:34

Pourquoi apprendre le C++, pourquoi pas, quand tu débutes c'est dur de s'y retrouver au milieu de tout ces langages et de tout les forum qui te vendent leur langage plutot qu'un autre,

c'est justement ce que j'ai dis il faut bien débuter quelque part même si la maitrise des regles de l'art ne sont pas parfaite... Puis quand je finirai le cours effectivement je me tournerai surement vers Python qui me sera largement suffisant j'en suis sur. Mais rien n'empeche de tout de même d'essayer de finir ce foutu cours..... 

et je pense pas qu'avec seulement ce cours on puisse prendre de mauvaises habitude, c'est tellement rapide et simple et le cours à lui seul ne permettra pas de porgrammer suffisameent pour prendre des habitudes.

Apres si ce cours est si mauvais pourquoi ne pas l'enlever de la base de donnée alors ? Ils seront peut être d'accord sur OC je ne sais pas, leur but c'est de faire un peu de qualité aussi non ?

salessesmarc a écrit:

et je pense pas qu'avec seulement ce cours on puisse prendre de mauvaises habitude, c'est tellement rapide et simple et le cours à lui seul ne permettra pas de porgrammer suffisameent pour prendre des habitudes.

J'en ai personnellement fait les frais il y a bientôt 10 ans (et c'est aussi le cas d'un paquet d'autres gens croisés années après années sur le forum), il y a pas besoin de beaucoup de pratiques pour acquérir une mauvaise habitude. Le plus mauvaises d'entre toutes en C++ étant sûrement new/delete. Et le cours n'a pas subi de mise à jour réelle depuis ce temps (il n'y a eu que des changements très mineurs).

salessesmarc a écrit:

Apres si ce cours est si mauvais pourquoi ne pas l'enlever de la base de donnée alors ? Ils seront peut être d'accord sur OC je ne sais pas, leur but c'est de faire un peu de qualité aussi non ?

Euh non. Leur but c'est de faire de l'argent. Ils n'ont pas besoin que la qualité soit là, juste que leurs clients y croient.

salessesmarc a écrit:

et de tout les forum qui te vendent leur langage plutot qu'un autre,

En l'occurrence, si sur le forum C++, on te dit que le C++ n'est pas forcement une bonne idée si tu ne peux pas l'étudier correctement, c'est un indice, non ?

salessesmarc a écrit:

Mais rien n'empeche de tout de même d'essayer de finir ce foutu cours...

Sur ce point, on est d'accord : on ne va pas venir chez toi pour désinstaller Code::Block et t'interdire de faire du C++.

Tu restes responsable de tes choix. Les bons comme les mauvais.

salessesmarc a écrit:

et je pense pas qu'avec seulement ce cours on puisse prendre de mauvaises habitude

Si tu ne retiens rien, tu ne peux effectivement pas prendre de mauvaise habitude. Si tu apprends des choses, tu peux prendre des mauvaises habitudes.

On est quand même plusieurs "vieux cons" ici, qui avons appris le C et/ou le C++ old school en premier, on est bien placé pour savoir que se débarrasser d'une habitude est difficile.

salessesmarc a écrit:

Apres si ce cours est si mauvais pourquoi ne pas l'enlever de la base de donnée alors ? Ils seront peut être d'accord sur OC je ne sais pas, leur but c'est de faire un peu de qualité aussi non ?

Openclassrooms fait de la qualité (à mon sens). Mais cela ne veut pas dire que TOUT est de qualité.

Ils investissent beaucoup de temps et d'argent pour proposer des cours à jour, validé par des professionnels du domaine ET par des professionnels de la pédagogie, le tout assisté par des professionnels de l'audiovisuel. Et ils prennent aussi beaucoup de temps pour l'encadrement des apprenants.

Mais a coté des bons cours (payant souvent), il y a aussi des anciens cours, des choses qui ne sont plus du tout a jour (même Mathieu Nebra, l'un des auteurs du cours C++ le reconnait). Mais pour des questions de moyens et de choix d'entreprises, tous les cours ne sont pas (encore ?) mis a jour. 

En attendant, ces anciens cours restent en ligne et en vente. Parce qu'ils ne sont pas idiots, ils ne vont pas supprimer quelque chose qui leur apporte de la présence et de l'argent.

-
Edité par gbdivers 5 novembre 2018 à 16:19:15

OK merci pour ces retours et conseils et merci de prendre du temps pour aider les débutants qui comme moi en ont besoin.

Et donc j'ai regardé pour C++ Primer ont trouve la version 5 gratuite en Pdf et il y a une nouvelle version qui sort en janvier 2019 donc si le livre est bien et mis à jour en plus dans 2 mois ça devrait être pas mal...

A bientot

-
Edité par salessesmarc 5 novembre 2018 à 17:13:54

salessesmarc a écrit:

Et donc j'ai regardé pour C++ Primer ont trouve la version 5 gratuite en Pdf et il y a une nouvelle version qui sort en janvier 2019 donc si le livre est bien et mis à jour en plus dans 2 mois ça devrait être pas mal...

A ma connaissance, pas de 6ème édition annoncée pour le moment. (Tu confonds peut être avec "C++ Primer Plus" ?)

Et ce n'est bien sûr pas un "pdf gratuit", c'est un pdf pirate.

-
Edité par gbdivers 5 novembre 2018 à 17:27:50

Ksass`Peuk a écrit:

• return (m_vie > 0);

Évitez les parenthèses autour du return, ça peut provoquer quelques surprises.

https://stackoverflow.com/a/25615981

https://stackoverflow.com/q/49931586

-
Edité par markand 6 novembre 2018 à 10:41:53

C'est surtout avec auto qu'il faut se méfier.

gbdivers a écrit:

A ma connaissance, pas de 6ème édition annoncée pour le moment. (Tu confonds peut être avec "C++ Primer Plus" ?)

je parle de ce livre : https://www.amazon.fr/gp/product/0135161797/ref=oh_aui_detailpage_o00_s00?ie=UTF8&psc=1

Il dise bien que c'est la 6eme edition

-
Edité par salessesmarc 6 novembre 2018 à 11:07:33

Effectivement. C'est amusant, je n'ai pas vu d'annonces par les auteurs ou l'éditeur, Amazon est en avance

Ouen pleine rupture d'un NDA

En faisant une recherche sur C++ Primer directement, aucun moyen d'avoir des infos. Par contre, en faisant une recherche sur le numéro ISBN, on voit que ce livre est présent sur plusieurs pages Amazon (.fr, .co.uk, .it, .es, etc). C'est étrange.

Ksass`Peuk a écrit:

Ouen pleine rupture d'un NDA

Ils s'en foutent ils sont riches...