<![CDATA[Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt.]]>Ich bin immer noch bei meinem Telefonbuchprogramm, und habe nun eine Sortierklasse die mir die alles durchsortiert.
Immer wenn etwas neues eingefügt wird (mit der Methode insert), dann prüft er ob mehr als ein Eintrag vorhanden ist [if (m_size!=0) m_data.put_in_order();], weil wenn ja nur ein Eintrag drin ist dann is es ja sinnlos zu sortieren.
Das ganze funktioniert auch gut, aber leider nur mit Zahlen (int,....) aber bei strings funzt es schon nicht mehr.

Das funktioniert nicht!
main.cpp

#include <iostream>
#include "set.hpp"
#include <string>

int main()
{
    set<std::string> data_base;
    data_base.insert("Hans");
    data_base.insert("Otto");
    data_base.insert("Alex");
    data_base.insert("Oskar");
    for (int i=0;i<4;i++)
    {
        std::cout << data_base[i] << std::endl ;
    }
	return 0;
}

AUSGABE:
4 Zeilen, in denen aber gar nichts drin steht.
Also wie wenn der Text unsichtbar wäre.
Wenn ich in der Klasse "set" in der Methode "insert" (oben beschrieben) folgende Zeile Weglasse [if (m_size!=0) m_data.put_in_order();] dann wird zwar nicht mehr sortiert, aber es kommt wieder eine Ausgabe.

Wenn ich meine Klasse set aber mit "int,...." ausprobiere dann geht alles, Er sortiert fröhlich.... siehe hier:
main.cpp

#include <iostream>
#include "set.hpp"
#include <string>

int main()
{
    set<int> data_base;
    data_base.insert(67);
    data_base.insert(23);
    data_base.insert(15);
    data_base.insert(90);
    for (int i=0;i<4;i++)
    {
        std::cout << data_base[i] << std::endl ;
    }
	return 0;
}

AUSGABE:
15
23
67
90

Ich weiß jetzt nicht genau warum das net funzt? Liegt das irgendwie an "strings"? Es kann ja wohl nur an denen legen. Ich hab den Code jetzt schon öfters zurückverfolgt und mir genau angeschaut was er macht.... aber ich kommt immer wieder zu dem Ergebnis das es gehen sollte. Warum zeigt er die String nach dem Sortieren nicht mehr an?
Mh hier mal der ganze CODE:
(die Stellen um die es geht sind markiert mit "###")

main.cpp

#include <iostream>
#include "set.hpp"
#include <string>

int main()
{
    set<int> data_base;
    data_base.insert(67);
    data_base.insert(23);
    data_base.insert(15);
    data_base.insert(90);
    for (int i=0;i<4;i++)
    {
        std::cout << data_base[i] << std::endl ;
    }
	return 0;
}

vector.hpp

#ifndef VECTOR_HPP_INCLUDED
#define VECTOR_HPP_INCLUDED

#include "size.hpp"

template <class T>
class vector : public size<T>
{
    public:
    vector(int size);
    vector(const vector &rhs);
    ~vector();
    int GetSize() {return m_size;}
    T &operator[] (int index);
    vector &operator= (const vector &rhs);
    void grow(int fields);
    void moveDown(int pos); //ohne Nullstelle!!!
    void put_in_order();

    private:
    T *m_data;
    size_t m_size;
    size_t counter;

};

template <class T>
vector<T>::vector(int size)
:m_size(size),counter(0)
{
    m_data=new T[m_size];
}

template <class T>
vector<T>::vector(const vector &rhs)
:m_size(rhs.m_size),counter(rhs.counter)
{
    m_data=new T[m_size];
    for (int i=0;i<m_size;i++)
    {
        m_data[i]=rhs.m_data[i];
    }
}

template <class T>
vector<T>::~vector()
{
    delete []m_data;
}

template <class T>
T &vector<T>::operator[] (int index)
{
    return m_data[index];
}

template <class T>
vector<T> &vector<T>::operator= (const vector &rhs)
{
    if (&rhs!=this)
    {
        delete []m_data;
        m_data=NULL;
        m_size=rhs.m_size;
        m_data=new T[m_size];
        for (int i=0;i<m_size;i++)
        {
            m_data[i]=rhs.m_data[i];
        }
    }
    return *this;
}

template <class T>
void vector<T>::grow(int fields)
{
    change_size(&m_data,m_size,fields);
}

template <class T>
void vector<T>::moveDown(int pos)
{
    for (size_t i=pos;i<counter;i++)
    {
        m_data[i]=m_data[i+1];
    }
    counter--;
}

template <class T>
void vector<T>::put_in_order() //<-- ###
{
    sort_array(m_data,m_size); //<-- hier wird dann sortiert ###
    counter++; 
}

#endif // VECTOR_HPP_INCLUDED

size.hpp

#ifndef SIZE_HPP_INCLUDED
#define SIZE_HPP_INCLUDED

#include "sort.hpp"

template <class T>
class size : public sort<T>
{
    public:
    size();
    virtual ~size();
    void change_size(T **array,int length_old,int extension);
};

template <class T>
size<T>::size()
{

}

template <class T>
size<T>::~size()
{

}

template <class T>
void size<T>::change_size(T **array,int length_old,int extension)
{
    T *cache=new T[length_old];
    for (int i=0;i<length_old;i++)
    {
        cache[i]=(*array)[i];
    }
    delete [](*array);
    *array=0;
    *array=new T[length_old+extension];
    for (int i=0;i<length_old;i++)
    {
        (*array)[i]=cache[i];
    }
    delete []cache;
}

#endif // SIZE_HPP_INCLUDED

set.hpp

#ifndef SET_HPP_INCLUDED
#define SET_HPP_INCLUDED

#include "vector.hpp"

template <class T>
class set
{
    public:
    set();
    ~set();
    T *find(const T &toFind);
    bool has(const T &toFind);
    void insert(const T &toInsert);
    void remove(const T &toRemove);
    const T &operator[](int index);
    vector<T> m_data;

    private:
    int findIndex(const T &toFind);

    int m_size;
};

template <class T>
set<T>::set()
:m_data(10)
{
    m_size=0;
}

template <class T>
set<T>::~set()
{

}

template <class T>
T *set<T>::find(const T &toFind)
{
    int found=findIndex(toFind);
    if (found!=-1)
    {
        return &m_data[found];
    }
    else
    {
        return 0;
    }
}

template <class T>
bool set<T>::has(const T &toFind)
{
    return find(toFind)!=0;
}

template <class T>
void set<T>::insert(const T &toInsert)
{
    if (!has(toInsert))
    {
        if (m_size==m_data.GetSize())
        {
            m_data.grow(10);
        }
        m_data[m_size]=toInsert;
        if (m_size!=0) m_data.put_in_order(); //<-- ###
        m_size++;

    }
}

template <class T>
int set<T>::findIndex(const T &toFind)
{
    for (int i=0;i<m_size;i++)
    {
        if (toFind==m_data[i])
        {
            return i;
        }
    }
    return -1;
}

template <class T>
void set<T>::remove(const T &toRemove)
{
    int found=findIndex(toRemove);
    if (found!=-1)
    {
        m_data.moveDown(found);
        m_size--;
        m_data[m_size]=-5; //"-5" bedeutet --> NICHT ZUGEWIESEN
    }
}

template <class T>
const T &set<T>::operator[] (int index)
{
    return m_data[index];
}

#endif // SET_HPP_INCLUDED

sort.hpp

#ifndef SORT_HPP_INCLUDED
#define SORT_HPP_INCLUDED
#include <string>

//Das hier ist die SORTIER-KLASSE
template <class T>
class sort
{
    public:
    sort();
    ~sort();
    void sort_array(T *array,int length);
    void swap(T &a,T &b);

    private:

};

template <class T>
sort<T>::sort()
{

}

template <class T>
sort<T>::~sort()
{

}
template <class T>
void sort<T>::sort_array(T *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (array[tradeoff]>array[j])
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

template <class T>
void sort<T>::swap(T &a,T &b)
{
    const T temp=a;
    a=b;
    b=temp;
}

#endif // SORT_HPP_INCLUDED

So vll. is jemand so nett und stöbert mal bisschen durch meinen CODE. Wenn sich das n ausenstehender anschaut dann is das mal aus nem anderen Blickwinkel und diejenige oder derjenige weiß eventuell weiter.
Dankeschön schon mal im Voraus.

]]>https://www.c-plusplus.net/forum/topic/180695/telefonbuchprogramm-strings-werden-nach-dem-sortieren-nicht-mehr-angezeigtRSS for NodeMon, 21 Sep 2026 22:34:48 GMTSat, 05 May 2007 13:49:29 GMT60<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sat, 05 May 2007 13:51:16 GMT]]>Ich bin immer noch bei meinem Telefonbuchprogramm, und habe nun eine Sortierklasse die mir die alles durchsortiert.
Immer wenn etwas neues eingefügt wird (mit der Methode insert), dann prüft er ob mehr als ein Eintrag vorhanden ist [if (m_size!=0) m_data.put_in_order();], weil wenn ja nur ein Eintrag drin ist dann is es ja sinnlos zu sortieren.
Das ganze funktioniert auch gut, aber leider nur mit Zahlen (int,....) aber bei strings funzt es schon nicht mehr.

Das funktioniert nicht!
main.cpp

#include <iostream>
#include "set.hpp"
#include <string>

int main()
{
    set<std::string> data_base;
    data_base.insert("Hans");
    data_base.insert("Otto");
    data_base.insert("Alex");
    data_base.insert("Oskar");
    for (int i=0;i<4;i++)
    {
        std::cout << data_base[i] << std::endl ;
    }
	return 0;
}

AUSGABE:
4 Zeilen, in denen aber gar nichts drin steht.
Also wie wenn der Text unsichtbar wäre.
Wenn ich in der Klasse "set" in der Methode "insert" (oben beschrieben) folgende Zeile Weglasse [if (m_size!=0) m_data.put_in_order();] dann wird zwar nicht mehr sortiert, aber es kommt wieder eine Ausgabe.

Wenn ich meine Klasse set aber mit "int,...." ausprobiere dann geht alles, Er sortiert fröhlich.... siehe hier:
main.cpp

#include <iostream>
#include "set.hpp"
#include <string>

int main()
{
    set<int> data_base;
    data_base.insert(67);
    data_base.insert(23);
    data_base.insert(15);
    data_base.insert(90);
    for (int i=0;i<4;i++)
    {
        std::cout << data_base[i] << std::endl ;
    }
	return 0;
}

AUSGABE:
15
23
67
90

Ich weiß jetzt nicht genau warum das net funzt? Liegt das irgendwie an "strings"? Es kann ja wohl nur an denen legen. Ich hab den Code jetzt schon öfters zurückverfolgt und mir genau angeschaut was er macht.... aber ich kommt immer wieder zu dem Ergebnis das es gehen sollte. Warum zeigt er die String nach dem Sortieren nicht mehr an?
Mh hier mal der ganze CODE:
(die Stellen um die es geht sind markiert mit "###")

main.cpp

#include <iostream>
#include "set.hpp"
#include <string>

int main()
{
    set<int> data_base;
    data_base.insert(67);
    data_base.insert(23);
    data_base.insert(15);
    data_base.insert(90);
    for (int i=0;i<4;i++)
    {
        std::cout << data_base[i] << std::endl ;
    }
	return 0;
}

vector.hpp

#ifndef VECTOR_HPP_INCLUDED
#define VECTOR_HPP_INCLUDED

#include "size.hpp"

template <class T>
class vector : public size<T>
{
    public:
    vector(int size);
    vector(const vector &rhs);
    ~vector();
    int GetSize() {return m_size;}
    T &operator[] (int index);
    vector &operator= (const vector &rhs);
    void grow(int fields);
    void moveDown(int pos); //ohne Nullstelle!!!
    void put_in_order();

    private:
    T *m_data;
    size_t m_size;
    size_t counter;

};

template <class T>
vector<T>::vector(int size)
:m_size(size),counter(0)
{
    m_data=new T[m_size];
}

template <class T>
vector<T>::vector(const vector &rhs)
:m_size(rhs.m_size),counter(rhs.counter)
{
    m_data=new T[m_size];
    for (int i=0;i<m_size;i++)
    {
        m_data[i]=rhs.m_data[i];
    }
}

template <class T>
vector<T>::~vector()
{
    delete []m_data;
}

template <class T>
T &vector<T>::operator[] (int index)
{
    return m_data[index];
}

template <class T>
vector<T> &vector<T>::operator= (const vector &rhs)
{
    if (&rhs!=this)
    {
        delete []m_data;
        m_data=NULL;
        m_size=rhs.m_size;
        m_data=new T[m_size];
        for (int i=0;i<m_size;i++)
        {
            m_data[i]=rhs.m_data[i];
        }
    }
    return *this;
}

template <class T>
void vector<T>::grow(int fields)
{
    change_size(&m_data,m_size,fields);
}

template <class T>
void vector<T>::moveDown(int pos)
{
    for (size_t i=pos;i<counter;i++)
    {
        m_data[i]=m_data[i+1];
    }
    counter--;
}

template <class T>
void vector<T>::put_in_order() //<-- ###
{
    sort_array(m_data,m_size); //<-- hier wird dann sortiert ###
    counter++; 
}

#endif // VECTOR_HPP_INCLUDED

size.hpp

#ifndef SIZE_HPP_INCLUDED
#define SIZE_HPP_INCLUDED

#include "sort.hpp"

template <class T>
class size : public sort<T>
{
    public:
    size();
    virtual ~size();
    void change_size(T **array,int length_old,int extension);
};

template <class T>
size<T>::size()
{

}

template <class T>
size<T>::~size()
{

}

template <class T>
void size<T>::change_size(T **array,int length_old,int extension)
{
    T *cache=new T[length_old];
    for (int i=0;i<length_old;i++)
    {
        cache[i]=(*array)[i];
    }
    delete [](*array);
    *array=0;
    *array=new T[length_old+extension];
    for (int i=0;i<length_old;i++)
    {
        (*array)[i]=cache[i];
    }
    delete []cache;
}

#endif // SIZE_HPP_INCLUDED

set.hpp

#ifndef SET_HPP_INCLUDED
#define SET_HPP_INCLUDED

#include "vector.hpp"

template <class T>
class set
{
    public:
    set();
    ~set();
    T *find(const T &toFind);
    bool has(const T &toFind);
    void insert(const T &toInsert);
    void remove(const T &toRemove);
    const T &operator[](int index);
    vector<T> m_data;

    private:
    int findIndex(const T &toFind);

    int m_size;
};

template <class T>
set<T>::set()
:m_data(10)
{
    m_size=0;
}

template <class T>
set<T>::~set()
{

}

template <class T>
T *set<T>::find(const T &toFind)
{
    int found=findIndex(toFind);
    if (found!=-1)
    {
        return &m_data[found];
    }
    else
    {
        return 0;
    }
}

template <class T>
bool set<T>::has(const T &toFind)
{
    return find(toFind)!=0;
}

template <class T>
void set<T>::insert(const T &toInsert)
{
    if (!has(toInsert))
    {
        if (m_size==m_data.GetSize())
        {
            m_data.grow(10);
        }
        m_data[m_size]=toInsert;
        if (m_size!=0) m_data.put_in_order(); //<-- ###
        m_size++;

    }
}

template <class T>
int set<T>::findIndex(const T &toFind)
{
    for (int i=0;i<m_size;i++)
    {
        if (toFind==m_data[i])
        {
            return i;
        }
    }
    return -1;
}

template <class T>
void set<T>::remove(const T &toRemove)
{
    int found=findIndex(toRemove);
    if (found!=-1)
    {
        m_data.moveDown(found);
        m_size--;
        m_data[m_size]=-5; //"-5" bedeutet --> NICHT ZUGEWIESEN
    }
}

template <class T>
const T &set<T>::operator[] (int index)
{
    return m_data[index];
}

#endif // SET_HPP_INCLUDED

sort.hpp

#ifndef SORT_HPP_INCLUDED
#define SORT_HPP_INCLUDED
#include <string>

//Das hier ist die SORTIER-KLASSE
template <class T>
class sort
{
    public:
    sort();
    ~sort();
    void sort_array(T *array,int length);
    void swap(T &a,T &b);

    private:

};

template <class T>
sort<T>::sort()
{

}

template <class T>
sort<T>::~sort()
{

}
template <class T>
void sort<T>::sort_array(T *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (array[tradeoff]>array[j])
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

template <class T>
void sort<T>::swap(T &a,T &b)
{
    const T temp=a;
    a=b;
    b=temp;
}

#endif // SORT_HPP_INCLUDED

So vll. is jemand so nett und stöbert mal bisschen durch meinen CODE. Wenn sich das n ausenstehender anschaut dann is das mal aus nem anderen Blickwinkel und diejenige oder derjenige weiß eventuell weiter.
Dankeschön schon mal im Voraus.

]]>https://www.c-plusplus.net/forum/post/1279287https://www.c-plusplus.net/forum/post/1279287Sat, 05 May 2007 13:51:16 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sat, 05 May 2007 13:54:30 GMT]]>Randfrage: Warum schreibst du dir das eigentlich selber? Die Standard-Bibliothek hat doch schon zwei Klassen vector<> und set<>, die du auch nutzen könntest

]]>https://www.c-plusplus.net/forum/post/1279290https://www.c-plusplus.net/forum/post/1279290Sat, 05 May 2007 13:54:30 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sat, 05 May 2007 14:04:39 GMT]]>CStolls Frage ist auf jeden Fall das erste, dass einem einfällt. Natürlich ist es zulässig, deine Klassen so zu benennen, dafür sind Namensräume ja da. Es ist aber in Hinblick auf die Standardbibliothek unglücklich, die gleichen Namen zu verwenden - mindestens bei Bezeichnern, die sehr häufig genutzt werden.

Ohne jetzt das Programm analysiert zu haben, fällt mir in set<T> auf, dass du einerseits Informationen doppelt speicherst (m_size ist auch in m_data enthalten), und andererseits m_size nicht initialisierst...

ob das ein Problem ist ? keine Ahnung - schau selber nach

Grundsätzlich sind nicht nur public oder protected Daten kritisch zu beurteilen; selbst innerhalb einer Klasse ist es sinnvoll, zu kapseln, und den direkten Zugriff auf Daten auf eine kleine Anzahl von Funktionen (eine Art minimales Interface im Sinne von Sutters) zu beschränken.

Edit: Mach dich auch mit den Algorithmen der Standardbibliothek vertraut, damit wird einiges deutlich einfacher und ausdrucksstärker. Nachdem du weist, wie du arrays mit einer Schleife kopierst, solltest du wirklich lernen, mit copy umzugehen 😉

]]>https://www.c-plusplus.net/forum/post/1279292https://www.c-plusplus.net/forum/post/1279292Sat, 05 May 2007 14:04:39 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sat, 05 May 2007 14:14:56 GMT]]>Mh ja ich nen die halt so weil ich das so mache wie in dem Volkar Tutorial, und mich halt an die Namen von dem gehalten habe.
Das schaut nur so aus, m_size in der Klasse set hat andere Werte als m_size in der Klasse vector. In der Klasse set zählt m_size immer mit wo es den nächsten Eintarg einfügen muss, also nachdem ersten Eintrag mit der Methode Insert -> m_size++, also anfangs ist m_size=0; dann 1,2....... soviele Einträge es halt gibt.
Und m_size in vector ist anfangs 10 und wenn das Array dann vergrößert wird, dann ist m_size="= 20....... (vergrößert wird in vector mit der Methode "grow")
Siehe vector.hpp Zeile 80 --> change_size(&m_data,m_size,fields);
Dankeschön schon mal im Vroaus.

PS: Meine Vererbungen sind aber glaub n bissel konfus.

]]>https://www.c-plusplus.net/forum/post/1279295https://www.c-plusplus.net/forum/post/1279295Sat, 05 May 2007 14:14:56 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sat, 05 May 2007 14:35:20 GMT]]>Eigentlich funktioniert das auch mit ints u.ä. nicht so richtig - allerdings wird das möglicherweise nicht sichtbar, wenn du im Debug-Modus arbeitest. Dein vector weiß nichts davon, wie viele Elemente tatsächlich mit sinnvollen Werten gefüllt sind und beim Sortieren benutzt er einfach alle, auch solche, die eigentlich erst einmal nur reserviert sind. Nun sind aber default-konstruierte Strings leere Strings. Und beim Vergleich sind diese kleiner als jeder andere String, landen also am Anfang.

]]>https://www.c-plusplus.net/forum/post/1279303https://www.c-plusplus.net/forum/post/1279303Sat, 05 May 2007 14:35:20 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 10:08:48 GMT]]>Danke für deinen Rat camper, stimmt natürlich, ich hab mein Programm gleich bissel umgebaut und jetzt geht alles mit dem Sortieren.
So aber kommen wir gleich zu meinem nächsten Problem 😃
Folgendes:
Das hier ist ja meine SORTIER-FUNKTION

template <class T>
void sort<T>::sort_array(T *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (array[tradeoff]>array[j])
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

Wenn ich nun ein Array mit strings durchsortieren lasse, dann ist es so das er auch zwischen groß und kleinschreibung unterschiedet. DAs heißt also, wenn ich folgendes habe:

main.cpp

#include <iostream>
#include "set.hpp"
#include <string>
using namespace std;

int main()
{
    set<string> data_base;
    data_base.insert("zerch");
    data_base.insert("Werner");
    data_base.insert("olm");
    data_base.insert("oskar");
    data_base.insert("Hanna");
    data_base.insert("franz");
    data_base.insert("gehart");
    data_base.insert("Otto");
    data_base.insert("olga");
    data_base.insert("xaver");
    data_base.insert("gerda");
    data_base.insert("Peter");
    data_base.insert("hans");
    data_base.insert("elliott");

    for (int i=0;i<14;i++)
    {
        cout << data_base[i] << endl;
    }
	return 0;
}

dann kommt das hier raus:

Hanna
Otto
Peter
Werner
elliott
franz
gehart
gerda
hans
olga
olm
oskar
xaver
zerch

Des is aber ziemlich häslich, weil ich möchte das nicht unter groß und kleinschreibung unterschieden wird, sondern nur unter den Buchstaben im Alphabet.
Das Problem ist ja das der operator ">" bei strings diese nach den ASCII-Zeichen untersucht, was also heißt bei Großbuchstaben von 65 (für A) bis 90 (für Z), und das gleiche bei Kleinbuchstaben 97 (für a) bis 122 (für z).
Also müsste ich die Buchstaben in meiner Sortier funktion irgendwie kruz vor dem sortieren alle in kleinbuchstaben umwandeln, also wie das hier:

#include <ctype.h>
....
.....
//in sortier Methode
if (tolower(array[tradeoff])>tolower(array[j]))
......
.....
...

So alles schön und gut, aber wie man ja bei meiner sortier Methode (oben gepostet) sieht, handelt es sich um eine template Methode, und ich will ja da Zahlen sortieren bzw. strings.... somit muss ich die so allgemein wie möglich halten.
Also kann ich das hier:

if (tolower(array[tradeoff])>tolower(array[j]))

gar nicht machen, weil ja bei "int,..." Probleme kommen würden. Somit muss ich erst irgendwie feststellen ob "T" ein string,int.... ist [Funktionskopf: void sort<T>::sort_array(T *array,int length)]. Und dann halt irgendwie das so abfragen:
Wenn T ein string ist dann --> if (tolower(array[tradeoff])>tolower(array[j]))
Wenn T kein string ist dann ganz normal --> if (array[tradeoff]>array[j])

So aber wie mach ich das nun? Wie kann ich unterscheiden ob T ein "float" ist oder ein "double" oder ein "string"......???
Dankeschön schon mal im Voraus.

]]>https://www.c-plusplus.net/forum/post/1279585https://www.c-plusplus.net/forum/post/1279585Sun, 06 May 2007 10:08:48 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 10:36:28 GMT]]>Der Groß- und Kleinschreibungs - Vergleich von String ist in C++ eine etwas längere Geschichte 😃 ( Exceptional C++ oder hier: http://fara.cs.uni-potsdam.de/~kaufmann/?page=GenCppFaqs&faq=stricmp#Answ steht auch nen bissl was dazu ).

Zu deinem Problem: In dem falle würde dir TemplateSpezialisierung helfen:

template<class T> void func() { }
//func() für ints spezialsiert
template<> void func<int> () {}

Das nur auf dein Beispiel abstimmen und sorg dafür das dein Sortier-Code ausgelagert ist und deine template Funktion diese aufrufen.
Wandel die String in Groß/Klein um und übergib sie deinem sort().

]]>https://www.c-plusplus.net/forum/post/1279602https://www.c-plusplus.net/forum/post/1279602Sun, 06 May 2007 10:36:28 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 11:22:38 GMT]]>Meinst du sowas?

....
template <class T>
void sort<T>::sort_array(T *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (array[tradeoff]>array[j])
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

template <class T>
void sort<T>::sort_array<std::string>(T *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (tolower(array[tradeoff])>tolower(array[j]))
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}
.....

Das funzt aber irgendwie net bei mir.
Da kommt:

-------------- Build: Debug in Telefonbuch ---------------
Compiling: main.cpp
In file included from size.hpp:4,
from vector.hpp:4,
from set.hpp:6,
from main.cpp:2:
sort.hpp:51: error: expected init-declarator before '<' token
sort.hpp:51: error: expected `;' before '<' token
Process terminated with status 1 (0 minutes, 0 seconds)
2 errors, 0 warnings

Mh ich kenn mich leider mit templates no net so gut aus, das mit der template Spezialisierung hab ich au no nie gehört, weil ich sowas spezielles eigentlich noch nie gebraucht habe. 😃
Na ja aber es gibt ja immer ein erstes mal! 🙂
Is das sowas wie überladen, das mit der template Spezialisierung? Oder kann ich das vll. irgendwie auch mit "string" überladen? Oder ist das dann template Spezialisierung? Kann sich jemand vorstellen was ich meine?
Dankeschön schon mal im Voraus.

]]>https://www.c-plusplus.net/forum/post/1279617https://www.c-plusplus.net/forum/post/1279617Sun, 06 May 2007 11:22:38 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 12:05:12 GMT]]>Dein sort für Elementfunktion muss so aussehen:

template <>
void sort<T>::sort_array<std::string>(std::string *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (tolower(array[tradeoff])>tolower(array[j]))
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

Erinnerung: Versuche doppelten gleichen Code zu meiden.

Hier ist ein guter Artikel für Templates: http://www.c-plusplus.net/forum/viewtopic-var-t-is-128361.html

]]>https://www.c-plusplus.net/forum/post/1279628https://www.c-plusplus.net/forum/post/1279628Sun, 06 May 2007 12:05:12 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 12:26:38 GMT]]>Irgendwie funzts nicht:

#ifndef SORT_HPP_INCLUDED
#define SORT_HPP_INCLUDED

#include <string>
#include <ctype.h>

template <class T>
class sort
{
    public:
    sort();
    ~sort();
    void sort_array(T *array,int length);
    void swap(T &a,T &b);

    private:

};

template <class T>
sort<T>::sort()
{

}

template <class T>
sort<T>::~sort()
{

}
template <class T>
void sort<T>::sort_array(T *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (array[tradeoff]>array[j])
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

template <>
void sort<T>::sort_array<std::string>(std::string *array,int length)
{
    int tradeoff=0;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=i;j<length;j++)
        {
            if (tolower(array[tradeoff])>tolower(array[j]))
            {
                tradeoff=j;
            }
        }
        swap(array[i],array[tradeoff]);
    }
}

template <class T>
void sort<T>::swap(T &a,T &b)
{
    const T temp=a;
    a=b;
    b=temp;
}

#endif // SORT_HPP_INCLUDED

Aber so hast dus doch gemeint oder?

EROOR:

-------------- Build: Debug in Telefonbuch ---------------
Compiling: main.cpp
In file included from size.hpp:4,
from vector.hpp:4,
from set.hpp:6,
from main.cpp:2:
sort.hpp:52: error: T' was not declared in this scope sort.hpp:52: error: template argument 1 is invalid sort.hpp:52: error: expected init-declarator before '<' token sort.hpp:52: error: expected;' before '<' token
Process terminated with status 1 (0 minutes, 0 seconds)
4 errors, 0 warnings

Dankeschön schon mal im Voraus.

]]>https://www.c-plusplus.net/forum/post/1279635https://www.c-plusplus.net/forum/post/1279635Sun, 06 May 2007 12:26:38 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 12:48:29 GMT]]>Übergib deinem Set doch einfach als weiteren Parameter eine Comperator Klasse, die du per default auf less_then (oder wie hiesz die??) stellst. Wenn du dann eben ohne Grosz-Kleinschreibung vergleichen willst-> lies Volkards tut ein bisschen weiter bis zur NoCaseStringComperator-Klasse.

]]>https://www.c-plusplus.net/forum/post/1279648https://www.c-plusplus.net/forum/post/1279648Sun, 06 May 2007 12:48:29 GMT<![CDATA[Reply to Telefonbuchprogramm - Strings werden nach dem Sortieren nicht mehr angezeigt. on Sun, 06 May 2007 13:29:14 GMT]]>Ach murks, habe irgendwie was vercheckt 🙂
So ist es logisch und muss es aussehen:

template <>
void sort<std::string>::sort_array(std::string *array,int length)
]]>https://www.c-plusplus.net/forum/post/1279669https://www.c-plusplus.net/forum/post/1279669Sun, 06 May 2007 13:29:14 GMT