DesignPattern Depandency Injection mit Lazy Initialization

In PHP kann ich per instanceof in einer Bedingung prüfen ob die Klassen eine bestimmte Schnitstelle enthält um z.B. eine Lazy Initialization in einer Depandency Injection zu realisieren.

class Dependant 
{
	private $logger = NULL;

	public function set_logger(\Interfaces\Logger $logger) 
	{
		$this->logger = $logger;
	}

	// Lazy Initialization
	public function get_logger()
	{
		if(!($this->logger instanceof Interfaces\Logger))
		{
			$this->logger = new Output();
		}
		return $this->logger;
	}

	public function do_stuff()
	{
		// wenn nicht per set_logger gesetzt dann initialisieren
		$logger = $this->get_logger();
		$msg = 'i will do the right stuff<br>';
		$logger->write($msg);
	}
}

Wie geht sowas in C++?

typeid & dynamic_cast -> RTTI

Danke für die Antwort, kannst du mir ein Beispiel bringen welches ähnlich funktioniert wie meine Minilogger-Klasse?

knivil

Sorry, in Cpp programmiert man anders als in PHP. Dort ist etwas aehnliches wie instanceof nur sehr selten von Noeten. Meist ist es ein Indikator fuer ein schlechtes Design (auch in PHP). Und warum sollte ich nach dem Typ/Interfac von Logger fragen, wenn ich weiss, dass Logger dieses Interface anbieten muss?

Ok danke. In PHP ist instanceof halt eine Möglichkeit die Typisierung etwas stärker zu prüfen.

Welche bessere Möglichkeit kennst du denn um in PHP einen Klassentyp zu prüfen?

Eisflamme

Meistens muss man den Typ gar nicht explizit prüfen, da die Typsicherheit in C++ ja schon garantiert, dass Du nicht einfach nen Apfel als Birne verkaufen kannst. Es gibt auch nicht so was wie Object in Java. Wenn Du sicher stellen willst, dass eine Funktion nur Objekte von Klassen eines bestimmten Interfaces nutzt, übergibst Du eben einen Zeiger auf das Interface. Bei der Übergabe wird das entsprechende Objekt übergeben. Erbt dieses nicht vom entsprechenden Interface, gibt es automatisch einen Compilerfehler.

Beispiel:

#include <iostream>

class Interface
{
public:
virtual void foo() = 0;
};

class SomeDerived : public Interface
{
public:
virtual void foo() {std::cout << "Hi!";}
}

class SomeNotDerived
{
};

void function(Interface* blub)
{
blub->foo();
}

int main()
{
SomeDerived a;
SomeNotDerived b;
function(a); // Sauber
function(b); // Compilerfehler
return 0;
}

knivil

Ich verfahre da eher nach "garbage in, garbage out" und setze stattdessen auf Design by Contract.

Welche bessere Möglichkeit kennst du denn um in PHP einen Klassentyp zu prüfen?

Das ist eine rhetorische Frage ... ihn nicht pruefen zu muessen.

Ok, und wie funktioniert so eine Überprüfung zur Laufzeit in C++?

knivil

Du hast wohl den Unterschied zwischen statisch und dynamisch typisierten Sprachen nicht ganz verstanden ... http://de.wikipedia.org/wiki/Statische_Typisierung .

Oh sorry, klar kann ja in C++ so gar nicht funktionieren. Danke, Thread kann geschlossen werden.

Nexus

Vermeide RTTI wo möglich.
Warum explizite Typunterscheidungen schlecht sind