C++ Insertion d'une classe dans un plan contenant

J'ai une carte en C++ et je voudrais d'entrée de ma classe en tant que valeur, et une chaîne de caractères comme la clé.
Quand j'essaie, je reçois une erreur 'Scene_Branding' : illegal use of this type as an expression
Je reçois une utilisation illégale de ce type comme expression, et je n'arrive pas à trouver pourquoi. Voici un peu de code.

 string CurrentScene = "Scene_Branding";
 map<string, Scene> Scenes;
 Scenes.insert(std::make_pair("Scene_Branding", Scene_Branding));  //<-- Illegal Error parameter 2

et voici la Scène de l'image de Marque de l'en-tête..

#ifndef Scene_Branding_H
#define Scene_Branding_H

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


class Scene_Branding : Scene
{
public:
 Scene_Branding();
 ~Scene_Branding();
 void Draw();
};

#endif

et voici la Scène de l'en-tête..

#ifndef Scene_H
#define Scene_H

#include <iostream>
#include <string>

class Scene
{
public:
 Scene();
 ~Scene();
 virtual void Draw();

};

#endif

et voici là fichiers cpp.

Scène du rpc.

#include "Scene.h"

Scene::Scene()
{

}
Scene::~Scene()
{

}
void Scene::Draw(){
 std::cout << "Hey";
}

Scene_Branding rpc

#include "Scene_Branding.h"

Scene_Branding::Scene_Branding()
{

}

Scene_Branding::~Scene_Branding()
{

}

void Scene_Branding::Draw()
{
 std::cout << "Drawing from Scene_branding";
}

les deux réponses sont correctes, en soulignant que, vous avez besoin d'une instance de Scene_Branding non seulement par le type. une allusion plus faire de votre destructeur de la classe de base virtuelle
Pensez-vous vraiment dire à l'usage privé de l'héritage?

OriginalL'auteur Fouf | 2010-02-17

c++class inheritance map

16

Tout d'abord, ne pas stocker les objets eux-mêmes dans la carte, stocker des pointeurs vers les objets.

Deuxièmement, vous avez besoin de donner un exemple de Scene_Branding à std::make_pair, pas la classe elle-même.

EDIT:
Voici comment vous allez sur le stockage des pointeurs:
```
 string CurrentScene = "Scene_Branding";
 map<string, Scene*> Scenes;
 Scenes.insert(std::make_pair("Scene_Branding", new Scene_Branding()));
```
Mais, puisque vous avez posé ce type de question, je vous recommande de lire une bonne c++ livre pour plus de saisir des concepts comme des pointeurs.

Le stockage d'objets est très bien aussi longtemps que la classe de l'objet est définitive.
Aha, j'ai essayé ceci, mais j'avais tort de placer Scene_Branding .. de toute façon, merci.

OriginalL'auteur erelender
6

Essayer:
```
Scenes.insert(std::make_pair("Scene_Branding", Scene_Branding()));
```
Me battre pour elle!!
Cela fonctionne, mais le code n'est pas comme prévu et le cout est de la sortie Hey, et pas de Dessin de Scene_Branding.. hmm mais merci pour la correction.
C'est parce qu'une instance de la Scène est stocké dans la carte, et non une instance de Scene_Branding. Ceci est appelé l'objet de découpage, brièvement, elle vous fait perdre de l'information déclarée dans Scene_Branding. Stocke des pointeurs ne sera pas causer ce problème.
Comment puis-je transmettre un pointeur? Me semble que je viens d'obtenir des erreurs comme erreur C2664: 'la Scène::Scène(const Scène &)' : impossible de convertir le paramètre 1 de 'Scene_Branding (__cdecl *const )(void)' à 'const Scène &"
-1 en raison de découpage bug. Je pense que vous ne voyez pas que l'OP veut un conteneur d'objets polymorphes. 🙂

OriginalL'auteur Alexander Gessler
2

Je pense que vous ne voulez pas le faire.
1. il n'y a pas de runtime type de cartographie en C++, vous stockez des objets, pas des types.
2. vous ne pouvez pas stocker des types polymorphes dans des conteneurs STL, utilisez boost::ptr_map à la place si c'est votre souhait
Donc, le "nouveau" code:
```
class Scene
{
public:
  virtual ~Scene();                  //Virtual Destructor, it's a base class
  virtual Scene* clone() const = 0;  //Polymorphic construction
private:
  //whatever you wish
};

class Scene_Branding: public Scene
{
public:
  virtual Scene_Branding* clone() const { return new Scene_Branding(); }
};
```
Et la nouvelle façon de stocker ces:
```
const std::string SceneBrandingKey = "Scene_Branding";

typedef boost::ptr_map<std::string, Scene> scenes_type;

scenes_type Scenes;
Scenes.insert(SceneBrandingKey, new Scene_Branding());
```
Et vous pouvez l'utiliser ainsi:
```
Scenes["Scene_Branding"].process(); //Note: use '.' not '->'
```
La bonne chose à propos Boost Pointeur De Conteneur est qu'il a été censé pour polymorphes types, à l'exception de la sécurité et de tous, et pourtant imite le comportement /l'interface de la STL, de sorte que vous n'êtes pas perdu 🙂

Je pense que l'OP est un peu newbie à être plongée dans boost encore.
Je ne suis pas sûr, mais à mon humble avis, au lieu de virtuel Scene_Branding* clone() const il convient de Scène virtuelle* clone() const 😉
C'est drôle comment tout le monde pense que C++ les débutants ont besoin d'apprendre à faire les choses le risque d'erreur de façon manuelle, avant d'utiliser les bibliothèques qui rendent la vie plus facile.
+1 Après l'OP apprend à connaître les pièges du manuel de gestion de la mémoire, il/elle pourra apprécier shared_ptr et ptr_container.
Bien sûr, les choses qui rendent la vie plus facile sont mieux, mais, pour une utilisation à haut niveau de stuff efficacement, il faut comprendre le faible niveau de stuff, vous ne pensez pas? Ne pas donner une lamborghini à un nouveau pilote.

OriginalL'auteur Matthieu M.
0

Vous avez besoin de pointeurs dans la classe lors de l'utilisation générique de la carte des conteneurs d'autre, le résultat est possible qu'un nouvel objet vide de votre classe... avec des pointeurs fonctionne!
```
std::map<std::string, Type*> map_;
```
Insérer
```
map_["key"] = *Type;
```
REMARQUE: si -fpermisive drapeau à compilateur n'est pas définie, vous devez passer *Type non const lors de l'insérer dans le map_ conteneur.

Cordialement,

Javier,

OriginalL'auteur Javier Gutiérrez-Maturana Sánc

Vous devez vous connecter pour publier un commentaire.

Insérer