Bonjour, je rencontre actuellement un problème concernant une erreur d'opérande. En effet j'essaye de comparé une valeur qui sera entré dans la méthode avec valeur déjà présente dans mon tableau.
PS: on ne rappelle pas le nom de la classe dans les définitions de fonctions réalisées à l'intérieur des définitions de classes. Il y a des compilos qui râlent violemment là dessus.
PS: on ne rappelle pas le nom de la classe dans les définitions de fonctions réalisées à l'intérieur des définitions de classes. Il y a des compilos qui râlent violemment là dessus.
Que voulez-vous dire par balise </> ? Le C++ n'est pas censé disposer de balise, je ne comprends pas..
#pragma once
#include <iostream>
#include "Pomme.h"
#include <array>
#include "stdafx.h"
class TableauStockage
{
public:
TableauStockage();
void Ajoute(Pomme unePomme);
void Ajoute(Pomme unePomme, int position);
int GetPosition(Pomme unePomme);
Pomme GetObjet(int position);
void Enlever(int position);
int Taille();
private:
array<Pomme, 30> cageot;
};
le .cpp :
#include "stdafx.h"
#include <iostream>
#include "TableauStockage.h"
#include "Pomme.h"
#include <array>
using namespace std;
TableauStockage::TableauStockage()
{
}
void TableauStockage::Ajoute(Pomme unePomme)//Ajoute une Pomme au dernier emplacement du cageot
{
for (int i = 0; i > 0; i--)
{
if (&cageot[i] == NULL)//Si le dernier emplacement du cageot est vide alors on le rempli, sinon on passe à l'emplacement précédent et on fait la même vérification
{
cageot[i] = unePomme;
break;
}
else if (i < 0)//Sinon si le cageot est plein, prévenir l'utilisateur
{
cout << "Cageot plein" << endl;
}
}
}
void TableauStockage::Ajoute(Pomme unePomme, int position)//Ajoute une Pomme au cageot à une certaine position donnée
{
if (&cageot[position] != NULL)//Si la position est déjà prise, prévenir l'utilisateur
{
cout << "Il y a déjà une pomme à cette emplacement" << endl;
}
else//Sinon insérer la pomme
{
cageot[position] = unePomme;
}
}
int TableauStockage::GetPosition(Pomme unePomme)//Retourne la position où se situe la pomme
{
for (int i = 0; i < 30; i++)
{
if (unePomme == cageot[i])
{
return i;
}
}
}
void TableauStockage::Enlever(int position)//Supprime la pomme dans la position
{
cageot[position] = NULL;
}
- Edité par MerwanZeggai 15 octobre 2018 à 13:28:49
Tu stockes les Pommes par valeur et tu fais intervenir des pointeurs à tour de bras.
Si tu choisis les valeurs, alors il te faut stocker le nombre d'éléments effectifs (size() chez std::vector) qui se distingue de la capacité de ta cagette (std::vector::capacity()). Mais il y a un non soucis, il faut quelque part prévoir une pomme qui soit une non-pomme. Il serait plus pertinent d'avoir une cagette de std::array<std::optionnal<Pomme>> (C++17 requis)
Ou alors, si tu choisi les valeurs, il faut à la place utiliser un conteneur qui permettre véritablement de retirer des pommes: std::vector<Pomme>.
Si tu choisis les pointeurs, alors, c'est std::array<std::unique_ptr<Pomme>> qu'il faudrait employer, ou mieux std::vector<std::unique_ptr<Pomme>> vu que tu as besoin de flexibilité dans le nombre d'éléments.
Au vu du code, je soupçonne des choix bizarres dans l'énoncé de l'exo qui pousse à faire des trucs compliqués que l'on cherche à éviter de voir dans du vrai code.
A la rigueur j'ai déjà défini la capacité de la cagette, qui est de 30. De plus les pointeurs me permettent d'effectuer la comparaison avec NULL vu que je vérifie la case mémoire.
Je dispose aussi de la méthode permettant de supprimer la pomme de la position.
La question est donc, cela est-il fonctionnel pour ce que je cherche à faire et s'il y a un moyen de régler ce problème d'opérandes ?
Et si je peux me permettre d'être plus pertinent sur mon programme, voici le .h ainsi que le .cpp de Pomme :
#pragma once
#include <iostream>
#include "stdafx.h"
class Pomme
{
public :
Pomme();
Pomme(std::string couleur, int taille, bool estAcide);
private :
std::string m_couleur;
int m_taille;
bool m_estAcide;
};
J'ai trouvé un moyen d'effectuer la comparaison sans utiliser NULL, néanmoins je n'arrive toujours pas à régler ce problème d'opérande. Cela m'empêche d'effectuer mes conditions et je ne vois réellement pas ce qui m'empêche de les effectuer...
Voici ce que j'ai effectué :
#pragma once
#include <iostream>
#include "Pomme.h"
#include <array>
#include "stdafx.h"
class TableauStockage
{
public:
TableauStockage();
void Ajoute(Pomme unePomme);
void Ajoute(Pomme unePomme, int position);
int GetPosition(Pomme unePomme);
Pomme GetObjet(int position);
void Enlever(int position);
int Taille();
private:
Pomme m_vide;
array<Pomme, 30> cageot;
};
#include "stdafx.h"
#include <iostream>
#include "TableauStockage.h"
#include "Pomme.h"
#include <array>
using namespace std;
TableauStockage::TableauStockage()
{
for (int i = 0; i < cageot.size(); i++)
{
cageot[i] = m_vide;
}
}
void TableauStockage::Ajoute(Pomme unePomme)//Ajoute une Pomme au dernier emplacement du cageot
{
for (int i = 30; i > 0; i--)
{
if (cageot[i] == m_vide)//Si le dernier emplacement du cageot est vide alors on le rempli, sinon on passe à l'emplacement précédent et on fait la même vérification
{
cageot[i] = unePomme;
break;
}
else if (i < 0)//Sinon si le cageot est plein, prévenir l'utilisateur
{
cout << "Cageot plein" << endl;
}
}
}
void TableauStockage::Ajoute(Pomme unePomme, int position)//Ajoute une Pomme au cageot à une certaine position donnée
{
if (cageot[position] != m_vide)//Si la position est déjà prise, prévenir l'utilisateur
{
cout << "Il y a déjà une pomme à cette emplacement" << endl;
}
else//Sinon insérer la pomme
{
cageot[position] = unePomme;
}
}
int TableauStockage::GetPosition(Pomme unePomme)//Retourne la position où se situe la pomme
{
for (int i = 0; i < 30; i++)
{
if (unePomme == cageot[i])
{
return i;
}
}
}
void TableauStockage::Enlever(int position)
{
cageot[position] = m_vide;
}
Tu n'as pas d'opérateur == pour Pomme, il faudrait en définir un si tu veux comparer tes pommes.
Mais est-ce que cela a un sens ? Si tu as 2 pommes de meme couleur, de meme taille et de meme acidité, est-ce que tu peux alors dire que tu as une seule pomme ? A priori, non, cela n'a pas de sens.
Donc ton approche avec m_vide ne fonctionne pas.
(Tu es dans un problème bien connu, dont on parle souvent sur ce forum : les sémantiques de valeur et d'entité. Ici, même si 2 pommes ont exactement les mêmes caractéristiques, cela reste 2 objets distincts. Donc ce sont des entités, par des valeurs. Et l'opérateur == n'a pas de sens).
Il y a plusieurs approches possibles, qui ont été données par lmghs (array+capacity, vector, array+unique_ptr).
Je laisse à mes VDD les aspects purement C++ et POO.
Je me charge des spécificités MSVC qui auront un impact quand vous aurez un peu progressé pour les autres aspects.
VIREZ-MOI CES PUTAINS DE "stdafx.h" DES HEADERS, BORDEL.
Si vous ne maitrisez pas bien les precompiled headers, ne les utilisez pas, donc supprimez-les aussi des .cpp et changez la configuration du projet pour ne plus vous en servir.
Je recherche un CDI/CDD/mission freelance comme Architecte Logiciel/ Expert Technique sur technologies Microsoft.
Erreur Opérandes
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Discord NaN. Mon site.
Discord NaN. Mon site.
Discord NaN. Mon site.