0
votes

Le type de valeur de retour ne correspond pas au type de fonction (le type de retour est une classe imbriquée)

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 Set :: FindsMallest code> qui est défini en bas de set.cpp.

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> xxx pré>

set.hpp p>

#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;
        }
    } 
}


1 commentaires

Vous devez déplacer la déclaration d'avenir du noeud dans la même portée - dans le jeu de classe


4 Réponses :


2
votes

L'erreur ici:

nœud * SET :: FINDSMALLEST (NODE * NODE) ​​{

est parce que nœud n'est pas encore dans la portée du moment où il est utilisé comme type de retour. Vous devriez écrire

SET :: NODE * SET :: FINSMALLEST (NODE * NODE) ​​{

à la place. Ou, en utilisant une fonctionnalité moderne,

SET AUTO SET :: WASTSMALLEST (noeud * noeud) -> nœud * {


2 commentaires

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 *')


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.



1
votes

Il y a deux problèmes syntaxiques:

  1. 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>

  2. Vous pouvez déclarer noeud de classe avant de trouver la déclaration de Maste (P> L>

  3. Vous devez spécifier SET :: Node * En tant que type de retour P> LI> ol>

    Set::Node* Set::findSmallest(Node* node){
        ...
    


1 commentaires

Merci beaucoup pour cette explication. En tant que débutant, c'était un vrai rayure de tête, mais cela a du sens maintenant.



1
votes

Pour ajouter à la réponse de @ Numzero, votre déclaration de WindsMalLestNode précède la définition du noeud , qui vous donnera une erreur.

Vous devez soit définir la fonction après la définition du noeud , ou renvoyer déclarer nœud dans définir . Notez que la déclaration du noeud en dehors de la classe ne déclare pas déclarer le noeud dans la classe.


1 commentaires

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 *.



1
votes

Cette déclaration en avant xxx pré>

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;
}    


4 commentaires

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.