[...]

Elementus

[...]

volkard

std::vector<Obst*> obstSammlung;

for(...) {
        Obst* oobject;
	switch(...) {
		case APFEL:
                {
			Apfel* aobject = new Apfel;
			aobject->methodeAusKlasseApfel();
                        oobject=aobject;
                }
		break;

		case BANANE:
                {
			Banane* bobject = new Banane;
			bobject->methodeAusKlasseBanane();
                        oobject=bobject;
                }
		break;
	}

	oobject->methodeAusKlasseObst();

	obstSammlung.push_back(oobject);
}

Elementus

[...]

volkard

Vielleicht

std::vector<Obst*> obstSammlung;

for(...) {
        Obst* oobject;
	switch(...) {
		case APFEL:
                {
			Apfel* aobject = new Apfel;
			aobject->methodeAusKlasseApfel();
                        oobject=aobject;
                }
		break;

		case BANANE:
                {
			Banane* bobject = new Banane;
			bobject->methodeAusKlasseBanane();
                        oobject=bobject;
                }
		break;
		default:
                        oobject=0;//only to make the compiler happy
                        assert(false);
	}

	oobject->methodeAusKlasseObst();

	obstSammlung.push_back(oobject);
}

Elementus

[...]

Skym0sh0

#include <vector>
#include <memory>
#include <cstdlib>

struct Base
{
	void someBaseFoo(){}

	virtual ~Base(){}
};

struct Derive1 : Base
{
	void someDerive1Foo(){}
};

struct Derive2 : Base
{
	void someDerive2Foo(){}
};

std::vector<std::unique_ptr<Base>> generate(int n)
{
	std::vector<std::unique_ptr<Base>> obj;
	obj.reserve(n);

	for(int i = 0; i < n; i++)
	{
		std::unique_ptr<Base> ptr;

		if ( i%2 == 0 )
		{
			std::unique_ptr<Derive1> ptr1(new Derive1());
			ptr1->someDerive1Foo();
			ptr = std::unique_ptr<Base>(ptr1.release());
		}
		else
		{
			std::unique_ptr<Derive2> ptr2(new Derive2());
			ptr2->someDerive2Foo();
			ptr = std::unique_ptr<Base>(ptr2.release());
		}

		ptr->someBaseFoo();
		obj.push_back(std::move(ptr));
	}

	return obj;
}

int main()
{
	auto objs = generate(rand() % 10);

	return 0;
}

(Schön finde ich den Code grad nicht oO, im Moment total java und C# gewöhnt, und meine Compiler hier sind alle noch nicht C++14 ready für z.B. std::make_unique)

So hätte ich den Teil 27-46 geschrieben:

for (int i = 0; i < n; i++) {
  auto ptr = [&]() -> std::unique_ptr<Base> {
    if (i % 2 == 0) {
      auto ptr1 = std::make_unique<Derive1>();
      ptr1->someDerive1Foo();
      return std::move(ptr1);
    } else {
      auto ptr2 = std::make_unique<Derive2>();
      ptr2->someDerive2Foo();
      return std::move(ptr2);
    }
  }();
  ptr->someBaseFoo();
  obj.push_back(std::move(ptr));
}

Wenn das zu modern ist,

ptr = std::unique_ptr<Base>(ptr1.release());

schreibt man besser als

ptr = std::move(ptr1);

.