enum SortType {SORT_QUICK};

   template<class Template>
   class CSort {
         public:
         CSort() {}
         ~CSort() {}
         static bool Compare(int & i1, int & i2) {
              if(i1 > i2) {
                    return true;
              }
              return false;
         }

         static void Sort(std::vector<Template> & List, bool (*Compare)(Template & r1, Template & r2), SortType Type);

         private:
         static void QuickSort(std::vector<Template> & List, unsigned long dwLow, unsigned long dwHigh, bool (*Compare)(Template & r1, Template & r2)){
                //Die Indizes in das zu sortierende Array initialisieren
                int iTop = dwLow;
                int iBottom = dwHigh - 1;
                int iPartitionIndex = 0;
                int iPartitionValue = 0;

                //Wenn Low >= High, muss nichts getan werden (wie auch...)
                if (dwLow < dwHigh) {
                          //Wenn die Elemente direkt hintereinander liegen, ist die unterste Sortierebene erreicht
                          if (dwHigh == (dwLow + 1)) {
                                     if(Compare(List[dwLow], List[dwHigh])) {
                                                             SwapElements(List, dwHigh, dwLow);
                                     }
                          }else {
                          //Ein Partition Element auswählen und an die letzte Position im Array schieben
                          //(damit man es in Ruhe lassen kann)
                          iPartitionIndex = static_cast<int>((dwLow + dwHigh) / 2);
                          iPartitionValue = List[iPartitionIndex];
                          SwapElements(List, dwHigh, iPartitionIndex);
                          do {
                             //Den Top Index hochzählen, bis man ein Element gefunden hat, das größer ist,
                             //als das Partition Element
                             while (!Compare(List[iTop], iPartitionValue) && (iTop <= iBottom)) {
                                   iTop++;
                             }
                             //Den Bottom Index herunterzählen, bis man ein Element gefunden hat, das kleiner 
                             //ist als das Partition Element
                             while (Compare(List[iBottom], iPartitionValue) && (iTop <= iBottom)) {
                                   iBottom--;
                             }
                             //Wenn die Indizes sich nicht getroffen haben, werden die Elemente vertauscht
                             if (iTop < iBottom) {
	                            SwapElements(List, iTop, iBottom);
                             }
                          } while (iTop < iBottom);

                          //Das Partition Element wird auf seine finale Position gesetzt
                          SwapElements(List, iTop, dwHigh);

                          //Und die Funktion für die Teile rechts und links des Partition Elements aufgerufen
                          QuickSort(dwLow, iTop - 1, Compare);
                          QuickSort(iTop + 1, dwHigh, Compare);
                          }
                }
         }
         static void SwapElements(std::vector<Template> & List, unsigned long dwFirstIndex, unsigned long dwSecondIndex) {
                Template Temp;
                Temp = List[dwFirstIndex];
                List[dwFirstIndex] = List[dwSecondIndex];
                List[dwSecondIndex] = Temp;
         }

wenn ich jetzt die funktion aufrufe kommt dieser fehler

std::vector<int> x;
CSort<int>::Sort(x,true, SORT_QUICK); //ich weiß nicht so genau was ich beim bool eingeben muss

fehlermeldung:
no matching function for call to `CSort<int>::Sort(std::vector<int, std::allocator<int> >&, bool, SortType)'

candidates are: static void CSort<Template>::Sort(std::vector<Template, std::allocator<_CharT> >&, bool (*)(Template&, Template&), SortType) [with Template = int]

std::vector<int> x;
CSort<int>::Sort(x, &CSort<int>::Compare, SORT_QUICK);

Aber das steht ja auch im Tutorial so (bzw. dort ist es eine freistehende Funktion, was auch mehr Sinn macht als sie in der Template-Klasse 'CSort' anzugeben - zumal du sie dort ohne Benutzung des Parameters 'Template' definierst hast.)

Und so gelungen ist die Klasse übrigens nicht, da sie einige Unschönheiten enthält (z.B. unterschiedliche Datentypen: int <-> DWORD).

Wenn eine Sortierfunktion benötigt wird, würde ich immer zuerst eine der Algorithmen aus der Standard-C++ Bibliothek verwenden, z.B. std::sort() oder std::stable_sort() etc.