3. Anzahl von gleichen Objekten in einem std::vector herausfinden

Anzahl von gleichen Objekten in einem std::vector herausfinden

  • C

    Upps..ja die klingt besser:D Danke werd es damit mal probieren;)
    @Sepp: Ebend die Vergleichsfunktion fehlte mir hier auch:D
    Nehme count_if!!!

    0
  • C

    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

    0
  • E

    CrazyPlaya schrieb:

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

  • int mycomparefunction(type Type)
{
  struct mycomparer
  {
    type typetocompare;

    mycomparer(type typetocompare)
      : typetocompare(typetocompare)
    {
    }

    bool operator ()(myobject* o) const
    {
      return o->type == typetocompare;
    }
  };

  return static_cast<int>(count_if(myvector.begin(), myvector.end(), mycomparer(type)));
}

    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?

    0
  • Mod

    Bau einen Funktor (oder besser: einen Lambda-Ausdruck, aber ich mach mal ganz klassisch auf C++98, anstatt auf C++11). Ungetestet:

    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...

    0
  • C

    Hey ok....besten dank an alle:)
    So gehts 🙂
    @SeppJ: Deine Lösung als Klasse gefällt mir persönlich am besten!
    Lambda Ausdrücke funktionieren aber nur mit C++11 richtig?

    0
  • T

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

    #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.

    0
  • V

    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.

    0
  • T

    volkard schrieb:

    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.

    0
  • C

    Boost darf ich leider nicht benutzen...fragt mich nicht warum ist aber so und garantiert nicht meine Anweisung:)

    0
  • V

    Ich halte es für wahrscheinlicher, daß da eigentlich schon Polymorphes ist, aber der Benutzer statt mit virtuellen Funktionen selber dispatchen will. Beliebter Anfängerfehler. variant ist dabei der Pfad des Bösen. Man kann ihn beschreiten, muß aber in Kauf nehmen, daß man, ohne es noch beeinflussen zu können, immer böser wird.

    0
Anmelden zum Antworten