ich habe einen std::vector mit einer Fülle von Objekten. Dabei sind die Objekte durch einen Type gekennzeichnen, können aber zu diesem Typ verschiedene weitere Werte beinhalten.
Nun möchte ich herausfinden ob innerhalb des vectors objekte mit nem bestimmten Typ aber verschieden oder auch gleichen Werten vorhanden sind. Sprich die Suche muss nach dem Typ erfolgen.
Nun wollte ich mal schauen ob es dafür nicht einen std::algo gibt mit dem man das bewerkstelligen kann. Hatte hier std:count ins Auge gefasst. Nur weiß ich nicht ganz wie jetzt den vector über diesen einen Wert Typ zählen lassen könnte.
Hab als Vergleichswert nur den Typ und kein Objekt.

Oder ist es doch sinnvoller ne kleine Routine zu schreiben die einmal über den vector iteriert und bei jedem objekt mit bestimmten Typ nen zähler inkrementiert?

Gruß
CP

Vermutlich ist das einfachste und schnellst, sich das selbst zu schreiben. Hier haste den Code:

template <class InputIterator, class T>
  ptrdiff_t count ( InputIterator first, InputIterator last, const T& value )
{
  ptrdiff_t ret=0;
  while (first != last) if (*first++ == value) ++ret;
  return ret;
}

Ersetz dann eben const T& value und == durch etwas angemessenes.

dot schrieb:

Es gibt auch std::count_if()

Ahh, jetzt weiß ich ,warum man count ohne Vergleichsfunktion definiert hat :p . Ja, nimm count_if.

bool mycomparer(myobject *o) { return (o.type == typetocompare); //??? }
int mycomparefunction(type Type)
{
    if(!myvector.empty())
    {   
	mycount = (int) count_if (myvector.begin(), 
             myvector.end(), mycomparer);
          //Hier fehlt mir jetzt die Möglichkeit meinen Type zu übergeben.
	return nCount;
    }
}

Gruß
CP

Nu steh ich gerade doch etwas aufm Schlauch.
Wie kann ich das ganze denn jetzt nach meinen Ansprüchen nutzen?
Also mein Problem ist jetzt eigentlich eher wie geb ich den mit mit welchem Typ verglichen werden soll?

bool mycomparer(myobject *o) { return (o.type == typetocompare); //??? }
int mycomparefunction(type Type)
{
    if(!myvector.empty())
    {   
	mycount = (int) count_if (myvector.begin(), 
             myvector.end(), mycomparer);
          //Hier fehlt mir jetzt die Möglichkeit meinen Type zu übergeben.
	return nCount;
    }
}

Gruß
CP

So zb:

struct IntCompare
{
  int toCompare;

  IntCompare(int comp)
    : toCompare(comp)
  { }

  bool operator()(int val)
  {
    return val == toCompare;
  }
};

if(!myvector.empty())
{  
  mycount = count_if(myvector.begin(), myvector.end(), IntCompare(7));
  return mycount;
}

Oder in C++11

int mycomparefunction(type Type)
{
  return static_cast<int>(count_if(begin(myvector), end(myvector), [=](myobject* o) {
    return o->type == Type;
  }));
}

Rein prinzipiell aber vielleicht noch ein Hinweis: Überleg dir doch nochmal ganz genau, ob das, was du da treibst, so eigentlich eine gute Lösung ist. Warum brauchen diese myobject Dinger ein Feld names type? Was genau willst du da modellieren, dass du dir eigenes Typsystem bauen musst und nicht das von C++ benutzen kannst?

class My_Comparator
{
 private:
  mytype type;
 public:
  My_Comparator(const mytype& type): type(type) {}
  bool operator()(const myobject& object) { return object.type == type; }
};

// ...
count_if (myvector.begin(), myvector.end(), My_Comparator(vergleichstyp));

Eventuelle Syntaxfehler die ich beim Programmieren im Foreneditorfenster gemacht habe dienen der Vertiefung des Verstaändnisses, weil du es nicht ungelesen übernehmen kannst.

edit: Oh, viel zu langsam...

#include <boost/variant.hpp>

#include <algorithm>
#include <iostream>
#include <vector>

struct my_type{};

typedef boost::variant<int, float, double, my_type> multi_type;
typedef std::vector<multi_type> multi_type_vector;

template<typename T>
struct my_visitor : public boost::static_visitor<bool>
{
    template<typename U>
    bool operator()(U const &) const
    {
        return false;
    }

    bool operator() (T const &) const
    {
        return true;
    }    
};

template<typename T>
struct my_predicate
{
    bool operator()(multi_type const & obj) const
    {
        return boost::apply_visitor(my_visitor<T>(), obj);
    }
};

int main()
{
    multi_type_vector vec;
    vec.push_back(10);
    vec.push_back(3.14159f);
    vec.push_back(0.7071);
    vec.push_back(3.14159);
    vec.push_back(42);
    vec.push_back(my_type());

    std::cout 
        << "ints: " << std::count_if(vec.begin(), vec.end(), my_predicate<int>()) << '\n'
        << "floats: " << std::count_if(vec.begin(), vec.end(), my_predicate<float>()) << '\n'
        << "doubles: " << std::count_if(vec.begin(), vec.end(), my_predicate<double>()) << '\n'
        << "my_types: " << std::count_if(vec.begin(), vec.end(), my_predicate<my_type>()) << std::endl;
}

Dannach kannst Du einfach neue Typen zum variant hinzufügen oder wegnehmen. Der Rest geht automatisch.

Wenn Du boost benutzt, kannst Du zum Typen speichern auch boost.variant benutzen. Dann wird das relativ einfach:

Und zu 98% ein Designfehler, weil die Objekte in gemeinsamen Containern genug miteuinander zu tun haben, daß man normale Polymorphie verwenden sollte, oder weil sie so wenig miteinander zu tun haben, daß man getrennte COntainer verwenden sollte.

Tachyon schrieb:

Wenn Du boost benutzt, kannst Du zum Typen speichern auch boost.variant benutzen. Dann wird das relativ einfach:

Und zu 98% ein Designfehler, weil die Objekte in gemeinsamen Containern genug miteuinander zu tun haben, daß man normale Polymorphie verwenden sollte, oder weil sie so wenig miteinander zu tun haben, daß man getrennte COntainer verwenden sollte.

Da hast Du sicherlich recht, jedoch habe ich nichts bewertet, sondern nur eine mögliche Lösung angeboten...

Dinge wie o.type implizieren auch, dass es wohl nichts polymorphes ist.