Daher ich mir wegen der größe nicht sicher bin würde ich ein std::vector verwenden (bitte korrigieren falls es was besseres gibt), und nun möchte ich noch ein paar funktion erstellen wie zum beispiel

std::vector<Obst> meinContainer;

void CommandMap::registerCommand(const Obst& obst)
{
    if(std::find(meinContainer.begin(), meinContainer.end(), obst.getName()) != meinContainer.end()) //funktioniert nicht
    {
        /* mein vector beinhaltet das Objekt */
    }
    else
    {
        meinContainer.push_back(obst.getName());
    }
}

Allerdings funktioniert der Code bei mir nicht

error: no matching function for call to 'find(std::vector<Obst>::iterator, std::vector<Obst>::iterator, std::string)'

In deinem vector sind Obst , du suchst aber anscheinend nach einem std::string . Dafür muss ein Operator== findbar sein, der ein Obst mit einem std::String vergleicht. Ist das beabsichtigt? Falls dies nicht beabsichtigt ist und ein solche Operator nicht vorhanden ist, sähe die Fehlermeldung jedoch anders aus.
Vermutlich willst du wohl eher direkt nach obst suchen, anstatt nach obst.getName() .

$Obst["banane"] $banane; //Banane ist ein Obejkt welches von Obst erbte

damit ich dann solche funktion wie

if(isset($obst["banane"])
{
    $obst["banane"]->eat();
}

in c++ machen kann. Doch das funktioniert scheinbar nicht mit Vectoren...
Hast oder jemand anders einen vorschlag?

std::map wäre hier wohl die beste Wahl.

Dein Code könnte dann in etwa so aussehen:

#include <map>

std::map<std::string, Obst> meinContainer;

void CommandMap::registerCommand(const Obst& obst)
{
    auto iter = meinContainer.find(obst.getName());
    if(iter == meinContainer.end())
    {
        meinContainer.insert({obst.getName(), obst});
    }
}

// Dann kannst du auch so darauf zugreifen:
meinContainer["banane"].eat();

Ich glaube was du benötigst, ist ein assoziatives Array (bzw. Container).

Singender Holzkuebel hat Recht aber so lange du keine alphabetische Sortierung benoetigst solltest Du eine hash map verwenden <unordered_map>.

Die outperformed die normale Map in allen belangen.
(Jedenfalls so lange der Key eine vernuenftige Laenge hat aber wer hat schon Keys mit ueber 150 Zeichen.)

auto iter = meinContainer.find(obst.getName());

was macht das "auto"?

Dankeschön Singender Rotzrübel
jedoch h#tte ich da noch eine frage bezühlich dieser zeile:

auto iter = meinContainer.find(obst.getName());

was macht das "auto"?

Auto ist nur eine Abkuerzung fuer:

std::map<std::string,Obst>::iterator iter;

Main Klasse

bool isGood()
{
    auto iter = meinContainer.find(name);
    return iter != meinContainer.end();
}

Garten::Obst aufheben()
{
    if(isGood(name))
    {
        meinContainer[name].eat();
        return true;
    }
    return false;
}

Wie der obrige Code zeigt will ich die funktion eat() aufrufen.
Dabei wird die Funktion eat() von der Obst klasse aufgerufen anstatt die von dem
(als beispiel) "apfel"

Codes:

class Obst
{
public:
    Obst();
    virtual void eat()
    {
        std::cout << "eat() wurde vom Obst aufgerufen";
    }
}

class apfel : public Obst
{
public:
    apfel() : Obst()
    {
      //meine codes
    }

    virtual void eat()
    {
        std::cout << "eat() wurde vom Apfel aufgerufen";
    }
}

Und ich möchte anstatt eat() von der Obst klasse, die eat() von der Apfel klasse aufrufe. Doch wie kann ich das machen?

Aber das wird jetzt ganz schnell mal eben non-trivial...

Apfel x = ...;
Obst y = x;

Hier sind x und y keine Referenzen, keine Zeiger oder was man dazu auch sonst in PHP sagen mag. x und y sind die Objekte selbst. Hier wird nur der Obst-Teil des Apfelobjekts x nach y kopiert, genauso wie bei

int x = 1729;
int y = x;

der Wert von x in y reinkopiert wird. Mit anderen Worten: In C++ sind Indirektionen nicht implizit für Klassentypen. Wenn du etwas Zeiger-artiges haben willst, nimm etwas Zeiger-artiges.

Dann kommt auch gleich das nächste Problem: Du weißt wahrscheinlich noch nichts von RAII, dem Ownership-Konzept und so weiter.

Du hast also viel Nachholbedarf! Erwarte nicht, dass du hier kostenlose Privatstunden bekommst. Also: Schnapp dir ein gutes, schlaues C++ Buch und lerne.

Geht das wirklich nicht anderst Ich würde das sehr gerne in dieser methode ausführen

So zum Beispiel (ist ziemlich ähnlich, nur dass zeiger verwendet werden):

#include <memory>
#include <unordered_map>
#include <iostream>
#include <string>

using namespace std;

struct Fruit
{
	string name() const { return "Fruit"; }
	virtual void eat() const { cout << "eat() from fruit!\n"; }
};

struct Apple : Fruit
{
	string name() const { return "Apple"; }
	void eat() const override { cout << "eat() from apple!\n"; }
};

struct Banana : Fruit
{
	string name() const { return "Banana"; }
	void eat() const override { cout << "eat() from banana!\n"; }
};

int main()
{
	using FruitBox = unordered_map<string, unique_ptr<Fruit>>;

	auto fruit = make_unique<Fruit>();
	auto apple = make_unique<Apple>();
	auto banana = make_unique<Banana>();

	FruitBox fruits;
	fruits[fruit->name()] = move(fruit);
	fruits[apple->name()] = move(apple);
	fruits[banana->name()] = move(banana);

	for (auto const &f : fruits)
	{
		f.second->eat();
	}
}