main.cpp

#include <iostream>
#include "sort.hpp"

int main()
{
    int field[10]={10,2,1,5,4,8,12,11,16,14};
    sort<int> sortieren;
    sortieren.sortArray(field,10);

	return 0;
}

sort.hpp

#ifndef SORT_HPP_INCLUDED
#define SORT_HPP_INCLUDED

template <class T>
class sort
{
    public:
    sort();
    ~sort();
    void sortArray(T *array,size_t 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>::sortArray(T *array,size_t length)
{
    T tradeoff;
    for (int i=0;i<length-1;i++)
    {
        tradeoff=i;
        for (int j=0;j<length-i;j++)
        {
            if (array[tradeoff]>array[j])
            {
                swap(array[tradeoff],array[j]);
            }
        }
    }

}

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

#endif // SORT_HPP_INCLUDED

kommt folgender Error:

-------------- Build: Debug in sort_find ---------------
Compiling: main.cpp
sort.hpp: In member function `void sort<T>::sortArray(T*, size_t) [with T = int]':
main.cpp:9: instantiated from here
sort.hpp:33: warning: comparison between signed and unsigned integer expressions
sort.hpp:36: warning: comparison between signed and unsigned integer expressions
Linking console executable: .\sort_find.exe
Process terminated with status 0 (0 minutes, 0 seconds)
1 errors, 2 warnings

Warum kommt da "instatiated from here"??? Bzw. was soll das bedeuten? Dem passt irgendwas nicht an "T tradeoff" (sort.hpp\Zeile 32), schätz ich mal?
Aber warum nicht? Was passt da nicht?
Kann mir jemand helfen? Dankeschön schon mal im Voraus.

#ifndef SORT_H__INCLUDED
#define SORT_H__INCLUDED

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

public:
	void sort_array(T*&, const size_t&);
	inline void swap(T&, T&)
	{
		T temp = a;
		a = b;
		b = temp;
	}
};

template <class T>
void sort<T>::sort_array(T*& arr, const size_t& length)
{
    T tradeoff;
    for (size_t x = 0; x < (length - 1); ++x)
    {
        tradeoff = x;
        for (size_t y = 0; y < (length - x); ++y)
            if (arr[tradeoff] > arr[y])
                swap(arr[tradeoff], arr[y]);
    }

}

#endif // SORT_H__INCLUDED

... kann man aber noch stark optimieren!

wenn aus templates ("Schablonen") "richtige" Funktionen/Klassen gemacht werden, nennt man das "instantiiert". Das macht der Compiler für Dich und er zeigt an, welche Zeile im Code ihn dazu veranlassen (das passiert nämlich nur für die Typen und Situationen, in denen sie tatsächlich verwendet werden).

Leider hast Du (wenn ich das richtig lese) den wesentlichen Teil der Fehlermeldung abgeschnitten, so dass ich Dir zu dem einen error nichts sagen kann. Die warnings kommen daher, dass Du tradeoff letztlich als (signed) int deklariert hast ... und es mit size_t (immer unsigned) vergleichst.... (und i genauso).
BTW: warum tradeoff vom Typ T sein sollte, ist mir nicht klar ... es bezeichnet doch auch nur eine Position, oder ?

Gruß,

Simon.

Die Glaskugel hat CStoll gestohlen

Hey, keine Verleumdungen - ich hab' meine eigene Glaskugel.

@Stromberg: Hat es einen Grund, daß du nicht std::sort verwendest?

CODE:

main.cpp

#include <iostream>
#include "sort.hpp"

int main()
{
    int field[10]={10,2,1,5,4,8,12,11,16,14};
    sort<int> grade;
    grade.sort_array(field,10);
    for (int i=0;i<10;i++)
    std::cout << field[i] << std::endl;

	return 0;
}

sort.hpp

#ifndef SORT_HPP_INCLUDED
#define SORT_HPP_INCLUDED

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

Dankeschön schon mal im Voraus.

template<class T>
sort(T* pArray, size_t n){...}

nicht angemessener?

habe hier jetzt nicht die ganze diskussion mitverfolgt, aber... wozu eigentlich eine klasse ohne member-variablen und ohne gar nichts? wäre hier eine

template<class T>
sort(T* pArray, size_t n){...}

nicht angemessener?

Wie ich finde, ein sehr guter Vorschlag. Wenn man unbedingt eine Klasse haben möchte, würde ich einen echten "Funktor" bauen:

template <class T>
struct sort
{
    void operator()(T *array,size_t length) {
       size_t tradeoff=0; // wenn size_t gemeint ist, sollte man es auch nehmen
       for (size_t i=0;i<length-1;i++)   {
          tradeoff=i;
          for (size_t j=i;j<length;j++)  {
             if (array[tradeoff]>array[j]) tradeoff=j;
        }
        // std::swap braucht man nicht nachzuprogrammieren
        std::swap(array[i],array[tradeoff]);
    }
// Konstruktoren und Destriktoren, die nix tun, braucht keiner
};

und schon wird auch der Aufruf übersichtlicher:

int main()
{
    int field[10]={10,2,1,5,4,8,12,11,16,14};
    sort<int> mySort;
    mySort(field,10);
    for (int i=0;i<10;i++)
    std::cout << field[i] << std::endl;

    return 0;
}

Gruß,

Simon2.

template <class T>
void sort<T>::operator() (T *array,int length)
{
    sort_array(array,length);
}

Was soll den genau ein "Funktor" sein? Is damit sowas gemeint wie ..(int length)... das ding wo man halt argumente reinschreibt?
Dankeschön schon mal im Voraus.

...
Was soll den genau ein "Funktor" sein? ...

"Funktor" = "Funktionsobjekt" = "Ein Objekt, das eigentlich nur einen Funktionsaufruf darstellt/kapselt".
Sowas wird z.B. in der C++-Standardlib gerne verwendet, weil es letztlich flexibler und syntaktisch einfacher zu handhaben ist als Funktionspointer.

Klassischerweise überlädt man den operator(), damit man es einfach aufrufen kann.
Es kann zwar "Status haben" (Attribute, über Konstruktor gesetzt, ...), sollte aber nicht allzuviel innere Logik besitzen und "einfach kopierbar" sein.

Ehrlich gesagt: Wenn Du sowieso sort_array() aufrufst, sehe ich überhaupt keinen Nährwert von dem struct mehr.... :p

Gruß,

Simon2.

Ehrlich gesagt: Wenn Du sowieso sort_array() aufrufst, sehe ich überhaupt keinen Nährwert von dem struct mehr...

Wo kommt da n struct vor?
Sorry für die blöden Fragen bin halt n Anfänger
Dankeschön schon mal im Voraus.

Mh was meinst du mit:

Ehrlich gesagt: Wenn Du sowieso sort_array() aufrufst, sehe ich überhaupt keinen Nährwert von dem struct mehr...

Wo kommt da n struct vor?...

(Übrigens: Die Frage finde ich nicht blöd - brauchst Du Dich nicht für entschuldigen)

Hier:

Stromberg schrieb:

...
void sort<T>::operator() (T *array,int length)
...

Da definierst Du die komplette Funktionalität in eine einzige public Memberfunktion einer Klasse (oder struct). Und diese Klasse beinhaltet selbst keinen "Zustand" oder irgendeine andere Funktionalität.

Mal andersherum gefragt: Warum sollte irgendein User

...
   sort<int> mySort; // Instantiierung eines Objekts + explizite Typangabe notwendig
   mySort(array, length);
...

aufrufen, wenn er viel einfacher direkt

... // Kein Objekt und keine explizite Typangabe notwendig
    sort_array(array,length);
...

nutzen könnte ?
Natürlich könntest Du ihn dazu zwingen, indem Du sort_array() "versteckst", aber warum ?

Gruß,

Simon2.

P.S.: Vielleicht kam Deine Verwirrung auch einfach daher, dass Du "class { public:" geschrieben hast, wo ich lieber "struct {" nehme.

main.cpp

#include <iostream>
#include "sort.hpp"

int main()
{
    int buffer;
    int field[10];
    for (int i=0;i<10;i++)
    {
        std::cin >> buffer;
        field[i]=buffer;
    }
    std::cout << "\n";
    sorting(field,10);
    for (int i=0;i<10;i++)
    {
        std::cout << field[i] << "\n";
    }

	return 0;
}

sort.hpp

#ifndef SORT_HPP_INCLUDED
#define SORT_HPP_INCLUDED

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

    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;
}

template <class T>
void sort<T>::operator() (T *array,int length)
{
    sort_array(array,length);
}

extern sort<int> sorting;

#endif // SORT_HPP_INCLUDED

ERROR:

-------------- Build: Debug in sortieren ---------------
Compiling: main.cpp
Linking console executable: .\sortieren.exe
obj\Debug\main.o: In function main': C:/MinGW/Andi/C++/Projekte/sortieren/main.cpp:14: undefined reference tosorting'
collect2: ld returned 1 exit status
Process terminated with status 1 (0 minutes, 0 seconds)
1 errors, 0 warnings

Dankeschön schon mal im Voraus.

Ja gut stimmt, es ist wirklich bisschen kompliziert, und viel Schreibarbeit.
Sollte ich dann vll. einfach eine Template-Funktion verwenden? ...

Japp !
Sortieren ist einfach ein ganz klassischer Algorithmus ... und hat von der Aufgabenstellung nichts "Objektartiges". Deswegen würde ich auch nicht versuchen, es als Klasse zu modellieren.

@"C++ machen": Machst Du doch ! Generische Programmierung mit templates ist absolutes C++.

Wenn Du "Klassenübungen" machen möchtest, solltest Du Dir eine andere Aufgae suchen.

Gruß,

Simon2.