[C++] Costruttori di classi

[oni305]

Ho un problema a cui non riesco a trovare soluzione stò cercando di creare una MAP che contenga da una parte una stringa e dall'altra una Classe, e fin qui nessun problema, ma però non capisco come poter inserire al posto della classe normale, una sua sottoclasse...


quando eseguo l'assegnamento con la classe principale, funziona tutto egregiamente

Map_of_Param["ciao 1"] = Param("1a","1b",1);

invece se tento ad usare una sottoclasse classe mi dice : " 'Param_bool' was not declared in this scope "

Map_of_Param["ciao 1"] = Param_bool("1a",false,"1b",1);

non capisco perchè...

Qui vi metto il codice delle due classi:
Param.H

#ifndef PARAM_H_
#define PARAM_H_
#include <string>
using namespace std;
class Param
{
private:
string key;
string type;
float weight;
public:
Param();
Param(string _key,string _type,float _weight);
void set_key(string _key);
void set_type(string _type);
void set_weight(float weight);
string get_key();
string get_type();
float get_weight();
virtual float similarity(Param &p);
virtual string get_string_value();
};
#endif /*PARAM_H_*/

Param.CPP

#include "param.h"
Param::Param()
{
}

Param::Param(string _key,string _type,float _weight)
{
key=_key;
type=_type;
weight = _weight;
}

void Param::set_key(string _key)
{
key=_key;
}

void Param::set_type(string _type)
{
type=_type;
}
void Param::set_weight(float _weight)
{
weight=_weight;
}
string Param::get_key()
{
return key;
}

string Param::get_type()
{
return type;
}
float Param::get_weight()
{
return weight;
}

float Param::similarity(Param &p)
{
return 1;
}

string Param::get_string_value()
{
return "";
}

Param_bool.H

#ifndef PARAM_BOOL_H_
#define PARAM_BOOL_H_

#include "param.h"
#include "util.h"

class Param_Bool : public Param
{
public:
bool value;
Param_Bool();
Param_Bool(string _key,bool _value,string _type,float _weight);
~Param_Bool();
virtual float similarity(Param &p);
virtual string get_string_value();

};
#endif /*PARAM_INT_H_*/

Param_bool.CPP

#include "param_bool.h"

Param_Bool::Param_Bool():
Param()
{
value = false;
}

Param_Bool::Param_Bool(string _key,bool _value,string _type,float _weight):
Param(_key,_type,_weight)
{
value = _value;
}

Param_Bool::~Param_Bool()
{

}

float Param_Bool::similarity(Param &p)
{
return (value==dynamic_cast<Param_Bool*>(&p)->value);
}

string Param_Bool::get_string_value()
{
return (value)?"true":"false";
}

ah ed un altra domanda, per ora la map è definita così:
map<string,Param> Map_of_Param;

Se la volessi definire map<string,Param*> Map_of_Param;
nell'assegnazione del valore Map_of_Param["ciao 1"] = Param("1a","1b",1); cosa dovrei cambiare?


Se può servire, compilo sotto Win e uso Dev-C++

[metal_prog]

Se non sbaglio una classe derivata da un'altra vengono passati solo i metodi ed attributi contenuti public e protected, ma non quelli privati.

Inoltre (sperando di non dire stupidate ) ogni costruttore dovrebbe essere di un'unica classe e non penso venga importato, sarebbe più semplice creare un metodo a se che viene richiamato nei costruttori.

Scusatemi se nel caso abbia detto cose inappropriate.

[oni305]

mi sono arrangiato ed ho trovato le soluzione :

map<string,Param*>;

Param*PB = new Param_Bool();

Map_of_Param["ciao 1"] = PB;

[metal_prog]

Ma non avevi creato un ogetto?