C++ étrange erreur de compilation: erreur: les changements de sens de “l'Objet” de la classe “Objet”

Je ne sais même pas où aller avec cela. Google n'était pas très utile. Comme avec ma question précédente. J'utilise TextMate de Commande+R pour compiler le projet.

jeu.h:16:erreur: la déclaration de ‘Player* HalfSet::Joueur() const’

joueurs.h:11:erreur: les changements de sens de ‘Player’ de ‘Joueur de classe’

jeu.h:21:erreur: "Joueur" n'est pas un type

joueur.h fichier (partielle)

#ifndef PLAYERS_H
#define PLAYERS_H
using namespace std;

#include <string>
#include <vector>
#include <istream>
#include <iomanip>
#include "generics.h"

class Player{ //Line 11
public:
    //getters
    long Id() const;
    string FirstName() const;
    string LastName() const;
    string Country() const;
    //setters
    void setId(long id);
    void setFirstName(string s);
    void setLastName(string s);
    void setCountry(string s);
    //serializing functions
    void display(ostream &out);
    void read(istream &in);
    void write(ostream &out);
    //Initalizers
    Player();
    Player(istream &in);
    Player(string firstName, string lastName);
    Player(string firstName, string lastName, string country);
    Player(long id, string firstName, string lastName, string country);
    ~Player();
private:
    long _id;
    string _firstName;
    string _lastName;
    string _country;
};

jeu.h fichier (partielle)

#ifndef GAME_H
#define GAME_H

#include "generics.h"
#include "players.h"
#include <string>
#include <vector>
#include <istream>
#include <iomanip>

using namespace std;

class HalfSet{
public:
    //getters
    Player* Player() const; //Line 16
    int GamesWon() const;
    int TotalPoints() const;
    int Errors() const;
    //setters
    void setPlayer(Player* p);
    void setGamesWon(int games);
    void setTotalPoints(int points);
    void setErrors(int errors);
    //Serialization
    void display(ostream &out) const;
    void read(istream &in) const;
    void write(ostream &out) const;
    //Initalizers
    HalfSet();
    ~HalfSet();
private:
    Player* _player;
    int _gamesWon;
    int _points;
    int _errors;
};

Ce qui se passe ici?

L'actuel accepté de répondre à cette question est tout simplement faux comme je l'explique dans ma réponse.

OriginalL'auteur epochwolf | 2008-11-12

  1. 16

    En C++, vous ne pouvez pas appeler une fonction de même nom qu'un class/struct/typedef. Vous avez une classe nommée "le Joueur" et si le HalfSet classe a une fonction nommée "le Joueur" ("le Joueur *Joueur()"). Vous avez besoin de renommer l'une de ces (probablement changer HalfSet du Joueur() pour getPlayer() ou somesuch).

    Je vous remercie, mon projet actuellement en train de compiler complètement.
    Bien que vous pouvez, mais pas une fonction membre.
    ::Joueur *Joueur() pour la ligne 16 de corriger ce problème. (comme l'a suggéré b @MSalters)
    Malheureusement, le compilateur Visual C++ vous permet de le faire, de sorte que vous obtenez une mauvaise surprise si lorsque vous essayez de compiler avec g++ quelque chose qui fonctionne sur windows.

    OriginalL'auteur SoapBox

  2. 8

    Votre problème, c'est que les noms sont considérés dans les étendues. Au sein de la déclaration de HalfSet::setPlayer(Joueur*), le nom non qualifié Joueur doit être recherché. La première portée essayé, de la catégorie HalfSet. Dans ce champ d'activité, la recherche de Joueur trouve la fonction HalfSet::Joueur, pas de classe mondiale ::Joueur.

    La solution est d'utiliser un nom qualifié, ::Joueur. Elle indique au compilateur étendue à utiliser pour la recherche (global) qui à son tour signifie HalfSet::le Joueur n'est même pas envisagé.

    OriginalL'auteur MSalters

  3. 5

    L'actuelle réponse à cette question est tout simplement faux, il dit:

    En C++, vous ne pouvez pas appeler une fonction de même nom qu'un class/struct/typedef

    Nom de la dissimulation d'une classe par une fonction est autorisée, si nous allons à la projet de Pré C++11 section 3.3.7 Nom de cacher il dit:

    Un nom de classe (9.1) ou énumération nom (7.2) peuvent être cachés par le nom
    d'un objet, la fonction, ou l'énumérateur déclaré dans le même champ d'application. Si un
    de la classe ou de l'énumération nom et un objet, une fonction ou un agent recenseur sont
    déclaré dans le même champ d'application (dans n'importe quel ordre) avec le même nom, le
    de la classe ou de l'énumération nom est masqué, où l'objet, la fonction, ou
    énumérateur nom est visible.

    Donc le fait que vous avez la fonction et une classe nommée Player n'est pas la question, en fait, le code suivant est valide:

    class Player
{
} ;

Player* Player() ;

    et nous pouvons utiliser un élaboré spécificateur de type de non-cacher le type de classe.

    Aussi loin que je peux dire, c'est la violation de l'article 3.3.6 portée de Classe paragraphe 2 qui dit:

    Un nom N utilisé dans une classe S se réfèrent à la même déclaration dans son
    contexte et lors de la ré-évalué dans le champ d'application de la S. N
    de diagnostic est nécessaire pour une violation de cette règle.

    Donc dans ce cas Player les changements de sens de classe à un fonction, il n'est pas clair pour moi, il a été prévu de manière stricte, mais je peux voir comment cela pourrait se lire de cette façon. Cela semble être le message gcc utilise lorsqu'il détecte cette violation comme on peut le voir à partir d'un question similaire.

    Élaboré à l'aide d'un spécificateur de type empêche le changement de sens:

    class Player* Player() const ;

    OriginalL'auteur Shafik Yaghmour