Je pratique la programmation en mettant en œuvre une structure de données définie en C ++. Je reçois actuellement cette erreur de compilation liée au type de retour d'une fonction étant différente de celle indiquée dans sa déclaration. Le programme compile si je commente J'ai essayé de nombreuses variantes de faire référence au nœud comme Set :: noeud ou juste nœud dans le Fichiers HPP et CPP, mais je ne peux pas sembler le faire fonctionner. P> Je peux résoudre ce problème en ne nidifiant la classe de nœuds à l'intérieur de la classe de jeu, mais je tiens à pratiquer avec des classes imbriquées. p> set.hpp p> Set :: FindsMallest code> qui est défini en bas de set.cpp.
#include <iostream>
#include "set.hpp"
using std::cout;
using std::endl;
Set::Node::Node():value(0){
smallerNode = nullptr;
greaterNode = nullptr;
}
Set::Node::Node(int x):value(x){
smallerNode = nullptr;
greaterNode = nullptr;
}
Set::Set(){
rootNode = nullptr;
nextNode = nullptr;
}
Set::Set(int x){
rootNode->value = x;
nextNode = nullptr;
}
void Set::find(int x){
nextNode = rootNode;
while(1){
if(x == nextNode->value){
cout << x << " found!" << endl;
return;
}
else if(x > nextNode->value){
if(nextNode->greaterNode){
nextNode = nextNode->greaterNode;
}
else {
cout << x << " not found!" << endl;
return;
}
}
else {
if(nextNode->smallerNode){
nextNode = nextNode->smallerNode;
}
else {
cout << x << " not found!" << endl;
return;
}
}
}
}
void Set::insert(int x){
if(!rootNode){
rootNode = new Node(x);
return;
}
nextNode = rootNode;
while(1){
if(x == nextNode->value){
cout << x << " already exists!" << endl;
return;
}
else if(x > nextNode->value){
if(nextNode->greaterNode){
nextNode = nextNode->greaterNode;
}
else {
nextNode->greaterNode = new Node(x);
cout << "inserted " << x << endl;
return;
}
}
else {
if(nextNode->smallerNode){
nextNode = nextNode->smallerNode;
}
else {
nextNode->smallerNode = new Node(x);
cout << "inserted " << x << endl;
return;
}
}
}
}
Node* Set::findSmallest(Node* node){
Node* nextNode = node;
while(1){
if(!nextNode->smallerNode){
return nextNode;
}
else {
nextNode = nextNode->smallerNode;
}
}
}
4 Réponses :
L'erreur ici: p>
est parce que à la place. Ou, en utilisant une fonctionnalité moderne, p>
nœud * SET :: FINDSMALLEST (NODE * NODE) { CODE> P>
nœud code> n'est pas encore dans la portée du moment où il est utilisé comme type de retour. Vous devriez écrire p>
SET :: NODE * SET :: FINSMALLEST (NODE * NODE) { CODE> P>
SET AUTO SET :: WASTSMALLEST (noeud * noeud) -> nœud * { code> p>
Malheureusement, celles qui me donnent tous deux des erreurs sur le type de retour ./ set.hpp: 11: 24: Remarque: Type de 1er paramètre de la déclaration de membre ne correspond pas à la définition ("Node *" VS 'SET :: NODE *') code>
Votre réponse est correcte en supposant que le nœud est déclaré avant de trouver FINSMALLEST dans SET.HPP. Merci pour votre explication.
Il y a deux problèmes syntaxiques:
Le nœud de la classe déclarant avant que vous le faites au début ne va pas se référer comme le type de type :: Node. Le nœud Nom de la classe à l'intérieur de la classe de jeu n'est pas le même que le nœud à l'extérieur. P> li>
Vous pouvez déclarer noeud de classe avant de trouver la déclaration de Maste (P> L>
Vous devez spécifier SET :: Node * En tant que type de retour P> LI> ol>
Set::Node* Set::findSmallest(Node* node){ ...
Merci beaucoup pour cette explication. En tant que débutant, c'était un vrai rayure de tête, mais cela a du sens maintenant.
Pour ajouter à la réponse de @ Numzero, votre déclaration de Vous devez soit définir la fonction après la définition du noeud WindsMalLestNode code> précède la définition du noeud code>, qui vous donnera une erreur. p>
code>, ou renvoyer déclarer
nœud code> dans
définir code>. Notez que la déclaration du noeud
code> en dehors de la classe ne déclare pas em> déclarer le noeud
code> dans la classe. P>
Merci. La déclaration de noeud à terme à l'extérieur de la classe a permis de causer des problèmes. J'avençai que je l'ai déclarée à l'intérieur de l'ensemble, puis j'ai fait le type de retour de FindsMallest de type Set :: Node *. Ceci est très déroutant car le compilateur ne se soucie pas si le paramètre de FindsMallest est défini :: noeud * ou juste noeud *.
Cette déclaration en avant est redondante et n'est pas la même que la déclaration de noeud de classe membre dans la définition du jeu de classe. P> bool Set::find( int x ) const
{
Node *node = rootNode;
while ( node != nullptr && node->value != x )
{
if ( x < node->value ) node = node->smallerNode;
else node = node->greaterNode;
}
return node != nullptr;
}
J'apprécie vraiment la réponse, mais malheureusement, lorsque je supprimais la déclaration en avant, le compilateur se plaint que le nœud utilisé dans la déclaration de FindsMallest est un type inconnu. J'obtiens toujours une erreur sur un type de retour incorrect avec ce changement pour trouver la recherche de Set.cpp
@ Phasor555 Comme j'ai écrit Iin ma réponse n la définition de la fonction que vous devez écrire le type de retour tel que SET :: Node. C'est SET :: NODE * SET :: FINSMALLEST (NODE * NODE) {Placez également une déclaration de noeud en avant dans la définition de la classe. Voir mon poste mis à jour.
Merci pour ton explication.
C'est cristal clair. Vous avez même optimisé le code. Mes compétences C ++ ont nivelé aujourd'hui.
Vous devez déplacer la déclaration d'avenir du noeud code> code> dans la même portée - dans le jeu de classe
code>