?
Hallo,
also ich bin ziemlich neu im Gebiet C++ und mache gerade ein Toturial.Ich habe schon tagelang versucht das Programm zum Laufen zu bringen und ich bin auch so weit, dass es startet und einigermasen gut funktioniert.Nur das Problem ist die Ausgabe aollte in einer bestimmten Reihenfolge passieren, aber es wird in der selben Reihenfolge ausgegeben wie man eingibt.Ich benutze uebrigenz Dev-Cpp und Win XP.Ein paar andere Fehler scheinen auch noch drin zu sein aber ich kann nichts finden.Ich dachte mir, ich poste einfach mal den Code und vielleicht kann mir ja einer helfen.
/*hier die main.cpp datei; nichts besonderes, is nur da, um die header auf Funktion zu ueberpruefen*/
#include <iostream>
using namespace std;
#include "vector.h"
#include "SortedArray.h"
int main()
{
Vector<int> v1(10);
Vector<int> v2(10);
Vector<int> v3(10);
v1[1] = 4711;
v1[2] = 0;
v3 = v2 = v1;
cout << v3[1] << endl;
cout << v3[2] << endl;
cout << '\n';
SortedArray<string> s;
s.insert("Hans");
s.insert("Klaus");
s.insert("ich");
s.insert("Fritz");
s.insert("Anna");
for(int i = 0; i < s.getSize(); ++i)
cout << i << " " << s[i] << endl;
cin.get();
return 0;
}
#include <assert.h>
#ifndef VECTOR_H
#define VECTOR_H
template<class T>
class Vector
{
private:
T *m_data;
int m_size;
static const int GROW_SIZE = 10;
public:
Vector(int size)//Konstruktor
{
m_size = size;
m_data = new T[m_size];
};
Vector(const Vector& diff_Vector)//Copy-Konstruktor
{
m_size = diff_Vector.m_size;
m_data = new T[m_size];
for(int i = 0; i < m_size; ++i)
m_data[i] = diff_Vector.m_data[i];
};
~Vector()//Destruktor
{
delete[] m_data;
};
Vector &operator=(const Vector& diff_Vector)//ueberladen des = Operators
{
if(&diff_Vector != this)
{
delete[] m_data;
m_size = diff_Vector.m_size;
m_data = new T[m_size];
for(int i = 0; i < m_size; ++i)
m_data[i] = diff_Vector.m_data[i];
}
return *this;
};
T& operator[](int index)//ueberladen des [] Operators
{
assert(index < m_size);
return m_data[index];
};
int getSize()//gibt Groesse des Vectors wieder
{
return m_size;
};
void grow(int NewSize)//vergroessert den Vector
{
if(NewSize > m_size)
{
NewSize += GROW_SIZE;
T *tmp_array = new T[NewSize];
for(int i = 0; i < m_size; ++i)
tmp_array[i] = m_data[i];
delete[] m_data;
m_data = tmp_array,
m_size = NewSize;
}
else cerr << "Die neue Groesse ist zu klein!" << endl;
};
void remove(const T &toRemove)//entfernt ein Element
{
int found = findIndex(toRemove);
if(found != -1)
{
m_data.moveDown(found + 1, m_size, found);
--m_size;
}
};
//verschiebt Vector nach unten
void moveDown(const int &start, const int &end, const int &newStart)
{
for(int i = newStart; i < end + 1; ++i)
m_data[i] = m_data[i + (start - newStart)];
};
//verschiebt Vector nach oben
void moveUp(const int &start, const int &end, const int &newStart)
{
T *tmp_array = new T[m_size];
tmp_array = m_data;
for(int i = start; i < end; ++i)
m_data[start + (newStart - start)] = tmp_array[i];
};
};
#endif
#include "vector.h"
#include <assert.h>
#ifndef SortedArray_H
#define SortedArray_H
using namespace std;
template<class T>
class SortedArray
{
private:
Vector<T> m_data;
int m_size;
////sucht nach dem Index eines Elementes(funktioniert nur, wenn sortiert)
int findIndex(const T &toFind)
{
int oben = m_size - 1, unten = 0, mitte = int(m_size / 2);
do
{
if(m_data[mitte] <= toFind)
{
unten = mitte;
mitte = int(mitte + ((oben - mitte) / 2));
}
else
{
oben = mitte - 1;
mitte = int(mitte - (mitte - unten) / 2);
};
}while(oben - unten > 1);
if(m_data[oben] == toFind)
return oben;
else if(m_data[unten] == toFind)
return unten;
else
return -1;
};
public:
SortedArray():m_data(10)//Konstruktor
{
m_size = 0;
};
SortedArray &operator=(const SortedArray &sa)//ueberladen des = Operators
{
m_data = sa.m_data;
m_size = sa.m_size;
return *this;
};
T *find(const T &toFind)//gibt zu suchendes Element wieder
{
int found = findIndex(toFind);
if(found != -1)
return &m_data[found];
else
return 0;
};
bool has(const T &toFind)//bestaetigt, ob Element vorhanden
{
return find(toFind) != 0;
};
/*soll ein Element einguegen, und zwar nicht einfach an das Ende des Arrays haengen, sondern in sortierter Reihenfolge*/
void insert(const T &toInsert)
{
if(m_size != 0)
{
m_data.grow(m_size + 1);
if(!has(toInsert))
{
for(int pos = m_size - 1; pos > 0; --pos)
{
if (m_data[pos] < toInsert)
{
m_data.moveUp(pos, m_size, pos + 1);
m_data[pos] = toInsert;
break;
}
else if(pos == 0)
{
m_data.moveUp(pos + 1, m_size, pos + 2);
m_data[pos] = toInsert;
}
}
++m_size;
}
else
;
}
else
{
m_data[m_size] = toInsert;
++m_size;
}
};
const T &operator[](int index)//ueberladen des = Operators
{
assert(index < m_size);
return m_data[index];
};
int getSize()//gibt Groesse wieder
{
return m_size;
};
};
#endif
Ich hoffe einer von euch kann mir da weiterhelfen.Ich waere fuer jeden Tip, jede Anregung und natuerlcih fuer jeden Loesungsvorschlage sehr dankbar.
MfG,
Vedran Klaric