Witam. Właśnie sobie uświadomiłem że dopiero raczkuję w programowaniu obiektowym, bo nie wiem nawet czy to jest możliwe: mam zamiar odnieść się do $zmienna znajdującej się w $obiekta w innym utworzonym przez niego obiekcie.

[PHP] pobierz, plaintext 
<?php
class A {
 
public $zmienna;
 
public function __construct() {
	$this->zmienna = asd;
	$obiektb = new B;
}
 
}
 
class B {
 
public function __construct() {
	//czy da się teraz odnieść do $zmienna w obiekta?
}
 
}
 
$obiekta = new A;
?>
[PHP] pobierz, plaintext 

Czy to jest w ogóle możliwe?

Pozdrawiam

Nie, ale możesz przekazać referencję obiektu A do obiektu B i wtedy się da

Pozdrawiam.

Rozwiązanie twojego problemu jest aż za proste

class B extends A

Rozumiem, że masz na myśli coś takiego?

[PHP] pobierz, plaintext 
<?php
class A {
 
public $zmienna;
 
public function __construct() {
	$this->zmienna = asd;
	$obiektb = new B(&$this);
}
 
}
 
class B {
 
public function __construct(&$parent) {
	echo $parent->zmienna;
}
 
}
 
$obiekta = new A;
?>
[PHP] pobierz, plaintext 

Zaczynam się zastanawiać, czy jest to dobre rozwiązanie przy większej aplikacji. Przykład powyżej był uproszczony: w rzeczywistości mam obiekt inicjujący, który wczytuje inne, tworzy i dodaje do swoich zmiennych (uciekło mi właściwe słowo). Te wczytane obiekty powinny móc się do siebie odnosić i dotychczas myślałem że będzie to możliwe bez problemów przez obiekt rodzica (inicjujący). Teraz się zastanawiam, czy przekazując za każdym razem jego instancję nie dochodzę do jakiegoś antywzorca?

Możesz dać np.

[PHP] pobierz, plaintext 
<?php
$this->var = new var ( ) ;
?>
[PHP] pobierz, plaintext 

i później

[PHP] pobierz, plaintext 
<?php
$this->var->metoZklasyVar( );
?>
[PHP] pobierz, plaintext 

nie...

@pyro, nie wiem do czego Twoja odpowiedź się odnosi, bo w cytacie znajdują się 3 pytania.

@Moli, nie zrozumiałem tego zbytnio. Chodzi mi o odniesienie się w podrzędnym obiekcie do nadrzędnego, a nie odwrotnie.

No to jak dasz

[PHP] pobierz, plaintext 
<?php
class B extends A
?>
[PHP] pobierz, plaintext 

To do metod z A dajesz

[PHP] pobierz, plaintext 
<?php
$this->metodaZklasyA();
?>
[PHP] pobierz, plaintext 

@Moli, ale ja chcę się odnieść do konkretnego obiektu zawierającego swoje zmienne i dane a nie tylko odziedziczyć jego metody No chyba że coś źle myślę?

dziedziczysz tez zmienne i inne dane od rodzica

Ale nie konkretnego. (albo jestem ciągle w błędzie). Przykład: jest obiekt $db a po nim dziedziczy $queryMaker . Dane do bazy dla $db podajemy w konstruktorze. Teraz chcemy w $queryMaker wykonać zapytanie do bazy wykorzystując obiekt $db, który został już utworzony. Chyba nie uda się to przy użyciu dziedziczenia? Singleton nie wchodzi w grę.

Dlaczego miałoby się nie udać?

[PHP] pobierz, plaintext 
<?php
 
 
	class DB
	{
		public $connected = false;
		protected $prefix = 'abc_';
 
 
		public function __construct( )
		{
			echo "Połączono z bazą danych<br />";
			$this->connected = true;
 
		}
 
		public function query( $query )
		{
			echo "Wykonujesz zapytanie:<pre>$query</pre><br />";
		}
 
	}
 
 
	class QueryMaker extends DB
	{
 
		public function makeSelect( $table, $cols = '*' )
		{
			if( $this->connected )
			{
				echo "OK, jesteś połączony<br />";
 
				$query = "SELECT $cols FROM {$this->prefix}{$table}";
				$this->query( $query );
			}
 
		}
 
	}
 
 
	$query = new QueryMaker();
	$query->makeSelect( 'tabela' );
 
	$query->makeSelect( 'tabela2', 'a, b, c' );
 
?>
[PHP] pobierz, plaintext 

Różnica jest taka, że tworzymy tylko obiekt klasy QueryMaker. Jako że klasa ta nie ma swojego konstruktora to wywoływany jest konstruktor rodzica i nawiązywane jest połączenie z bazą danych. Takie rozwiązanie ma jednak sporo wad, np.: nie da się teraz sensownie przekazać parametrów połączenia z bazą - musiałbyś przerobić klasę DB na statyczną. Trzeba także zrobić z QueryMakera Singleton bo każda nowa instancja będzie nawiązywała nowe połączenie z bazą danych.

Ja proponowałbym coś takiego:

[PHP] pobierz, plaintext 
<?php
 
 
	class DBConfig
	{
		public static $DBhost   = 'localhost';
		public static $DBuser   = 'root';
		public static $DBpass   = '';
		public static $DBname   = 'test';
		public static $DBprefix = '';
 
		public static function setConfig( array $configValues )
		{
			self::$DBhost   = $configValues['host'];
			self::$DBuser   = $configValues['user'];
			self::$DBpass   = $configValues['pass'];
			self::$DBname   = $configValues['name'];
			self::$DBprefix = $configValues['prefix'];
		}
	}
 
 
 
	class DB
	{
		private $connID = null;
 
 
		public function __construct()
		{
			echo "Następuje połączenie z serwerem '" . DBConfig::$DBuser . ":" . DBConfig::$DBpass ."@" . DBConfig::$DBhost . "' i wybranie bazy '" . DBConfig::$DBname . "'<br />";
		}
 
		public function __destruct()
		{
			echo "Koniec połączenia z serwerem<br />";
		}
 
 
		public function query( Query $query )
		{
			echo "Wykonuje zapytanie:<pre>$query</pre><br />";
		}
 
	}
 
 
 
	interface Query
	{
		public function __toString();
	}
 
 
 
	class Select implements Query
	{
		private $queryParts = array();
 
 
		public function __construct( $table, array $cols = array() )
		{
			$this->queryParts['cols'] = empty( $cols ) ? '*' : implode( ', ', $cols );
			$this->queryParts['table'] = $table;
		}
 
 
		public function where( $where )
		{
			$this->queryParts['where'] = $where;
			return $this;
		}
 
		public function order( $order, $direction = 'ASC' )
		{
			$this->queryParts['order'][] = "$order $direction";
			return $this;
		}
 
		public function limit( $a, $b = null )
		{
			$this->queryParts['limit'] = is_null( $b ) ? "$a" : "$a, $b";
			return $this;
		}
 
 
		public function __toString()
		{
			$query = "SELECT {$this->queryParts['cols']}\nFROM " . DBConfig::$DBprefix . "{$this->queryParts['table']}";
 
			if( !empty( $this->queryParts['where'] ) ) {
				$query .= "\nWHERE ( {$this->queryParts['where']} )";
			}
			if( !empty( $this->queryParts['order'] ) ) {
				$query .= "\nORDER BY " . implode( ', ',  $this->queryParts['order'] );
			}
			if( !empty( $this->queryParts['limit'] ) ) {
				$query .= "\nLIMIT {$this->queryParts['limit']}";
			}
 
 
			return $query;
		}
 
	}
 
 
	class Update implements Query
	{
		// ...
 
		public function __toString()
		{
		}
 
	}
 
	class Insert implements Query
	{
		// ...
 
		public function __toString()
		{
		}
 
	}
 
 
 
 
	$DBconfig = array(
		'host'   => 'localhost',
		'user'   => 'root',
		'pass'   => 'pass',
		'name'   => 'baza',
		'prefix' => 'abc_'
	);
	DBConfig::setConfig( $DBconfig );
 
 
 
	$DB = new DB;
 
 
	$query = new Select( 'tabela', array( 'col1', 'col2', 'col3' ) );
	$DB->query( $query );
 
	$query = new Select( 'tabela' );
	$query->where( 'col1 = 'abcde' AND ( col2 = 321 OR col3 IN ( 0, 2, 4, 6, 8 ) )' )
		  ->order( 'col1' )
		  ->order( 'col3', 'DESC' )
		  ->limit( 50, 25 );
	$DB->query( $query );
 
?>
[PHP] pobierz, plaintext 

Warto też poczytać o:
Criteria
http://www.php.net/manual/pl/language.oop5.static.php
http://www.php.net/manual/pl/language.oop5...nekudotayim.php
http://www.php.net/manual/pl/language.oop5.interfaces.php
http://www.php.net/manual/pl/language.oop5.typehinting.php

jakto nie konkretnego? DZIEDZICZYSZ DANE KONKRETNEGO DZIEDZICZONEGO RODZICA, czyli tego, którego podasz w paramtetrze extends

Kicok, dzięki wielkie Twoja odpowiedź na pewno mi się przyda przy budowie sterownika bazy Tak czy siak wróciliśmy właściwie do punktu wyjścia, czyli przekazania $DB do dowolnej klasy. Owszem, można by to było robić za każdym razem przez np. parametr w konstruktorze, ale licząc, że podobnych klas do przekazania może być kilkanaście, byłoby to niepraktyczne. Do singletonów się nie przekonam, więc myślałem jak to objeść.

Wymyśliłem utworzenie głównego obiektu $fbCore, który będzie tworzył i przechowywał wszystkie inne, przekazując im przy tworzeniu swoją instancję. Wtedy taka dołączona klasa miałaby możliwość np. do odniesienia się do wcześniej zadeklarowanej klasy bazy danych w ten sposób:
(przykładowy fragment):

[PHP] pobierz, plaintext 
<?php
class configRegistry {
	private $db;
	private $configArray;
 
	public function __construct(fbCore $fbCore) {
		$this->db = $fbCore->getObject('database');
		$this->loadConfig();
	}
?>
[PHP] pobierz, plaintext 

Po czym inne obiekty mogłyby się odnieść do configRegistry przez $fbCore->getObject('configRegistry') (z założenia prawie wszystkie obiekty byłyby tworzone od razu po zaincludowaniu ich kodu przez $dbCore. Byłaby też możliwość np. załadowania odpowiedniego modelu w klasie widoku przez $modelInstance = $fbCore->loadModel('nazwa_pliku','nazwaKlasy')

Główny problem, to czy nie dochodzimy w takiej koncepcji do jakiegoś antywzorca?

Pozdrawiam

Przenoszę na OOP

Nie będzie to jakiś antywzorzec, a przynajmniej ja tego problemu nie widzę. Możesz opisać, dlaczego tak uważasz?

Bo za każdym razem przekazujemy wszystko do wszystkiego, czyli do każdego wczytanego obiektu przekazujemy instancję $dbCore które zawiera instancje do wszystkich innych klas. Chociaż tak po przemyśleniu, chyba nie jest to aż tak strasznie zasobożerne? Druga sprawa, że od razu zakładamy że każdy wczytany obiekt musi pobierać w konstruktorze tylko instancję $dbcore. Chociaż to chyba również nie jest takie złe, bo mamy jeden interfejs do tego i porządek?

Generalnie w powyższym poście chodziło mi o ocenę pomysłu przez osobę bardziej doświadczoną z OOP. Nie chciałbym popełnić poważnych błędów już na starcie tworzenia rozbudowanej aplikacji.

Pozdrawiam

Pamiętaj, że przechowujesz tylko referencje do obiektów, więc nie jest to coś strasznego. Należy jedynie uważać z kopiami obiektów

Pozdrawiam

Problemów z kopiami raczej nie będzie, bo klasa jest includowana i obiekt z niej tworzony tylko raz, przez użycie $fbCore->loadX() . Za każdym każdym razem gdy jest potrzebny, pobieram instancję przez $dbCore->getObject() . Myślę, że to dobra metoda pod warunkiem, że uwzględni się wyjątki takie jak np. klasy abstrakcyjne.
Tak więc problem rozwiązany

Dzięki za pomoc
Pozdrawiam

Nie wiem dlaczego, ale w trakcie czytania na myśl nasunęły mi się dwa wzorce, Budowniczy i Obserwator...
(ale zmęczony jestem, więc nie analizuję tego dokładniej, muszę w końcu wypocząć... ach ten remont)



Dlatego w PHP5 domyślnie jest przy przypisaniu referencja robiona. (można wywalić & jak używasz PHP5 [a masz public więc na pewno tak jest])
Do tego kopiowanie jest ciężkie jak są złożone zależności.

Tak myśląc jednak trochę, to Budowniczy trochę jest innego zastosowania... Ale jeśli te wartości się nie zmieniają, to ustawienie ich jest najlepszym rozwiązaniem. Natomiast jeśli są zmienne to można chyba użyć obserwatora, ale to jeśli jest potrzeba reakcji na zmianę...

W sumie to coś mi się wydaje, że można by było te wartości przekazać tamtemu budowanemu obiektowi, ale musiał bym się wczytać.

(I jak już wiele razy pisałem, nie przedstawiajcie swoich rozwiązań, przemyśleń, a to co macie zrobić. Mówię tak bo to problem jest do rozwiązania, a wielokrotnie już się zdarzało, że autor proponując rozwiązanie nie przedstawił tego dobrze. Tak więc piszcie co jest problemem, a potem co najwyżej swoją propozycję, bo jak nie wiemy co dokładnie mamy rozwiązać, ciężko coś doradzić. Tak jak czy to się zmienia, czy obiekty muszą wiedzieć o zmianie itp. itd, a niże w ogóle inaczej to rozwiązać? Dlatego dobry opis problemu jest tak ważny)