Programmieren - alles kontrollieren 4.941 Themen, 20.715 Beiträge

variable Menge inform einer Klasse in C++

JeromeB / 5 Antworten / Baumansicht Nickles

Hallo erstmal.


Ich muss für einen Programmentwurf 2 variabel große Mengen in Form von Klassen definieren (in C++).


Leider hab ich keine Idee wie das gehen soll und komme somit zu keinem Ergebnis. Die Sache ist auch recht dringend und ich würde mich sehr sehr freuen wenn sich hier jemand bereiterklären würde mir dabei zu helfen, inform des Quelltextes.


Vielleicht hat ja auch jemand ein Programm in dem er das schonmal gemacht hat.


Vielen vielen Dank an alle Helfer.


Ciao, Jerome.....(Jerome2000@gmx.de)

bei Antwort benachrichtigen
mr.escape JeromeB „variable Menge inform einer Klasse in C++“
Optionen

Auch wenn die fragestellung sehr unscharf ist, könnte evtl. so etwas gemeint sein:

class MyClass {

int n, *speicher;//anzahl der möglichen einträge und adresse des speichers
public:
MyClass(){speicher=NULL;n=0;}
MyClass(int count){speicher=new int[n=count];}//hier noch fehler behandeln
~MyClass(){if(speicher) delete[] speicher;}
int Read(int i){if(speicher && i>=0 && i<n) return speicher[i]; else return 0;}
void Write(int i, int v){if(speicher && i>=0 && i<n) speicher[i]=v;}//evtl. alten wert zurückgeben
void Alloc(int count){if(speicher) delete[] speicher;speicher=new int[n=count];}//fehlerbehandlung fehlt
int Count(){return n;}
//etc.
};

mit dieser klasse kann man beliebige mengen an gleichartigen daten speichern (hier z.b. int).
Aufruf mit
MyClass var1;//kein speicher allokiert
MyClass var2(100);//speicher für 100 int allokiert
var1.Alloc(100);//speicher für 100 int nachträglich allokiert, vorherigen speicher freigegeben
var1.Write(0, 100);
int i=var1.Read(0);//gibt den ersten wert aus dem speicherblock zurück (hier 100), undefiniert wenn noch unbeschrieben oder 0 wenn unzulässig (kein speicher vorhanden oder ausserhalb der grenzen)

Wird die variable ungültig, wird der speicher automatisch freigegeben.
Hier fehlen noch einige methoden und auch die fehlerbehandlung muss noch besser werden aber das ist eine andere baustelle.

mr.escape

ps.: falls es semikolonmangel gibt, nach geschmack setzen.
"The man who trades freedom for security does not deserve nor will he ever receive either." - Benjamin Franklin"Wer seine Freiheit aufgibt, um Sicherheit zu erreichen, wird beides verlieren." - Georg Christoph Lichtenberg
bei Antwort benachrichtigen
JeromeB mr.escape „Auch wenn die fragestellung sehr unscharf ist, könnte evtl. so etwas gemeint...“
Optionen

die fragestellung war scheinbar wirklich zu ungenau.

also viel von c++ verstehe ich nicht, hatte erst 1 semester... naja, und jetzt dieser programmentwurf...

das ganze soll mit hilfe von konstruktoren geschehen.

also der benutzer gibt ne zahl ein die in seiner menge vorkommen soll und mit hilfe eines konstruktors soll dann ein objekt erstellt werden was dann diese zahl enthält und zu der menge gehört.

naja, und der benutzer soll halt so viele elemente für seine menge eingeben wie er will.

das ganze macht der benutzer für 2 mengen die dann später verglichen werden sollen (schnittmenge, vergleich und anderer funktionen). aber das ist erstmal nebensache...

mein problem liegt darin solch eine klasse zu definieren, oder muß ich vielleicht mehrere klassen definieren? vielleicht eine klasse für jede menge?

bitte antworten und weiterhelfen, danke vielmals...

ciao, jerome.....

bei Antwort benachrichtigen
mr.escape JeromeB „die fragestellung war scheinbar wirklich zu ungenau. also viel von c verstehe...“
Optionen

OK, das sieht nach verketteter liste aus, oder bei eingeschränkten bereichen (werte und/oder anzahl) nach bitarray.
das ganze soll mit hilfe von konstruktoren geschehen.
also der benutzer gibt ne zahl ein die in seiner menge vorkommen soll und mit hilfe eines konstruktors soll dann ein objekt erstellt werden was dann diese zahl enthält und zu der menge gehört.
naja, und der benutzer soll halt so viele elemente für seine menge eingeben wie er will.

Also mit konstruktor UND soviele wie er will, wird nicht ganz trivial sein, den der konstruktor wird nur einmal pro instanz aufgerufen. Das heisst, dass im konstruktor wohl nur ein einziges element angegeben werden kann, alle andere weiteren mit einer extra methode. Für die verschiedenen strategien gibt es in der regel schon standard templates, aber die benutzt man erst, wenn man "ausgelernt" hat. Also muss hier alles zu fuß erledigt werden.
Im ersten fall, d.h. keine begrenzung, bietet sich eine verkettete liste oder ein nachwachsendes array.

class intKettenglied;

class intKettenglied {
public:
int num;
intKettenglied *next;
intKettenglied(){next=NULL;};
~intKettenglied(){if(next) delete next;next=NULL;}//rekursives löschen
};

class intKette {
public:
intKettenglied *glieder;
intKetten(){glieder=NULL;}
intKetten(int z){glieder=NULL;Append(z);}
~intKetten(){if(glieder) delete glieder;glieder=NULL;}
void Append(int z){//element einfügen, sehr simpel; sortiertes einfügen wäre evtl. besser, fehlerbehandlung empfohlen
intKettenglied *neu=new intKettenglied;
neu.num=z;
neu.next=glieder;
glieder=neu;
}
void Sort();//hier eine methode um die liste zu sortieren
//um es nach allen einfügungen für den folgenden vergleich
//leichter zu haben
};

Verwendung z.b.:
intKette kette1(3);//erster wert

kette1.Append(4);//zweiter wert
kette1.Append(7);//dritter
kette1.Append(1);//vierter
...
kette1.Sort();
intKette kette2(7);//erster wert
kette2.Append(6);//zweiter wert
kette2.Append(1);//dritter
kette2.Append(9);//vierter
...
kette2.Sort();

usw.
Jetzt fehlt noch eine funktion um zwei instanzen zu vergleichen.

mr.escape
"The man who trades freedom for security does not deserve nor will he ever receive either." - Benjamin Franklin"Wer seine Freiheit aufgibt, um Sicherheit zu erreichen, wird beides verlieren." - Georg Christoph Lichtenberg
bei Antwort benachrichtigen
JeromeB mr.escape „OK, das sieht nach verketteter liste aus, oder bei eingeschränkten bereichen...“
Optionen

aja, verkettete liste, super sache, hab ich schonmal gehört...
ist ja ne gute lösung wie ich meine, aber eins ist noch nicht beinhaltet: der benutzer soll ja selbst entscheiden wie viele elemente er in seine liste eingeben will, also der benutzer der dann da dran sitzt... es soll auf dem bildschirm stehen:"element eingeben (->Eingabe)", dann:"weiter element? (->JA/NEIN)".....wie macht man das? wenn vorher feststehen würde wieviele elemente kommen, dann würde man die zeile "kette1.Append(...)"halt genauso oft eintippen in den quelltext, oder? aber das hat dann doch nix mit dynamischer speicherverwaltung zu tun, richtig?

kannst du das bitte mal in den quelltext einbauen? wäre super...

vielen vieln dank, jerome.....

bei Antwort benachrichtigen
mr.escape JeromeB „aja, verkettete liste, super sache, hab ich schonmal gehört... ist ja ne gute...“
Optionen

Mit dem obigen beispiel käme etwa sowas raus:

intKette kette3;//ohne starteintrag, da noch unbekannt

int z;//da kommen die eingaben jeweils hin
do {
printf("element eingeben (->Eingabe):");
scanf("%d", &z);//von standardeingabe
kette3.Append(z);//wert speichern
getchar();//zeilenende aus standardeingabe löschen
printf("weiter element? (->JA/NEIN):");//hier wird es hässlich, denn
//immer JA oder NEIN tippen zu müssen ist "böse", etwas einfacheres
//ist netter, z.b. keine eingabe für ja und alles andere für nein
z=getchar();
} while(z==10);//wenn bei JA/NEIN frage nichts eingegeben wird, geht es weiter
//hier ist die erste variable voll, das gleiche nochmal für die
// zweite und danach der rest (schnittmenge, vergleich und anderer funktionen)

//es muss in "class intKette" übrigens auch noch heissen:
intKette(){glieder=NULL;}
intKette(int z){glieder=NULL;Append(z);}
~intKette(){if(glieder) delete glieder;glieder=NULL;}
void Append(int z){//element einfügen, sehr simpel; sortiertes einfügen wäre evtl. besser, fehlerbehandlung empfohlen
intKettenglied *neu=new intKettenglied;
neu->num=z;
neu->next=glieder;
glieder=neu;
}

//eine mögliche sort routine
typedef int (__cdecl *COMPARE )(const void *elem1, const void *elem2);

int gliedcomp(const intKettenglied **arg1, const intKettenglied **arg2){
if((*arg1)->num>(*arg2)->num)
return 1;
if((*arg1)->num<(*arg2)->num)
return -1;
return 0;
}

void intKette::Sort(){
int n, i;
intKettenglied *act_gl=glieder;
intKettenglied **sortarray;
n=0;
while(act_gl){
n++;//ist anzahl elemente
act_gl=act_gl->next;
}
if(n<2)//0 oder 1 elemente sind automatisch richtig sortiert
return;
//alle zeiger in ein array
sortarray=new intKettenglied*[n];
act_gl=glieder;
i=0;
while(act_gl){
sortarray[i++]=act_gl;
act_gl=act_gl->next;
}
//sortieren
qsort(sortarray, n, sizeof(intKettenglied*), (COMPARE)gliedcomp);
//und neu aufbauen
glieder=sortarray[0];
for(i=0;i<n-1;i++){
sortarray[i]->next=sortarray[i+1];
}
sortarray[i]->next=NULL;//kette stoppen
delete[] sortarray;//array freigeben
}


Und das ganze, wie immer ohne viel fehlerbehandlung, da nur das prinzip gezeigt werden soll.

mr.escape
"The man who trades freedom for security does not deserve nor will he ever receive either." - Benjamin Franklin"Wer seine Freiheit aufgibt, um Sicherheit zu erreichen, wird beides verlieren." - Georg Christoph Lichtenberg
bei Antwort benachrichtigen