Ich versuche gerade zum ersten mal in meinem Leben einen generischen Algorithmus zu schreiben:

- IsSorted
- SortedUntil
- SortedFrom

Leider habe ich bei meinem code bis jetzt ein Problem mit einem nicht aufgelösten externen symbol, das ich nicht verstehe....

Vllt kann von euch jemand den Fehler finden? Er entsteht beim Aufruf der bisher geschriebenen Funktion SortedUntil ohne Prädikat (alle Funktionen sollen sowohl mit als auch ohne Prädikat aufrufbar sein, wenn ohne Prädikat aufgerufen wird, soll defaul Less verwendet werden)

Hier mein bisher geschriebener Code:

Modul

//--------------------------[SortedUntil]--------------------------

// Variante mit Prädikat
template <typename TIter, typename TPred>
TIter SortedUntil(TIter begin, TIter end, TPred pred) {

	TIter TMP = begin++;

	while(begin != end && pred(*begin, *TMP)){

		if(TMP != end){TMP++;}
		begin++;		
	}
	return begin;
}

// Variante ohne Prädikat
template <typename TIter>
TIter SortedUntil(TIter begin, TIter end) {
	return SortedUntil(begin, end, std::less<typename std::iterator_traits<TIter>::value_type>());
}

Testtreiber

#include <iostream>
#include <iterator>
#include "Generic_Algos.h"

using namespace std;

int main(){

	// Declarations of TestContainers
	DataArray MyArray = {1, 2, 3, 4, 5, 6};
	cout << MyArray[2] << endl << endl;

	DataList MyList;
	MyList.push_back(5);
	MyList.push_back(2);
	MyList.push_back(1);
	MyList.push_back(9);

	DataVector MyVector;
	MyVector.push_back(7);
	MyVector.push_back(8);
	MyVector.push_back(3);
	MyVector.push_back(5);

	// teste less
	Less<int> TestBuddy;
	bool result = TestBuddy(3,4);
	if (result){cout << "Less funktioniert einwandfrei..." << endl;}

	// teste SortedUntil
	vector <int>:: const_iterator IterResult1 = SortedUntil(MyVector.begin(), MyVector.end());					// ohne Prädikat
	//vector <int>:: const_iterator IterResult2 = SortedUntil(MyVector.begin(), MyVector.end(), Greater);		// mit Prädikat

	//cout << *IterResult1 << endl;

	MyVector.clear();
	MyList.clear();

	return 0;
}

Header

// Variante mit Prädikat
template <typename TIter, typename TPred>
TIter SortedUntil(TIter begin, TIter end, TPred pred);

// Variante ohne Prädikat
template <typename TIter>
TIter SortedUntil(TIter begin, TIter end);

//-----------------------------------------------------------
// Default-Prädikat: Less
//-----------------------------------------------------------
template<typename T>
struct Less{
	bool operator() (T const& x, T const& y){
		return x < y;
	}
};

//-----------------------------------------------------------
// Prädikate zum Testen des generischen Algorithmus
//-----------------------------------------------------------

// Greater
template<typename T>
struct Greater{
	bool operator() (T const& x, T const& y){
		return x > y;
	}
};

//-----------------------------------------------------------
// Typedefs
//-----------------------------------------------------------
int const n = 6;
typedef int DataArray[n];
typedef std::list <int> DataList;
typedef std::vector <int> DataVector;

//typedef T::const_iterator DataIterator;		geht nicht!!!!!!!!

Bin noch eher Anfänger bei der STL^^

könntest du mir das kurz anhand eines Beispiels demonstrieren?

Diese Anleitung hatte ich mir schon durchgelesen, allerdings verstehe ich sie nicht so ganz^^

Was genau verstehst du nicht? Frag einfach

Meint ihr damit jetzt, dass ich alle template-vorlagen, die ich für die cpp-Funktion benötige im Header einmalig definieren muss?

Richtig. Bei Templates müssen die Definitionen überall sichtbar sein, wo du sie benutzt.