-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 14:44 Uhr
|
|
CIntArray::Quicksort()
{
qsort((void*) m_pData,m_Zaehler,sizeof(m_pData[0]),cmpFunc);
cout
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
Geschrieben am: 04.04.2007 um 14:45 Uhr
Zuletzt editiert am: 04.04.2007 um 14:45 Uhr
|
|
nach Quicksort hörts auf ...
Mach vor und nach die " < " Zeichen Leerzeichen rein, damit TU das nicht als HTML interpretiert
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 14:45 Uhr
|
|
Kann man was dagegen machen das der Beitrag bei jedem"
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
|
Geschrieben am: 04.04.2007 um 14:46 Uhr
|
|
Zitat von Polaris: nach Quicksort hörts auf ...
Mach vor und nach die " < " Zeichen Leerzeichen rein, damit TU das nicht als HTML interpretiert
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 14:50 Uhr
|
|
Auf ein neues 
#include "stdafx.h"
#include
#include
#include
#include
#include
#include
int cmpFunc(const void* _a, const void* _b)
{
const float* a = (const float*) _a;
const float* b = (const float*) _b;
if(*a > *b) return 1;
else
if(*a == *b) return 0;
else return -1;
}
class CIntArray
{
public:
CIntArray();
CIntArray(int Groesse,int Blockgroesse);
CIntArray(const CIntArray& co);//?????
int Clear(int Groesse);
int Zuweisungsoperator();//?????
int Add(int Zahl);
int Getsize();
int SetAt(int Index,int Zahl);
int Ausgabe();
int Eingeben();
int Sortiere();
int Quicksort();
protected:
int* m_pData;
int m_Groesse;
int m_Zaehler;
};
CIntArray::CIntArray()
:m_pData(0),m_Groesse(0)
{
}
CIntArray::Quicksort()
{
qsort((void*) m_pData,m_Zaehler,sizeof(m_pData[0]),cmpFunc);
cout < < "Ausgabe mit qsort \n";
for(int x=0;x > Zahl;
return Zahl;
}
int CIntArray::Add(int Zahl)
{
m_pData[m_Zaehler] = Zahl;
m_Zaehler++;
return 0;
}
int CIntArray::Ausgabe()
{
for(int x=0; x < = (m_Zaehler);x++)
{
cout < < m_pData[x] < < endl;
}
return 0;
}
int CIntArray::Getsize()
{
return m_Zaehler;
}
int CIntArray::SetAt(int Index,int Zahl)
{
m_pData[Index]=Zahl;
return 0;
}
int CIntArray::Sortiere()
{
for(int x=0;x < = (m_Zaehler-1);x++)
{
for(int j=0;j < m_Zaehler;j++)
{
if (m_pData[x+1] < m_pData[j])
{
int n=m_pData[x+1];
int z=m_pData[j];
m_pData[x+1]=z;
m_pData[j]=n;
}
}
}
cout < < "Sortiert mit Nrmaler Sortierung\n";
return 0;
}
int main()
{
int Groesse=10;
int Blockgroesse=0;
int Zahl1=0;
int Index=0;
int Eingabe=1;
CIntArray();
CIntArray CIntArray(Groesse,Blockgroesse);
while(Eingabe!=0)
{
cout < < "Was möchten sie tun? \n";
cout < < "1)Zahl eingeben \n";
cout < < "2)Ausgeben \n";
cout < < "3)An bestimmter Stelle einen Wert einfügen\n";
cout < < "0) Beenden \n";
cin > > Eingabe;
switch(Eingabe)
{
case 1:
{
Zahl1=CIntArray.Eingeben();
CIntArray.Add(Zahl1);
break;
}
case 2:
{
CIntArray.Quicksort();
CIntArray.Sortiere();
CIntArray.Ausgabe();
break;
}
case 3:
{
cout < < "An welcher stelle?\n";
cin > > Index;
if(Index>=Groesse)
{
cout < < "Der Index ist größer als die Anzahl der Zahlen\n";
cout < < "Bitte geben sie eine kleinere Zahl ein \n";
}
else
{
Zahl1=CIntArray.Eingeben();
CIntArray.SetAt(Index,Zahl1);
}
break;
}
default:
{
CIntArray.Clear(Groesse);
}
}
}
return 0;
}
Meine Probleme sind noch :
KopyConstruktor
Übergabeoperator
und CLear methode
Quicksort
und Sortieren sind ne zusatz aufgabe
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:01 Uhr
|
|
Also für deine SetAt Methode musst du natürlich auch eine Überlaufüberprüfung machen:
int CIntArray::SetAt(int Index,int Zahl)
{
if(Index < Groesse) {
m_pData[Index]=Zahl;
if(Index > m_Zaehler)
{
m_Zaehler = Index;
}
}
else {
while(Index > = Groesse) { AriseArray(Blockgroesse > 1?Blockgroesse:1); }
m_pData[Index] = Zahl;
m_Zaehler = Index;
}
}
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:04 Uhr
|
|
Zitat von Polaris: Also für deine SetAt Methode musst du natürlich auch eine Überlaufüberprüfung machen:
int CIntArray::SetAt(int Index,int Zahl)
{
if(Index < Groesse) {
m_pData[Index]=Zahl;
if(Index > m_Zaehler)
{
m_Zaehler = Index;
}
}
else {
while(Index > = Groesse) { AriseArray(Blockgroesse > 1?Blockgroesse:1); }
m_pData[Index] = Zahl;
m_Zaehler = Index;
}
}
hmm
das hab ich doch schon bei meiner main funktion.
Wenn Index größer ist als Groesse dann springt man erst gar nicht in SetAt sondern man bekommt eine Textmeldung "Index zu groß" und es wird das menu aufgerufen
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
Geschrieben am: 04.04.2007 um 15:08 Uhr
Zuletzt editiert am: 04.04.2007 um 15:09 Uhr
|
|
Zitat von -mOsTwAnTeD-: Zitat von Polaris: Also für deine SetAt Methode musst du natürlich auch eine Überlaufüberprüfung machen:
int CIntArray::SetAt(int Index,int Zahl)
{
if(Index < Groesse) {
m_pData[Index]=Zahl;
if(Index > m_Zaehler)
{
m_Zaehler = Index;
}
}
else {
while(Index > = Groesse) { AriseArray(Blockgroesse > 1?Blockgroesse:1); }
m_pData[Index] = Zahl;
m_Zaehler = Index;
}
}
hmm
das hab ich doch schon bei meiner main funktion.
Wenn Index größer ist als Groesse dann springt man erst gar nicht in SetAt sondern man bekommt eine Textmeldung "Index zu groß" und es wird das menu aufgerufen
Das ist aber nicht Sinn der Sache, diese Klasse soll ja jeder benutzen können (der C++ benutzt ).
/Edit:
sonst wäre die Blockgroesse auch Blödsinn
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:08 Uhr
|
|
Zitat von Polaris: Damit das hier richtig verstanden wird: wir machen hier keine Hausaufgaben für dich.
Damit es richtig verstanden wird: Das sind keine Hausaufgaben.
Aber ich finds ja gut wenn du mich das alleine machen lässt und mir halt tipps gibst.
Wollt nur klar stellen das das keine Hausaufgaben sind
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:09 Uhr
|
|
Zitat von Polaris: Zitat von -mOsTwAnTeD-: Zitat von Polaris: Also für deine SetAt Methode musst du natürlich auch eine Überlaufüberprüfung machen:
int CIntArray::SetAt(int Index,int Zahl)
{
if(Index < Groesse) {
m_pData[Index]=Zahl;
if(Index > m_Zaehler)
{
m_Zaehler = Index;
}
}
else {
while(Index > = Groesse) { AriseArray(Blockgroesse > 1?Blockgroesse:1); }
m_pData[Index] = Zahl;
m_Zaehler = Index;
}
}
hmm
das hab ich doch schon bei meiner main funktion.
Wenn Index größer ist als Groesse dann springt man erst gar nicht in SetAt sondern man bekommt eine Textmeldung "Index zu groß" und es wird das menu aufgerufen
Das ist aber nicht Sinn der Sache, diese Klasse soll ja jeder benutzen können (der C++ benutzt  ).
Ja habs schon umgeschrieben
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
Polaris
Experte
(offline)
Dabei seit 07.2006
1766
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:11 Uhr
|
|
Zitat von -mOsTwAnTeD-: Zitat von Polaris: Damit das hier richtig verstanden wird: wir machen hier keine Hausaufgaben für dich.
Damit es richtig verstanden wird: Das sind keine Hausaufgaben.
Aber ich finds ja gut wenn du mich das alleine machen lässt und mir halt tipps gibst.
Wollt nur klar stellen das das keine Hausaufgaben sind
ja okay , sorry,
Die Aufgabe hörte sich halt schwer nach Hausaufgaben an ... in anderen Foren kommen oft Typen her, posten ne Aufgabe und schreiben: "macht mal" und das sind dann meistens Hausaufgaben, die sie auch noch bis zum nächsten Tag brauchen ...
Patriotismus ist die Tugend der Bosheit! (Oscar Wilde)
|
|
Rifleman - 40
Experte
(offline)
Dabei seit 09.2003
1540
Beiträge
|
Geschrieben am: 04.04.2007 um 15:12 Uhr
Zuletzt editiert am: 04.04.2007 um 15:15 Uhr
|
|
Zitat von Polaris: void CIntArray::AriseArray(int _Blockgroesse) {
int* _Temp = new int[Groesse + _Blockgroesse];
memset(_Temp, 0, sizeof(int) * (Groesse + _Blockgroesse));
memcpy(_Temp, m_pData, sizeof(int) * Groesse);
delete[] m_pData;
m_pData = _Temp;
}
void CIntArray::Add(int Zahl)
{
if(++Zaehler < = m_Groesse)
m_pData[m_Zaehler] = Zahl;
else {
AriseArray(Blockgroesse > 0?Blockgroesse:1);
m_pData[m_Zaehler] = Zahl;
}
}
In AriseArray sollte m_Groesse natürlich noch angepasst werden wenn ich das richtig sehe...sonst wird der nächste Call einen Teil ins Nirwana schicken..
Gibt es einen speziellen Grund, warum bei jedem Aufruf von AriseArray die Blockgröße überprüft wird anstatt einfach nur den constructor und eine Änderungsmethode dies prüfen zu lassen?
/edit: Angenommen, mit Groesse meinst du m_Groesse...
Es sind die kleinen Dinge, die einen zum Wahnsinn treiben.
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:13 Uhr
|
|
Zitat von Polaris: Zitat von -mOsTwAnTeD-: Zitat von Polaris: Damit das hier richtig verstanden wird: wir machen hier keine Hausaufgaben für dich.
Damit es richtig verstanden wird: Das sind keine Hausaufgaben.
Aber ich finds ja gut wenn du mich das alleine machen lässt und mir halt tipps gibst.
Wollt nur klar stellen das das keine Hausaufgaben sind
ja okay  , sorry,
Die Aufgabe hörte sich halt schwer nach Hausaufgaben an ... in anderen Foren kommen oft Typen her, posten ne Aufgabe und schreiben: "macht mal" und das sind dann meistens Hausaufgaben, die sie auch noch bis zum nächsten Tag brauchen ...
Ne des is ne Aufgabe von meinem Ausbilder 
Ich will ja gar nicht das du mir hier den kompletten Quellcode hinschreibst dabei leren ich ja überhaupt nichts.
Ich bin nur nich weitergekommen da dachte ich warum nicht mal im tu forum fragen
und bis morgen brauch ich das auch nicht
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:15 Uhr
|
|
Zitat von Rifleman: Zitat von Polaris: void CIntArray::AriseArray(int _Blockgroesse) {
int* _Temp = new int[Groesse + _Blockgroesse];
memset(_Temp, 0, sizeof(int) * (Groesse + _Blockgroesse));
memcpy(_Temp, m_pData, sizeof(int) * Groesse);
delete[] m_pData;
m_pData = _Temp;
}
void CIntArray::Add(int Zahl)
{
if(++Zaehler < = m_Groesse)
m_pData[m_Zaehler] = Zahl;
else {
AriseArray(Blockgroesse > 0?Blockgroesse:1);
m_pData[m_Zaehler] = Zahl;
}
}
In AriseArray sollte m_Groesse natürlich noch angepasst werden wenn ich das richtig sehe...sonst wird der nächste Call einen Teil ins Nirwana schicken..
Gibt es einen speziellen Grund, warum bei jedem Aufruf von AriseArray die Blockgröße überprüft wird anstatt einfach nur den constructor und eine Änderungsmethode dies prüfen zu lassen?
Nä da gibts keinen Grund dafür. Ich bin C++ newbie das ist der Grund
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|
-mOsTwAnTeD- - 35
Profi
(offline)
Dabei seit 07.2006
677
Beiträge
|
|
Geschrieben am: 04.04.2007 um 15:22 Uhr
|
|
AriseArray(Blockgroesse > 0?Blockgroesse:1);
was passiert in dieser Zeile?
Ich scheiß auf deine Welt voller Arroganz und Geld!
|
|