Niubbo OOP: problema di scope?

[andr3a]

Se __constructor e' private ma non bloccate il __clone il singleton va a farsi benedire.
Per il discorso __consturctor contro nome classe ho letto qualche superficialita'.

In primo luogo, non sono la stessa cosa. In PHP5 si usa __construct, senza se o ma.

La ragione e' semplicissima, si evita di rompere ereditarieta' e logica. Esempio:

class A {
    public  function    __construct(){
        echo 'A';
    }
}

class B extends A {
    public  function    __construct(){
        parent::__construct();
        echo 'B';
    }
}

new B; // AB

Il codice qui sopra e' valido ... ma se noi scriviamo questo:

class B extends A {
    public  function    __construct(){
        parent::A();
        echo 'B';
    }
}

il parser generera' un errore poiche' A non e' definito.
Definire il costruttore due volte, seppur __constructor abbia priorita', e' un altro errore, segnalato in strict standard.

qualora invece A sia una vecchia classe da estendere compatibile PHP4, questo codice funzionera' senza problemi:

class A {
    public  function    A(){
        echo 'A';
    }
}

class B extends A {
    public  function    __construct(){
        parent::__construct(); // va bene, purche' ci sia un costruttore vecchio o nuovo
        echo 'B';
    }
}

new B; // AB

ed ecco spiegato il perche' abbiano lasciato, esclusivamente per retrocompatibilita', la possibilita' di chiamare il costruttore come la classe.
E' errato usare il nome della classe come costruttore, dire che "__constructor non mi piace" e' a dir poco inutile, questo e' PHP5

[pictor]

Grazie mille delle delucidazioni

Originariamente inviato da andr3a
E' errato usare il nome della classe come costruttore, dire che "__constructor non mi piace" e' a dir poco inutile, questo e' PHP5

Ovviamente il "non mi piace" va bene finchè c'è scelta. Se è sbagliato inizio ad usare __constructor!

[andreamk]

Originariamente inviato da pictor
Se faccio così però la classe 'singleton' non può più instanziare oggetti MySQL.... c'è un modo per rendere il costruttore privato ma lasciarlo disponibile alla classe singleton?

Se rendi la classe MySql singleton l'unico modo per avere un istanza di MySql e' fare MySql::geInstance(). Server proprio a quello

Ma devo quindi modificare la classe 'singleton' o la classe 'MySQL'? Non mi è chiaro....

Se rendi MySql singleton la classe singleton non funzioan piu e non serve piu.

Ma se invece lo istanzio tramite

singleton::getInstance('MySQL'); 

?

Cosa cambia? Perchè l'articolo non sembra fare differenza!

Fa differenza difatti l'articolo (che mi è toccato leggere ) introduce la definizione della classe singleton nel modo standard e poi crea una classe che emula il funzionamento del singleton ma solo in parte.

La differenza sostanziale e' che se hai una classe singleton standard (con l'inibizione anche del clone come faceva notare giustamente andr3a) cascasse il mondo sei sicuro che nessuno mai l'istanzierà due volte.

Con il metodo rivisitato dall'articolo sei sicuro di questo solo se usi solo quella classe.
Infatti in quel modo nessuno ti vieta di fare

$primaIstanza = singleton::getInstance('MySql');
$secondaIstanza = new MySql(); 

[pictor]

Originariamente inviato da andreamk
Se rendi la classe MySql singleton l'unico modo per avere un istanza di MySql e' fare MySql::geInstance(). Server proprio a quello

Oh meno male che non sono l'unico che scrive "server" erroneamente ogni tre per due

Se rendi MySql singleton la classe singleton non funzioan piu e non serve piu.

Ecco infatti mi pareva ....

Fa differenza difatti l'articolo (che mi è toccato leggere mannaggia a te) introduce la definizione della classe singleton nel modo standard e poi crea una classe che emula il funzionamento del singleton ma solo in parte.

Ehehe scusa se l'hai dovuto leggere. Dai, un ripassino non fa mai male, no?

La differenza sostanziale e' che se hai una classe singleton standard (con l'inibizione anche del clone come faceva notare giustamente andr3a) cascasse il mondo sei sicuro che nessuno mai l'istanzierà due volte.

Con il metodo rivisitato dall'articolo sei sicuro di questo solo se usi solo quella classe.
Infatti in quel modo nessuno ti vieta di fare

$primaIstanza = singleton::getInstance('MySql');
$secondaIstanza = new MySql(); 

E' quello che pareva pure a me..... infatti quell'articolo secondo me confonde un pochino...

[andr3a]

... esempio singleton ... PHP 5

class MySQL {
    
    static  private $_mysql;        // istanza
    static  private $_connection;   // connessione

    // parametri connessione
    private $_host,
            $_db,
            $_user,
            $_pass
    ;
    
    // parametri alla prima chiamata, poi non necessari
    static  public  function    getInstance($host = '', $db = '', $user = '', $pass = ''){
        return  isset(self::$_mysql) ? self::$_mysql : (self::$_mysql = new self($host, $db, $user, $pass));
    }
    
    // costruttore, una volta sola
    private function    __construct($host, $db, $user, $pass){
        self::$_connection = mysql_connect($host, $user, $pass);
        mysql_select_db($db, self::$_connection);
        $this->_host = $host;
        $this->_db = $db;
        $this->_user = $user;
        $this->_pass = $pass;
    }
    
    // no clone
    public  function    __clone(){
        throw new Exception('non puoi farlo');
    }
    
    // chiudi connessione se distrutto (e non era stato deserializzato)
    public  function    __destruct(){
        if(is_resource(self::$_connection))
            mysql_close(self::$_connection);
    }
    
    // cosa salvi se serializzato
    public  function    __sleep(){
        return  array('_host', '_db', '_user', '_pass');
    }
    
    // cosa fai al wakeup ... sempre sinlgeton, oggetto diverso, connessione sempre uguale
    public  function    __wakeup(){
        self::getInstance($this->_host, $this->_db, $this->_user, $this->_pass);
    }
    
    // esempio layer per query
    public  function    query($sql){
        return  mysql_query($sql, self::$_connection);
    }
}

... qualche test ...

$a = MySQL::getInstance('localhost:3307', 'test', 'root', '');
$b = MySQL::getInstance();
echo    '<pre>';
var_dump($b === $a);
$c = unserialize(serialize($b));
var_dump($c);
// $d = clone $c; // errore
$q = $c->query('SELECT 123');
while($row = mysql_fetch_row($q))
    echo    $row[0]."\n";
echo    '</pre>';

sarebbe piu' sicuro e corretto usare un metodo crypt e decrypt in serializzazione per evitare di esporre dati sensibili qualora si voglia serializzare un singleton.

La serializzazione in questo caso genera un'istanza differente (normale comportamento della de-serializzazione) ma almeno e' possibile salvare una singleton (diciamo che e' solo un esempio per mostrare alcuni concetti base di PHP 5 ... da studiare, piu' che da usare)