3. in for_each eine member-funktion aufrufen - wie?

in for_each eine member-funktion aufrufen - wie?

  • Q

    hallo,

    ich hätte da eine klasse und würde gerne folgendes realisieren:

    class Clazz {

public:
  Clazz() {
    this->model = new std::vector<std::string>(5);
  }
  ~Clazz() {
    delete model;
  }

  void add(std::string& value)
   this->model->push_back(value);
  }

  void init() {
    std::vector<std::string> tmp;
    tmp.push_back(std::string("test 1"));
    tmp.push_back(std::string("test 2"));
    tmp.push_back(std::string("test 3"));
    tmp.push_back(std::string("test 4"));
    tmp.push_back(std::string("test 5"));

    /** vector tmp durchlaufen - add methode aufrufen lassen */
    std::for_each(tmp.begin(), tmp.end(), add);
  }

private:
  std::vector<std::string> *model;
};

    wie kann ich den vector tmp durchlaufen und jedesmal
    die methode add aufrufen lassen, der ein string übergeben wird.
    ist das irgendwie möglich?

    sorry, ich bin noch anfänger! 😕

    ich wäre sehr dankbar für vorschläge.

    gruss
    QuornJulio

    0
  • K
     

    class Clazz
{
public:
  void add(std::string const& value)
  {
    model.push_back(value);
  }

  void init();

private:
  std::vector<std::string> model;
};

// in einer cpp-datei definieren:

void Clazz::init()
{
  std::vector<std::string> tmp;
  tmp.push_back("test 1");
  tmp.push_back("test 2");
  tmp.push_back("test 3");
  tmp.push_back("test 4");
  tmp.push_back("test 5");

  model.insert(model.end(),tmp.begin(),tmp.end()); // hinten dranhängen
  // oder: model = tmp; // ersetzen
}

    Die Vektor-Klasse bietet mit der insert-Funktion eigentlich das an, was du brauchst. Allerdings frage ich mich, warum du in init nicht direkt die strings an den model Vektor dranhängst und stattdessen tmp erzeugst.

    Das mit dem Zeiger da bei dir ist auch pfui. Du hast außerdem die Dreierregel verletzt. Ähnlich ist im Funktionskontext

    void foo()
{
  string* p = new string;
  ...
  delete p;
}

    der Zeiger da auch total pfui! Da schreibst du einfach:

    void foo()
{
  string s;
  ...
}

    und gut ist. Warum kompliziert, wenn es auch einfach geht?

    0
  • K

    QuornJulio schrieb:

    wie kann ich den vector tmp durchlaufen und jedesmal
    die methode add aufrufen lassen, der ein string übergeben wird.
    ist das irgendwie möglich?

    Obwohl vector<>::insert hier echt vorzuziehen wäre, will ich dir die Antwort auf deine eigentliche Frage nicht vorenthalten:

    for_each ist eigentlich erst ab C++11 in diesem Fall vernünftig einsetzbar, es sei denn, du magst dir einen eigenen Funktor schreiben oder findest boost::bind okay.

    // for_each + Lambda (C++11):
for_each(begin(tmp),end(tmp),[this](string const& s){this->add(s);});

// for_each + boost::bind oder std::bind (letzteres ist auch C++11)
for_each(tmp.begin(),tmp.end(),bind(add,this,_1));

    Weitere Alternative:

    // copy + back_inserter
copy(tmp.begin(),tmp.end(),back_inserter(model));

    Da geht sicherlich noch einiges 😉

    Aber wie gesagt, vector<>::insert ist interessanter, da so nicht Elemente einzeln eingefügt werden sondern in einem Rutsch. Hier kann der vector sich auch besser darauf einstellen, wieviel Platz er noch so reservieren muss, falls nicht mehr alle Elemente da im freien Platz reinpassen.

    0
  • C
    Mod

    Der usprüngliche Code ist nich besonders sinnvoll. Erst wird ein Vektor mit 5 leeren Strings erzeugt. Und dann sollen 5 weitere angehängt werden? Noch dazu in einer Funktion, die sich init nennt?

    Vom Ergebnis her gedacht, dürfte eine direkte Initialisierung im Konstrukor das Richtige sein

    class Clazz
{
public:
  Clazz()
    : model{"test 1", "test 2", "test 3", "test 4", "test 5"}
  {}

private:
  std::vector<std::string> model;
};
    0
  • Q

    hallo,

    es ging mir ausschließlich um den aufruf von "add" in for_each.
    folgende möglichkeiten kenne ich:

    void add(const std::string& value) {
	std::cout << value << std::endl;
}

struct printVector {
	void operator()(const string& value) {
		std::cout << value << std::endl;
	}
} print;

int main() {
	std::vector<std::string> mVector;
	mVector.push_back("Test 1");
	mVector.push_back("Test 2");

        std::for_each(mVector.begin(), mVector.end(), add);
        /**
         * Auch möglich.
         * std::for_each(mVector.begin(), mVector.end(), print);
         */
	return 0;
}

    aber eben eine member-methode aufrufen, war mir nicht "bekannt".
    mit boost::bind hat es dann geklappt.

    std::for_each(tmp.begin(), tmp.end(), boost::bind(&Clazz::add, this, _1));

    bedanke mich sehr für eure tipps. 👍

    gruss
    QuornJulio

    0
Anmelden zum Antworten