dynamisk class

Nu har jeg ikke selv særlig stor erfaring med C++, men jeg tror seriøst det vil blive noget rod, og enda svær at overskue til sidst.

Såvidt jeg ved understøtter C++ ikke programmering af den slags. Det gør de fleste kompilerede sprog vidst ikke engang. Jeg ved Ruby understøtter det du leder efter, men det er et scriptsprog.

Du kan gøre noget i stil med:

#include <map>
#include <iostream>
#include <string>
using std::map;
using std::string;
using std::cout;
using std::endl;

class Ansat
{
public:
   map<string, string> Attribute;
};

int main()
{
   Ansat ansat;
   ansat.Attribute["Navn"] = "Poul Jensen";
   ansat.Attribute["Løn"] = "123.32";
   map<string, string>::iterator it;
   for(it = ansat.Attribute.begin(); it != ansat.Attribute.end(); ++it)
      cout << it->first << ": " << it->second << endl;
   cout << endl;
   ansat.Attribute["Adresse"] = "Jernbanegade 123";
   for(it = ansat.Attribute.begin(); it != ansat.Attribute.end(); ++it)
      cout << it->first << ": " << it->second << endl;
}

Her er alle værdierne af type std::string. Man kan godt give dem forskellige typer, hvilket kan gøres ved at lave en container der kan indeholde alle typer.

Et stykke nede på denne side:
http://damb.dk/container.php

Viser jeg hvordan det kan gøres.

Tak for de hurtige svar!
Bertel Brander din brug af maps gav mig en idé. Jeg har lavet en klasse som man kan putte data members og member functions ind i, efter klassen er lavet. Det er dog et par problemer og det bliver meget rodet. De problemer er umiddelbart kan se er:
-At adressere (hedder det det) tilføjne data members i tilføjne member functions.
-At adressere tilføjne member functions i andre tilføjne member functions.
-At frigive data members, dette er et problem da de er tilføjet som void* pointers (deres type er ukendt) og derfor ikke umiddelbart kan slettes.
Så tror jeg at jeg har taget mine forholdsregler , her er klassen: (jeg har kommenteret på engelsk - det virker mere naturligt)

#include <map>

using namespace std;

typedef void(*fPtr)();

class DynamicClass
{
public:

    //add a new data member
    void addDataMember(char* name, void* data)
    {
        DataMembers[name] = data;
    }

    //add a new member function
    void addMemberFunction(char* name, void(*function)())
    {
        MemberFunctions[name] = function;
    }

    //get a data member from its name
    void* getDataMember(char* name)
    {
        map<char*,void*>::iterator iter = DataMembers.find(name);
        return iter->second;
    }

    //get a member function from its name
    void (*getMemberFunction(char* name))()
    {
        map<char*,fPtr>::iterator iter = MemberFunctions.find(name);
        return iter->second;
    }

    //the maps that holds the pointers
    map<char*, void*> DataMembers;
    map<char*, fPtr> MemberFunctions;

};

Og her er den i aktion

void function(int number)
{
    cout<<"Test Function says: "<<number<<endl;
}

int main()
{
    //create the class
    DynamicClass *dc = new DynamicClass;

    //add a data member (a int - value 23)
    dc->addDataMember("Alder", new int(23));

    //get the added data member out of the class
    int Alder = *(int*)dc->getDataMember("Alder");

    //print it out
    cout<<Alder<<endl;

    //add a member function
    dc->addMemberFunction("Function", (fPtr)function);

    //get the member function out of the class
    void (*fTest)(int) = (void(*)(int))dc->getMemberFunction("Function");

    //run the member function
    fTest(4);

    //delete a data member
    delete (int*)dc->getDataMember("Alder");
    dc->DataMembers.erase("Alder");

    return 0;
}

Hvis i har en bedre idé vil jeg meget gerne hører fra jer!
Jeg elsker at pudsle med den slags ting!

Hvis i har en bedre idé vil jeg meget gerne hører fra jer!
Jeg elsker at pudsle med den slags ting!

Du kan eventuelt udvide din datamodel og inkludere typen også. Dvs. både typen på dine metaobjekter og typen på dine medlemsvariable. Herudover kan du indtænke en automatisk persistering af dine objekter, så de automatisk bliver gemt i fx en database, fladfil eller lign.

Hth.

Du kan eventuelt udvide din datamodel og inkludere typen også.

Jeg er ikke helt sikker på hva du mener her, men jeg har prøvet at gøre følgende uden held.

tempalte<class T>
map<char*, T> DataMembers;

dette giver følgende compiler error:

data member 'DataMembers' cannot be a member template

Jeg har altid syntes at templates er onde så har aldrig brugt dem.

Hva gør jeg galt her?

Som den siger kan man ikke bruge templates på den måde.

For at slippe for de mange cast her og der kan du pakke det hele lidt ind:

#include <map>
#include <iostream>
#include <string>

using std::map;
using std::string;
using std::cout;
using std::endl;
using std::ostream;

class Member
{
   enum Type
   {
      IntType, DoubleType, StringType, UndefinedType
   };
   Type MyType;
   union Data
   {
      int Int;
      double Double;
      string* String;
   };
   Data MyData;

public:
   Member(const Member& aOther) : MyType(aOther.MyType)
   {
      switch(MyType)
      {
      case IntType:
         MyData.Int = aOther.MyData.Int;
         break;
      case DoubleType:
         MyData.Double = aOther.MyData.Double;
         break;
      case StringType:
         MyData.String = new string(*aOther.MyData.String);
         break;
      case UndefinedType:
         MyData.String = 0;
         break;
      }
   }
   Member& operator = (const Member& aOther)
   {
      MyType = aOther.MyType;
      switch(MyType)
      {
      case IntType:
         MyData.Int = aOther.MyData.Int;
         break;
      case DoubleType:
         MyData.Double = aOther.MyData.Double;
         break;
      case StringType:
         MyData.String = new string(*aOther.MyData.String);
         break;
      case UndefinedType:
         MyData.String = 0;
         break;
      }
      return *this;
   }
   Member() : MyType(UndefinedType)
   {
      MyData.String = 0;
   }
   Member(int aValue) : MyType(IntType)
   {
      MyData.Int = aValue;
   }
   Member(double aValue) : MyType(DoubleType)
   {
      MyData.Double = aValue;
   }
   Member(const char* aValue) : MyType(StringType)
   {
      MyData.String = new string(aValue);
   }
   ~Member()
   {
      if(MyType == StringType)
         delete MyData.String;
   }
   friend ostream& operator << (ostream& os, const Member& aMember);
};

ostream& operator << (ostream& os, const Member& aMember)
{
   switch(aMember.MyType)
   {
   case Member::IntType:
      os << aMember.MyData.Int;
      break;
   case Member::DoubleType:
      os << aMember.MyData.Double;
      break;
   case Member::StringType:
      os << *aMember.MyData.String;
      break;
   case Member::UndefinedType:
      os << "Did not expect to print undefined types!";
      break;
   }
   return os;
}

class Ansat
{
public:
   map<string, Member> DataMembers;
};

int main()
{
   Ansat ansat;
   ansat.DataMembers["Navn"] = "Poul Jensen";
   ansat.DataMembers["Løn"] = 123.32;
   ansat.DataMembers["Alder"] = 42;
   map<string, Member>::iterator it;
   for(it = ansat.DataMembers.begin(); it != ansat.DataMembers.end(); ++it)
      cout << it->first << ": " << it->second << endl;
   cout << endl;
   ansat.DataMembers["Adresse"] = "Jernbanegade 123";
   for(it = ansat.DataMembers.begin(); it != ansat.DataMembers.end(); ++it)
      cout << it->first << ": " << it->second << endl;
}

Mange tak for det udførlige svar! Det var nu ikke så meget de definerede typer jeg havde tænkt mig at bruge i klassen (int, double, string og dem). Jeg ville bruge classen til mine egne klasser. Men jeg har fundet ud af at ikke er særlig brugbart når det kommer til stykket. Man tak for svaret!!

Du kan gøre det på samme måde som med std::string i mit eksempel.

Det kan godt gøres brugbart ved at pakke det pænt ind i en class.