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

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?

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.

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

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