ich habe eine Menge an Elementen, aus denen dasjenige, welches den niedrigsten Wert > 0 hat und ein zweites Kriterium erfüllt, ausgewählt werden soll.
Hab mal folgenden Pseudocode mit C Arrays:

// Objekte
MeineKlasse* Objekte[10];
...

// Vergleichswerte 
short Vergleichswert[10] = { 2, 5, 7, 3, 8, 1, 0, 9, 4, 6 };

// Bedingungen
bool Bedingung[10]     = { 0, 1, 0, 0, 1, 0, 0, 1, 1, 0 };

// Auswahl
int ResultatIndex = -1;
short KleinsterWert = 10;
for(int i = 0; i < 10; i++)
{
    if(Bedingung[i])
    {
        if(Vergleichswert[i] < KleinsterWert && Vergleichswert[i] > 0)
        {
            KleinsterWert = Vergleichswert[i];
            ResultatIndex = i;
        }
    }
}
if(ResultatIndex == -1)
{
    cout << "Kein Wert entspricht den Kriterien." << endl;
}
else
{
    cout << "Gesuchter Wert: " << *Objekte[ResultatIndex] << endl;
}

Mit dem Index kann ich dann das gesuchte Objekt fischen.
Das ganze soll dann aber mit mehr als 200 Werten funktionieren, anstatt nur mit 10, und soll eben dynamisch sein.
Nun dachte ich, dass das sicher schöner geht mit STL-Mitteln, doch weis ich grad nicht wie. Einfach die C Arrays mit Vectoren ersetzen?

Wäre für eventuelle Tipps sehr dankbar

Zum Suchen bietet sich eigentlich std::find_if() an. In deinem Beispiel sieht es aber so aus, als benötigtest du den Index für den Vergleichswert. Da wird find_if() wohl nicht funktionieren.

Also so ganz kapier ich das nicht.
find_if liefert einfach das erste zurück, aber nicht das mit dem kleinsten Wert. min_element sieht gut aus, es gibt aber kein min_element_if oder?
min_element benutzt ein Predicate oder den operator<. Ich müsste wohl ein eigenes Predicate machen und da die if Abfrage einbauen. Aber, ich hab die Vergleichswerte und Bedingungen ja nicht im Objekt, also extern. Wie kann ich darauf zugreifen?

Kann man solche Algorithmen selber auch machen? Gibs dafür Anleitungen?

Sorry, steh grad bisserl aufm Schlauch..

#include "stdafx.h"
#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <time.h>

using namespace std;

// Prüft auf kleiner Wert und > 0
template<class Type>
   struct lessgreaterzero : public binary_function <Type, Type, bool> 
   {
      bool operator()(
         const Type& i, 
         const Type& a
      ) const
	  {
		return i < a && i > 0;
	  }
   };

int main(int argc, char* argv[])
{
	std::vector<int> var ;

	//-------------------------------------------------------------------------------------
	// Vector befüllen mit Zuallswerten und am Anfang eine 0 um zu prüfen ob die Funktion oben geht
	srand(static_cast<int>(time(NULL)));
	var.push_back(0);	// Testen ob das > 0 klappt
	for(int i = 0; i < 100;++i)
		var.push_back(rand());
	//-------------------------------------------------------------------------------------

	// Element suchen das passt
	int index = -1;					// Index auf -1 um zu zeigen, das nichts gefunden wurde
	vector<int>::iterator pos;		// Das Ergebnis von find_if speichern
	pos = find_if(var.begin(),var.end(),bind2nd(lessgreaterzero<int>(),4000));	// Werte prüfen auf < 40000

	if(pos != var.end())				// Wenn das Ende vom Vector erreicht, wurde nichts gefunden
	 index = distance(var.begin(),pos);	// Ansonsten die Distanz von anfang bis gefundenen iterator errechnen

	//-------------------------------------------------------------------------------------
	// Alle Positionen die passen speichern und ausgeben
	vector<int> positionen;			

	pos = var.begin();				
	do
	{
		pos = find_if(pos,var.end(),bind2nd(lessgreaterzero<int>(),4000));
		if(pos == var.end())
			break;
		positionen.push_back(distance(var.begin(),pos));		

	}while(pos++ != var.end());

	// Alle index ausgeben die passen
	cout<<"vector:\n"<<endl;
	copy(var.begin(),var.end(),ostream_iterator<int>(cout,"\t"));
	cout<<"\npositionen:\n"<<endl;
	copy(positionen.begin(),positionen.end(),ostream_iterator<int>(cout,"\t"));

	return 0;
}

template <class ForwardIterator, class BinaryPredicate, class Predicate>
ForwardIterator min_element_if (ForwardIterator first,
                                ForwardIterator last,
                                BinaryPredicate comp,
                                Predicate       pred)
{
    ForwardIterator result = last;
    for (ForwardIterator = it ; it != last; it++)
    {
        if (pred(it))
            if (comp(it, result))
                result = it;
    }
    return result;
}

und dann noch zwei so structs

template <class T>
struct less_greater_zero : public binary_function <T, T, bool>
{
    bool operator() (const T& arg1, const T& arg2) const
    {
        return i > 0 && arg1 < arg2;
    }
};

template <class T>
struct has_item : public unary_function <T, bool>
{
    bool operator() (const T& arg) const
    {
        // so und hier brauch ich Zugriff auf Bedingung[arg's Index] ausm ersten Post???
    }
};

Wie kann ich dem struct has_item Zugriff auf das bool-Array geben?
Und wie komm ich an den Index von arg dran?

Wenn das so ginge wär super, macht Spass

return i > 0 && arg1 < arg2;

sollte

return arg1 > 0 && arg1 < arg2;

heissen

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm>
#include <time.h>

using namespace std;

// Prüft auf kleiner Wert und > 0
template<class Type>
   struct lessgreaterzero : public binary_function <Type, Type, bool> 
   {
      bool operator()(
         const Type& i, 
         const Type& a
      ) const
	  {
		return i < a && i > 0;
	  }
   };

int main(int argc, char* argv[])
{
	std::vector<int> var ;
	std::vector<bool> bed;
	std::vector<int>  posi;

	srand(static_cast<int>(time(NULL)));

	for(int i = 0;i < 100;++i)
	{
		int rnd = rand();
		var.push_back(rnd);
		bed.push_back(rnd < rand());

	}

	for(vector<bool>::iterator pos = bed.begin();pos != bed.end();++pos)
	{
		// Man könnte sich noch das ständige erzeugen der struktur ersparen
		if(*pos && lessgreaterzero<int>()(var[distance(bed.begin(),pos)],4000))
			posi.push_back(distance(bed.begin(),pos));
	}

	// Alle index ausgeben die passen
	cout<<"bed:\n"<<endl;
	copy(bed.begin(),bed.end(),ostream_iterator<int>(cout,"\t"));
	cout<<"vector:\n"<<endl;
	copy(var.begin(),var.end(),ostream_iterator<int>(cout,"\t"));
	cout<<"\npositionen:\n"<<endl;
	copy(posi.begin(),posi.end(),ostream_iterator<int>(cout,"\t"));
}

distance() wieder was gelernt :life:

Grübel...
Ich übergeb einfach nen Iterator auf den Bediungunsvector:

template <class ForwardIterator, class BinaryPredicate, class PredicateIterator>
ForwardIterator min_element_if (ForwardIterator first,
                                ForwardIterator last,
                                BinaryPredicate comp,
                                PredicateIterator pred)
{
    ForwardIterator result = last;
    for (ForwardIterator it = first; it != last; it++, pred++ )
    {
        if (*pred)
            if (comp(*it, *result))
                result = it;
    }
    return result;
}
//Aufruf
position = min_element_if( Vergleichswert.begin(), Vergleichswert.end(), less_greater_zero, Bedingung.begin()

Heureka?

ps: ich kompiliere grad im kopf :p

template<class Type>
struct lessbed : public binary_function <pair<Type,bool>, pair<Type,bool>, bool> 
{
  bool operator()( const pair<Type,bool>& i, const pair<Type,bool>& a) const
  {
    return i.first < a.first && i.first*i.second > 0;
  }
};