[PHP] Perchè mi dice che stò chiamando una funzione non definita ?!?!

[e-commerce84]

Quando provo a far girare la seguente classe con un esempio (inserito subito sotto la fine della classe) mi dà il seguente messagio di errore: Fatal error: Call to undefined function sinistro() in C:\xampp\htdocs\PHPEsempi\algoritmiOrdinamento\Heap.php on line 43

La linea di codice incriminata è:

if(sinistro($nodo_i) > $this->$heapSize) return;


Ma come si può vedere nel codice il metodo sinistro() è stato definito !!! Come mai dà questo errore?


<?php

/* Classe che implementa la struttura dati HEAP e la sua funzionalità per
l'ordinamento di una collezione mediante l'algoritmo di ordinamento
Heap Sort */

class Heap{

/* Variabile di istanza che implementa la struttura dati ad albero
dell'heap per mezzo di un array */
private $heap = array();
private $heapSize = 0; // Numero di elementi correntemente dentro l'HEAP

/* Costruttore: Crea un nuovo oggetto istanza di Heap. Riceve un qualunque
array come parametro di input, lo copia dentro alla
variabile di istanza heap[] (mettendoli dentro l'array Heap
a partire dalla posizione 1) e su di esso richiama ilmetodo
di classe heapify per trasformarlo in loco in un heap */

public function __construct($arr=array()){

/* Scorre l'array ricevuto come parametro e lo copia nel'array heap
traslando gli elementi una posizione in avanti (per farli partire dalla
posizione 1 e non 0) */
foreach($arr as $chiave => $valore){
$heap[$chiave+1] = $arr[chiave]; // Copia gli elementi traslandoli
$heapSize ++; //Incrementa di 1 il numero elementi inseriti nell'heap
}

/* Invoca il metodo heapify sull'array partendo dalla prima posizione che
sarà trasformato in un HEAP */
$this->heap = $this->heapify($heap, 1);
}


/* Metodo che dato un qualsiasi array lo riarrangia trasformandolo in una
struttura dati HEAP memorizzata sempre nello stesso array di partenza */

private function heapify($heap, $nodo_i){
echo "heapify è stata chiamata<br />";
$sin = sinistro($nodo_i); // Posizione della radice del sottoalbero sinistro
/* CASO BASE: Se heap è vuoto ritorna al chiamante */
if(sinistro($nodo_i) > $this->$heapSize) return;

/* Altrimenti procedi ricorsivamente nel seguente modo */
else{
$sin = sinistro($nodo_i); // Posizione della radice del sottoalbero sinistro
$des = destro($nodo_i); // Posizione della radice del sottoalbero destro

$nodoCorrente = $sin;
heapify($heap, $nodoCorrente); // Chiama ricorsivamente sul sottoalbero sinistro
$nodoCorrente = $des;
heapify($heap, $nodoCorrente); // Chiama ricorsivamente sul sottoalbero destro

fixHeap($nodoCorrente, $heap);
}

}

/* Metodo che prende in input un quasi heap (cioè un heap con al più
un'anomalia) ed un indice nodo_i e restituisce un heap corretto */
private function fixHeap($nodo_i, $quasiHeap){
$sin; // Conterrà l'indice del figlio sinistro
$des; // Conterrà l'indice del figlio destro
$max; // Conterrà l'indice del figlio avente valore massimo

/* Se nodo_i è una foglia allora ritorna al chiamante (caso base)*/
if(sinistro($nodo_i) > $this->$heapSize) return;

/* Se nodo_i non è una foglia */
else{
$sin = sinistro($nodo_i); // Posizione del figlio sinistro
$des = destro($nodo_i); // Posizione del figli destro

/* Trova il massimo tra il figlio sinistro e destro di nodo_i */
if($quasiHeap[sin] >= $quasiHeap[$des]) $max = $sin;
else $max = $des;

/* Se il valore in posizione nodo_i è MINORE del valore del figlio
massimo */
if($quasiHeap[$nodo_i] < $quasiHeap[$max]){
$tmp = $quasiHeap[$nodo_i]; // Salva il valore in posizione i
/* Scambia il valore in posizione nodo_i con il valore in
posizione max */
$quasiHeap[$nodo_i] = $quasiHeap[max];
$quasiHeap[$max] = $tmp;

/* Invoca ricorsivamente il metodo fixHeap() passandogli come
parametro lo stesso array e la posizione max */
fixHeap($max, $quasiHeap);
}
}
}

/* Metodo che dato l'indice di un elemento dell'heap calcola l'indice del
suo figlio sinistro nell'heap */
private function sinistro($indicePadre){
$sin = $indicePadre*2; // Calcola l'indice del figlio sinistro
return $sin; // Ritorna il valore di sin al chiamante
}

/* Metodo che dato l'indice di un elemento dell'heap calcola l'indice del
suo figlio destro nell'heap */
private function destro($indicePadre){
$des = $indicePadre*2 + 1; // Calcola l'indice del figlio destro
return $padre; // Ritorna il valore di des al chiamante
}

/* Metodo che dato un elemento dell'heap calcolal'indice del padre */
private function padre($indiceNodo){
$padre = floor(i/2); // Calcola la parte intera
return $padre; // Ritorna al chiamante la posizione del padre
}

}

echo "Test HEAP <br \>\n";
$arr = array(70,10, 14, 18, 11, 27);

$myHeap = new Heap($arr);
?>


Tnx

[vhost87]

Mmmm...

if($this->sinistro($nodo_i) > $this->$heapSize) return;

E' un metodo di un oggetto! Non una funzione :)

[e-commerce84]

Mmmm...

if($this->sinistro($nodo_i) > $this->$heapSize) return;

E' un metodo di un oggetto! Non una funzione :)

e come avrei dovuto fare allora? :cry:

[vhost87]

Te l ho scritto nel codice! Mettendoci $this-> davanti ! :D
Guarda sopra!

[e-commerce84]

Te l ho scritto nel codice! Mettendoci $this-> davanti ! :D
Guarda sopra!

mmm mettendo quello che mi hai detto te:
if($this->sinistro($nodo_i) > $this->$heapSize) return;

Continua a darmi: Fatal error: Cannot access empty property in C:\xampp\htdocs\PHPEsempi\algoritmiOrdinamento\Heap.php on line 43
:muro: :muro: :muro: :muro:

[vhost87]

Mmmm l'errore è cambiato; la linea è sempre la stessa? Sicuro?

[e-commerce84]

Mmmm l'errore è cambiato; la linea è sempre la stessa? Sicuro?

Si ho provato a cambiarla così e non dà più errore:
if($this->sinistro($nodo_i) > $this->heapSize) return;

Perchè?

Ora però ho un altro problema ancora che non sò proprio da cosa possa dipendere...nella classe ho inserito un altro metodo stampaHeap() che mi dovrebbe stampare il contenuto dell'array heap...ma non stampa nulla :muro: :muro: :muro:

Questo è il codice completo:


<?php

/* Classe che implementa la struttura dati HEAP e la sua funzionalità per
l'ordinamento di una collezione mediante l'algoritmo di ordinamento
Heap Sort */

class Heap{

/* Variabile di istanza che implementa la struttura dati ad albero
dell'heap per mezzo di un array */
private $heap = array();
private $heapSize = 0; // Numero di elementi correntemente dentro l'HEAP

/* Costruttore: Crea un nuovo oggetto istanza di Heap. Riceve un qualunque
array come parametro di input, lo copia dentro alla
variabile di istanza heap[] (mettendoli dentro l'array Heap
a partire dalla posizione 1) e su di esso richiama ilmetodo
di classe heapify per trasformarlo in loco in un heap */

public function __construct($arr=array()){

/* Scorre l'array ricevuto come parametro e lo copia nel'array heap
traslando gli elementi una posizione in avanti (per farli partire dalla
posizione 1 e non 0) */
foreach($arr as $chiave => $valore){
$heap[$chiave+1] = $arr[chiave]; // Copia gli elementi traslandoli
$heapSize ++; //Incrementa di 1 il numero elementi inseriti nell'heap
}

/* Invoca il metodo heapify sull'array partendo dalla prima posizione che
sarà trasformato in un HEAP */
$this->heap = $this->heapify($heap, 1);
}


/* Metodo che dato un qualsiasi array lo riarrangia trasformandolo in una
struttura dati HEAP memorizzata sempre nello stesso array di partenza */

private function heapify($heap, $nodo_i){
echo "heapify è stata chiamata<br />";

/* CASO BASE: Se heap è vuoto ritorna al chiamante */
if($this->sinistro($nodo_i) > $this->heapSize) return;

/* Altrimenti procedi ricorsivamente nel seguente modo */
else{
$sin = sinistro($nodo_i); // Posizione della radice del sottoalbero sinistro
$des = destro($nodo_i); // Posizione della radice del sottoalbero destro

$nodoCorrente = $sin;
heapify($heap, $nodoCorrente); // Chiama ricorsivamente sul sottoalbero sinistro
$nodoCorrente = $des;
heapify($heap, $nodoCorrente); // Chiama ricorsivamente sul sottoalbero destro

fixHeap($nodoCorrente, $heap);
}

}

/* Metodo che prende in input un quasi heap (cioè un heap con al più
un'anomalia) ed un indice nodo_i e restituisce un heap corretto */
private function fixHeap($nodo_i, $quasiHeap){
$sin; // Conterrà l'indice del figlio sinistro
$des; // Conterrà l'indice del figlio destro
$max; // Conterrà l'indice del figlio avente valore massimo

/* Se nodo_i è una foglia allora ritorna al chiamante (caso base)*/
if(sinistro($nodo_i) > $this->$heapSize) return;

/* Se nodo_i non è una foglia */
else{
$sin = sinistro($nodo_i); // Posizione del figlio sinistro
$des = destro($nodo_i); // Posizione del figli destro

/* Trova il massimo tra il figlio sinistro e destro di nodo_i */
if($quasiHeap[sin] >= $quasiHeap[$des]) $max = $sin;
else $max = $des;

/* Se il valore in posizione nodo_i è MINORE del valore del figlio
massimo */
if($quasiHeap[$nodo_i] < $quasiHeap[$max]){
$tmp = $quasiHeap[$nodo_i]; // Salva il valore in posizione i
/* Scambia il valore in posizione nodo_i con il valore in
posizione max */
$quasiHeap[$nodo_i] = $quasiHeap[max];
$quasiHeap[$max] = $tmp;

/* Invoca ricorsivamente il metodo fixHeap() passandogli come
parametro lo stesso array e la posizione max */
fixHeap($max, $quasiHeap);
}
}
}

/* Metodo che dato l'indice di un elemento dell'heap calcola l'indice del
suo figlio sinistro nell'heap */
private function sinistro($indicePadre){
$sin = $indicePadre*2; // Calcola l'indice del figlio sinistro
return $sin; // Ritorna il valore di sin al chiamante
}

/* Metodo che dato l'indice di un elemento dell'heap calcola l'indice del
suo figlio destro nell'heap */
private function destro($indicePadre){
$des = $indicePadre*2 + 1; // Calcola l'indice del figlio destro
return $padre; // Ritorna il valore di des al chiamante
}

/* Metodo che dato un elemento dell'heap calcolal'indice del padre */
private function padre($indiceNodo){
$padre = floor(i/2); // Calcola la parte intera
return $padre; // Ritorna al chiamante la posizione del padre
}

/* Metodo per stampare l'heap */
public function stampaHeap(){
for($i=1; $i<=$heapSize; $i++)
echo $heap[i];
}

}

echo "Test HEAP <br \>\n";
$arr = array(70,10, 14, 18, 11, 27);

$myHeap = new Heap($arr);
$myHeap->stampaHeap();


?>


Come mai questa cosa? Dici che c'è qualche altro problema semantico più serio sotto? :cry:

[vhost87]

Non mi convince il passaggio di parametri...

la variabile $heap, se privata, come fa a prendersela il metodo di stampa?
Dovrai passargliela come parametro no?

[e-commerce84]

Non mi convince il passaggio di parametri...

la variabile $heap, se privata, come fa a prendersela il metodo di stampa?
Dovrai passargliela come parametro no?

Scusa...ma se io faccio così non dovrebbe andare bene?

La mia variabile heap è privata, quindi è visibile solo nella classe. Se io dichiaro un metodo PUBLICO interno alla classe che stampa heap questo dovrebbe funzionare da interfaccia tra l'utente che usa la classe ed il contenuto della classe che è privato...per fare information hiding e nascondere l'implementazione della classe.
Se io dichiaro privata la variabile heap è perchè non voglio far sapere all'utente che usa la classe come l'ho implementata...e gli fornisco un metodo stampa() d'interfaccia...

O sbaglio qualcosa?

Grazie

[vhost87]

Scusa...ma se io faccio così non dovrebbe andare bene?

La mia variabile heap è privata, quindi è visibile solo nella classe. Se io dichiaro un metodo PUBLICO interno alla classe che stampa heap questo dovrebbe funzionare da interfaccia tra l'utente che usa la classe ed il contenuto della classe che è privato...per fare information hiding e nascondere l'implementazione della classe.
Se io dichiaro privata la variabile heap è perchè non voglio far sapere all'utente che usa la classe come l'ho implementata...e gli fornisco un metodo stampa() d'interfaccia...

O sbaglio qualcosa?

Grazie

Mmmm secondo me devi definire globale la variabile... in modo che tutti i metodi dell'oggetto possano accedervi

[e-commerce84]

Mmmm secondo me devi definire globale la variabile... in modo che tutti i metodi dell'oggetto possano accedervi

Ma se è globale non la vedono anche fuori dalla classe?
Cmq credo che ci sia proprio un problema a livello semantico...ho provato anche ad inserire un echo $heap[1]; alla fine del costruttore...e non viene visualizzato nulla...è come se l'array heap fosse vuoto...doh

[vhost87]

Ma se è globale non la vedono anche fuori dalla classe?

Da quel che ricordo io della OOP no :)

[e-commerce84]

Da quel che ricordo io della OOP no :)

mmm aspe te che intendi per globale? e come faccio a dirgli che quella variabile deve essere globale? non intendi pubblica giusto?

[vhost87]

mmm aspe te che intendi per globale? e come faccio a dirgli che quella variabile deve essere globale? non intendi pubblica giusto?

No intendo globale, con la parola riservata global;

Le variabili globali sono variabili che possono venire usate da tutte le procedure e dal programma principale. Si tratta di variabili che sono definite al di fuori delle procedure, e che sono accessibili da tutti i blocchi del programma.

[e-commerce84]

No intendo globale, con la parola riservata global;

Le variabili globali sono variabili che possono venire usate da tutte le procedure e dal programma principale. Si tratta di variabili che sono definite al di fuori delle procedure, e che sono accessibili da tutti i blocchi del programma.

Quindi dici che dovrei definire globale la variabile private heap?

Intendi così: private global $heap = array();

Però mi da il seguente errore: Parse error: parse error, expecting `T_VARIABLE' in C:\xampp\htdocs\PHPEsempi\algoritmiOrdinamento\Heap.php on line 11

Che intendi esattamente?

[vhost87]

Quindi dici che dovrei definire globale la variabile private heap?

Intendi così: private global $heap = array();

Però mi da il seguente errore: Parse error: parse error, expecting `T_VARIABLE' in C:\xampp\htdocs\PHPEsempi\algoritmiOrdinamento\Heap.php on line 11

Che intendi esattamente?

O è privata o è globale :)

[e-commerce84]

O è privata o è globale :)

Anche questo è vero...tuttavia se faccio:
global $heap = array();

mi da sempre
Parse error: parse error, expecting `T_FUNCTION' in C:\xampp\htdocs\PHPEsempi\algoritmiOrdinamento\Heap.php on line 11

[vhost87]

Anche questo è vero...tuttavia se faccio:
global $heap = array();

mi da sempre
Parse error: parse error, expecting `T_FUNCTION' in C:\xampp\htdocs\PHPEsempi\algoritmiOrdinamento\Heap.php on line 11

Scopro ora che non puoi indicare un array globale? :D :D

[e-commerce84]

Scopro ora che non puoi indicare un array globale? :D :D

Si ma cmq non credo dipenda da quello...in Java ho fatto varie cose analoghe...almeno così mi sembra di ricordare...

L'altra cosa che mi fa sospettare che non dipenda da quello è il fatto che se provo a far visualizzare (come test) ad esempio il primo elemento dell'array heap alla fine del costruttore non mi visualizza nulla...quindi mi viene il sospetto che per qualche motivo non popoli proprio l'array heap :cry: :cry: :cry:

Mi servirebbe un debbugger che mi fa vedere passo passo cosa succede...ne esistono?

[vhost87]

Si ma cmq non credo dipenda da quello...in Java ho fatto varie cose analoghe...almeno così mi sembra di ricordare...

L'altra cosa che mi fa sospettare che non dipenda da quello è il fatto che se provo a far visualizzare (come test) ad esempio il primo elemento dell'array heap alla fine del costruttore non mi visualizza nulla...quindi mi viene il sospetto che per qualche motivo non popoli proprio l'array heap :cry: :cry: :cry:

Mi servirebbe un debbugger che mi fa vedere passo passo cosa succede...ne esistono?

certo, o utilizzi la funzione print_r di php e ti crei un debugging manuale oppure guarda su eclipse, ci sono diversi debugger integrati per php (mi pare che uno si chiami Xdebugger) però non vorrei ricordare male.

[e-commerce84]

certo, o utilizzi la funzione print_r di php e ti crei un debugging manuale oppure guarda su eclipse, ci sono diversi debugger integrati per php (mi pare che uno si chiami Xdebugger) però non vorrei ricordare male.

attualmente non ho eclipse...il mio portatile non ce la farebbe mai...a brevissimo lo butto e me ne faccio uno nuovo...

[malocchio]

Ci sono un sacco di errori in quel codice.
In rosso le righe con errori. In verde la riga da sostituire a quella rossa.
Non conosco bene gli algoritmi sugli heap, ho corretto solo gli errori sintattici/di distrazione.
<?php

/* Classe che implementa la struttura dati HEAP e la sua funzionalità per
l'ordinamento di una collezione mediante l'algoritmo di ordinamento
Heap Sort */

class Heap{

/* Variabile di istanza che implementa la struttura dati ad albero
dell'heap per mezzo di un array */
private $heap = array();
private $heapSize = 0; // Numero di elementi correntemente dentro l'HEAP

/* Costruttore: Crea un nuovo oggetto istanza di Heap. Riceve un qualunque
array come parametro di input, lo copia dentro alla
variabile di istanza heap[] (mettendoli dentro l'array Heap
a partire dalla posizione 1) e su di esso richiama ilmetodo
di classe heapify per trasformarlo in loco in un heap */

public function __construct($arr=array()){

/* Scorre l'array ricevuto come parametro e lo copia nel'array heap
traslando gli elementi una posizione in avanti (per farli partire dalla
posizione 1 e non 0) */
foreach($arr as $chiave => $valore){
$heap[$chiave+1] = $arr[chiave]; // Copia gli elementi traslandoli
$heap[$chiave+1] = $arr[$chiave]; // Copia gli elementi traslandoli
$heapSize ++; //Incrementa di 1 il numero elementi inseriti nell'heap
}

/* Invoca il metodo heapify sull'array partendo dalla prima posizione che
sarà trasformato in un HEAP */
$this->heap = $this->heapify($heap, 1);
$this->heapify(1);
}


/* Metodo che dato un qualsiasi array lo riarrangia trasformandolo in una
struttura dati HEAP memorizzata sempre nello stesso array di partenza */

private function heapify($heap, $nodo_i){
private function heapify($nodo_i){
echo "heapify è stata chiamata<br />";

/* CASO BASE: Se heap è vuoto ritorna al chiamante */
if($this->sinistro($nodo_i) > $this->heapSize) return;

/* Altrimenti procedi ricorsivamente nel seguente modo */
else{
$sin = sinistro($nodo_i); // Posizione della radice del sottoalbero sinistro
$sin = $this->sinistro($nodo_i); // Posizione della radice del sottoalbero sinistro
$des = destro($nodo_i); // Posizione della radice del sottoalbero destro
$des = $this->destro($nodo_i); // Posizione della radice del sottoalbero destro

$nodoCorrente = $sin;
heapify($heap, $nodoCorrente); // Chiama ricorsivamente sul sottoalbero sinistro
$this->heapify($nodoCorrente); // Chiama ricorsivamente sul sottoalbero sinistro
$nodoCorrente = $des;
heapify($heap, $nodoCorrente); // Chiama ricorsivamente sul sottoalbero destro
$this->heapify($nodoCorrente); // Chiama ricorsivamente sul sottoalbero destro

fixHeap($nodoCorrente, $heap);
$this->fixHeap($nodoCorrente);
}

}

/* Metodo che prende in input un quasi heap (cioè un heap con al più
un'anomalia) ed un indice nodo_i e restituisce un heap corretto */
private function fixHeap($nodo_i, $quasiHeap){
private function fixHeap($nodo_i){
$sin; // Conterrà l'indice del figlio sinistro
$des; // Conterrà l'indice del figlio destro
$max; // Conterrà l'indice del figlio avente valore massimo

/* Se nodo_i è una foglia allora ritorna al chiamante (caso base)*/
if(sinistro($nodo_i) > $this->$heapSize) return;
if($this->sinistro($nodo_i) > $this->$heapSize) return;

/* Se nodo_i non è una foglia */
else{
$sin = sinistro($nodo_i); // Posizione del figlio sinistro
$sin = $this->sinistro($nodo_i); // Posizione del figlio sinistro
$des = destro($nodo_i); // Posizione del figli destro
$des = $this->destro($nodo_i); // Posizione del figli destro

/* Trova il massimo tra il figlio sinistro e destro di nodo_i */
if($quasiHeap[sin] >= $quasiHeap[$des]) $max = $sin;
if($this->$heap[$sin] >= $this->$heap[$des]) $max = $sin;
else $max = $des;

/* Se il valore in posizione nodo_i è MINORE del valore del figlio
massimo */
if($quasiHeap[$nodo_i] < $quasiHeap[$max]){
if($this->$heap[$nodo_i] < $this->$heap[$max]){
$tmp = $quasiHeap[$nodo_i]; // Salva il valore in posizione i
$tmp = $this->$heap[$nodo_i]; // Salva il valore in posizione i
/* Scambia il valore in posizione nodo_i con il valore in
posizione max */
$quasiHeap[$nodo_i] = $quasiHeap[max];
$this->$heap[$nodo_i] = $this->$heap[$max];
$quasiHeap[$max] = $tmp;
$this->$heap[$max] = $tmp;

/* Invoca ricorsivamente il metodo fixHeap() passandogli come
parametro lo stesso array e la posizione max */
fixHeap($max, $quasiHeap);
$this->fixHeap($max, $quasiHeap);
}
}
}

/* Metodo che dato l'indice di un elemento dell'heap calcola l'indice del
suo figlio sinistro nell'heap */
private function sinistro($indicePadre){
$sin = $indicePadre*2; // Calcola l'indice del figlio sinistro
return $sin; // Ritorna il valore di sin al chiamante
}

/* Metodo che dato l'indice di un elemento dell'heap calcola l'indice del
suo figlio destro nell'heap */
private function destro($indicePadre){
$des = $indicePadre*2 + 1; // Calcola l'indice del figlio destro
return $padre; // Ritorna il valore di des al chiamante
return $des; // Ritorna il valore di des al chiamante
}

/* Metodo che dato un elemento dell'heap calcolal'indice del padre */
private function padre($indiceNodo){
$padre = floor(i/2); // Calcola la parte intera
$padre = floor($indiceNodo/2); // Calcola la parte intera
return $padre; // Ritorna al chiamante la posizione del padre
}

/* Metodo per stampare l'heap */
public function stampaHeap(){
for($i=1; $i<=$heapSize; $i++)
for($i = 1; $i <= $this->$heapSize; $i++)
echo $heap[i];
echo $this->$heap[i];
}

}

echo "Test HEAP <br \>\n";
$arr = array(70,10, 14, 18, 11, 27);

$myHeap = new Heap($arr);
$myHeap->stampaHeap();


?>

Scusami per l'indentazione, che si è un po' rovinata formattando il codice...
Se hai dubbi chiedi pure, ovviamente potrei aver fatto degli errori...

ps. per postare codice php con syntax highlighting puoi usare il tag
public function __construct($arr=array()){

/* Scorre l'array ricevuto come parametro e lo copia nel'array heap
traslando gli elementi una posizione in avanti (per farli partire dalla
posizione 1 e non 0) */
foreach($arr as $chiave => $valore){
$heap[$chiave+1] = $arr[chiave]; // Copia gli elementi traslandoli
$heapSize ++; //Incrementa di 1 il numero elementi inseriti nell'heap
}

/* Invoca il metodo heapify sull'array partendo dalla prima posizione che
sarà trasformato in un HEAP */
$this->heap = $this->heapify($heap, 1);
}


/* Metodo che dato un qualsiasi array lo riarrangia trasformandolo in una
struttura dati HEAP memorizzata sempre nello stesso array di partenza */

private function heapify($heap, $nodo_i){
echo "heapify è stata chiamata<br />";

/* CASO BASE: Se heap è vuoto ritorna al chiamante */
if($this->sinistro($nodo_i) > $this->heapSize) return;

/* Altrimenti procedi ricorsivamente nel seguente modo */
else{
$sin = sinistr
Io non l'ho usato sopra perché non avrei potuto colorare le righe...

[e-commerce84]

Ti ringrazio...ma secondo te cos'è che non va in questa riga?

private function heapify($heap, $nodo_i){

A me pare corretta...gli stò dicendo che la funzione riceve una variabile chiamata $heap ed una chiamata $nodo_i cos'è che non va bene?

Grazie

[malocchio]

Ti ringrazio...ma secondo te cos'è che non va in questa riga?

private function heapify($heap, $nodo_i){

A me pare corretta...gli stò dicendo che la funzione riceve una variabile chiamata $heap ed una chiamata $nodo_i cos'è che non va bene?

Grazie

E' un errore logico grave. Quella funzione è un metodo della classe Heap. La richiami su un oggetto Heap e opera sull'oggetto stesso. Quindi perché passargli $heap, che è praticamente una variabile d'istanza?
Vedi le altre correzioni. Vanno aggiunti un sacco di "$this->"

[e-commerce84]

E' un errore logico grave. Quella funzione è un metodo della classe Heap. La richiami su un oggetto Heap e opera sull'oggetto stesso. Quindi perché passargli $heap, che è praticamente una variabile d'istanza?
Vedi le altre correzioni. Vanno aggiunti un sacco di "$this->"

Sisi...hai ragione...ho ritirato fuori anche i miei appunti di Java (in realtà erano più 2 corsi di programmazione OO) e parlava proprio di questa cosa...ti ringrazio di avermi rinfrescato la memoria...

Logicamente è più corretto come dici te nell'ambito di programmazione OO perchè ho un oggetto che riceve un messaggio ed il messaggio in questione è il metodo :)

[malocchio]

Sisi...hai ragione...ho ritirato fuori anche i miei appunti di Java (in realtà erano più 2 corsi di programmazione OO) e parlava proprio di questa cosa...ti ringrazio di avermi rinfrescato la memoria...

Logicamente è più corretto come dici te nell'ambito di programmazione OO perchè ho un oggetto che riceve un messaggio ed il messaggio in questione è il metodo :)

L'avevo intuito che eri un po' arrugginito in OOP :D

ps. in Php il $this-> è obbligatorio per accedere a variabili e metodi di classe ;)

[e-commerce84]

L'avevo intuito che eri un po' arrugginito in OOP :D

ps. in Php il $this-> è obbligatorio per accedere a variabili e metodi di classe ;)

Più che altro ho fatto 2 corsi universitari...tenuti molto bene e studiati parecchio...ma mai andato oltre gli esercizzi dati in classe...diciamo che non ho questa grande esperienza...

Poi venendo da Java dove il this è facoltativo ehhe me lo perdo spesso per strada perchè mi viene automatico riferirmi a quella variabile senza mettercelo davanti :D :mc: :muro:

[malocchio]

Più che altro ho fatto 2 corsi universitari...tenuti molto bene e studiati parecchio...ma mai andato oltre gli esercizzi dati in classe...diciamo che non ho questa grande esperienza...

Poi venendo da Java dove il this è facoltativo ehhe me lo perdo spesso per strada perchè mi viene automatico riferirmi a quella variabile senza mettercelo davanti :D :mc: :muro:

Io invece per una coincidenza ho scritto la mia prima classe in Php, quindi adesso in Java mi viene naturale mettere il this, anche se lo evito ovviamente quando verrebbero fuori degli statement troppo lunghi.