C++ creare instanze di oggetti dalla stringa del nome della classe

[Morpheus_/_Neo]

ciao a tutti.

come da titolo, vorrei sapere se in c++ e' possibile creare un'istanza di oggetto di una classe NOME_CLASSE avendo solo la stringa "NOME_CLASSE".

mi spiego meglio. In Java esiste il metodo statico newInstance(string X) che crea un oggetto di tipo X e ritorna una referenza di tipo Object che punta all'istanza creata. Vorrei sapere se esiste in c++ qualcosa di analogo per creare oggetti a runtime senza conoscerne la classe a design time.

grazie a tutti
M_/_N

[cionci]

Che io sappia non c'è...in primo luogo perchè non tutti gli oggetti derivano da un oggetto base...

Fai una cosa di questo tipo...ti crei un oggetto base per tutti i tuoi tipi di oggetti (suppongo che gli oggetti che vuoi instanziare siano oggetti personalizzati)...

class classe_base //classe base astratta
{
public:
classe_base() {}; //costruttore di default
virtual string tipo_classe() = 0; //funzione virtuale pura
};

class classe1: public classe_base //classe derivata da quella base
{
public:
classe1() { };
virtual string tipo_classe() { return "classe1"; };
};

class classe2: public classe_base //classe derivata da quella base
{
public:
classe2() { };
virtual string tipo_classe() { return "classe2"; };
};


//in oggetto è contenuto il tipo di oggetto da instanziare

classe_base *nuovo = NULL;

if(oggetto == "classe1") nuovo = new classe1;
if(oggetto == "classe2") nuovo = new classe2;

Il comportamento è simile a quello che cercavi...ma devi stare attento all'interfaccia... Se l'interfaccia è comune per tutte le classi e dichiari tutte le funzioni come viertuali nella classe base allora potrai usare indistintamente le classi a partire dalla classe base. Se non è così devi riconoscere se una istanza è quella dalla classe da te voluta tramite la funzione tipo_classe e poi fare un cast alla classe voluta...
Ad esempio:

if(obj->tipo_classe == "classe1")
((classe1 *)obj)->funzione_della_classe1(.....);
if(obj->tipo_classe == "classe2")
((classe2 *)obj)->funzione_della_classe2(.....);

[fek]

ciao a tutti.

come da titolo, vorrei sapere se in c++ e' possibile creare un'istanza di oggetto di una classe NOME_CLASSE avendo solo la stringa "NOME_CLASSE".

mi spiego meglio. In Java esiste il metodo statico newInstance(string X) che crea un oggetto di tipo X e ritorna una referenza di tipo Object che punta all'istanza creata. Vorrei sapere se esiste in c++ qualcosa di analogo per creare oggetti a runtime senza conoscerne la classe a design time.

grazie a tutti
M_/_N

Quello che cerchi di fare si chiama Reflection ed e' un concetto nativo di piattaforme quali Java e .NET (C# e parenti), oppure di linguaggi dinamici tipo Smalltalk, Python, Ruby.

Il C++ non supporta Reflection nativamente, e bisogna programmarsela a mano.
Cionci ti ha gia' indicato un modo per programmare quello che vuoi fare, che va benissimo se hai poche classi. Se il tuo sistema ha bisogno di supportare molte piu' classi, ti serve qualcosa di piu' flessibile, ma fino a quel momento l'implementazione di Cionci va benissimo.

Se ci dici con piu' precisione quello che vuoi fare possiamo esserti piu' di aiuto e magari indicarti implementazioni piu' flessibili (e complesse) se necessario.

[Morpheus_/_Neo]

instanto grazie a tutti e due!

vediamo allora di porre il vero problema che devo risolvere...

ho N processi (che chiamero' MONITORATI) i quali danno in output degli oggetti di tipo ignoto a prori. Ho inoltre un processo MONITOR che si aggancia agli N monitorati tramite mem condivisa e deve estrarre gli oggetti che ogni processo da' in output.

ora di processi monitor ne posso avere M, ognuno in ascolto su gruppi eterogenei di processi, e non so a priori l'interfaccia dell'output proprio perche' ogni processo monitorato e' indipendente dagli altri mentre io voglio un processo monitor generalizzato.

tra le varie cose mi era venuto in mente il discorso di creare oggetti dalla stringa della loro classe, ma per il momento mi sto orientando verso qualcosa di molto piu a basso livello: leggere la mem condivisa byte a byte e interpretare e ricomporre i byte in base alle info pubblicate in un file. tali info descrivono per ogni processo il tipo e la disposizione delle variabili date in output (questo almeno devo saperlo a priori).

ecco qua il vero problema :-) se qualcuno ha qualche idea brillante... beh, intanto si becca un GRAZIE maiuscolo :-D

ciao e grazie ancora
M_/_N

[cionci]

Ma i processi monitorati li fai tu ?

[fek]

ora di processi monitor ne posso avere M, ognuno in ascolto su gruppi eterogenei di processi, e non so a priori l'interfaccia dell'output proprio perche' ogni processo monitorato e' indipendente dagli altri mentre io voglio un processo monitor generalizzato.

Agli oggetti restituti da ogni processo puoi mandare messaggi e fargli compiere operazioni, oppure devi solo interrogarli per conoscerne le proprieta'?

Espando un po' la domanda di Cionci:
Quanti tipi diversi di processi hai? Prevedi di aggiungere in seguito altri tipi di processi? Puoi fare a meno di doverne aggiungere altri in seguito, quanto meno nella prima versione del tuo programma?

Riesci facilmente ad estrarre un'interfaccia comune a tutti i tipi di oggetto restituiti processi? Se no puoi cambiare leggermente le specifiche di modo da riuscirci?

In base alle risposte che dai, io avrei in mente un paio di soluzioni diverse.

[Morpheus_/_Neo]

allora, il problema e' proprio che i processi da monitorare non sono sviluppati ne specificati da me. io devo prenderli cosi come sono e leggerne l'output senza potergli far fare niente (i processi comunicano tra loro e il monitor deve essere il piu trasparente possibile per tali processi).

i processi dovrebbero essere 10 o 12 in un ambiente distribuito per cui ci sara' un monitor per macchina e ogni monitor sara' responsabile per un numero ignoto a priori di processi. inoltre ci sara' un monitor centralizzato che raccoglie le informazioni prelevate e inviategli dai singoli monitor dislocati sulle singole macchine.

non ho idea di cosa i vari processi daranno in output... so che saranno cose tipo array di double, matrici di int o double o numeri complessi (ma spero di no), ma purtroppo l'organizzazione del progetto fa talmente schifo che non posso escludere a priori che i processi scambino oggetti complessi... non so neanche che variabili elementari useranno... e i monitor devono essere general-purpose a sufficienza da fregarsene del processo specifico che stanno monitorando (potranno solo leggere da qualche parte una qualche descrizione dell'output del processo monitorato, ma ogni monitor avra' in carico piu' di un processo alla volta, e quindi non posso fare un monitor specifico per ogni processo... anche perche' diventerei stupido...). inoltre poiche' questi processi devono controllare un veicolo privo di pilota, hanno necessita' real time tali da non permettermi di fare grossi magheggi, quindi ho bisogno di roba leggera e veloce...

grazie mille a tutti per la disponibilita', davvero!
M_/_N

[fek]

Cerco di riassumere le specifiche per quello che ho capito:

1) Il monitor deve leggere dati dagli oggetti processi
2) Il monitor non deve dare comandi agli oggetti processi
3) La descrizione dei dati associati ad ogni tipo di oggetto processo e' contenuta in un qualche formato che e' disponibile
4) I tipi dei dati possono essere potenzialmente qualunque (nativi o complessi)
5) Il monitor deve essere abbastanza generico da gestire oggetti processo con tipi di dato differenti

Date le specifiche, il tuo problema e' un bel casino :)
Io cercherei di semplificarlo un po', inserendo qualche limitazione, ad esempio al punto 4). Se sei in grado di limitare i tipi dei dati, la soluzione al tuo problema diventa piuttosto semplice, un dizionario chiave/valore in cui organizzare i dati dei processi. La descrizione del dizionario e' contenuta nel file di descrizione.

Se non puoi mettere limiti ai tipi di dato, il tuo problema diventa molto complicato da risolvere in un linguaggio tipo C++ che non ha il concetto di "tipo dinamico".

Vedi se riesci a mettere una qualche limitazione al punto 4 e poi dimmi.

[Morpheus_/_Neo]

grazie mille ragazzi, davvero!

dunque ammesso e non concesso che io riesca a limitare il tipo di dati scambiati ai soli tipi elementari (int, double, array e matrici di int o di double), la soluzione che mi viene in mente e' leggere l'area di memoria condivisa byte a byte e poi ricomporre i byte secondo le info pubblicate che descrivono la struttura delle variabili nell'area di mem stessa. e' una buona soluzione o si puo' fare di meglio?

grazie di cuore a tutti
M_/_N