Home >Backend Development >PHP Tutorial >Simple instructions for using the php destructor, php instructions_PHP tutorial
Simple instructions for using the php destructor, php instructions_PHP tutorial
- WBOYOriginal
- 2016-07-13 09:44:16713browse
Simple instructions for using PHP destructor, PHP usage instructions
With the widespread development of object-oriented programming, object-oriented programming has revealed many interesting problems. I believe that many beginners will come into contact with two functions when learning PHP object-oriented, constructor and destructor. The constructor seems to be used more, and the destructor is used less (relative to the limited programming experience of beginners, the same is true for the author.) Functionally, the constructor is called when the object is created, and the destructor is called when the object is destroyed. , there is no need to call them specifically, one end and one end, but it is also the front and rear.
The destructor often handles some resource release work. For example, fopen() is called before, fclose() is called here, imagecreatefromjepg() is called before, and imagedestory() is called here. These are some common examples. Of course it is not limited to this. We can treat it as an ordinary function that will be executed when the object is destroyed or the script is executed.
Since there’s so much going on, let’s raise today’s main question as early as possible:
<?php
class Test{
public function __destruct(){
echo "执行析构函数";
}
}
$test1=new Test;
$test2=$test3=$test1;
unset($test1);
echo "<hr/>";
What is the result of executing this script?
Before answering this question, look back at the words I marked above. We can take it for granted that unset($test1) is used before the output separator line, which will call the destructor and output text. As for $test2 and $test3, the destructor should be called after the script execution is completed. That is to say, one paragraph of text will be output above the dividing line, and two paragraphs of text will be output below the dividing line. At this time, you can be a little proud, after all, you know when to call the destructor. But is this really the case? We can take a look at the execution results.
Hey, damn it, why did you just output one sentence? ? ?
In fact, we have overlooked an important prerequisite, that is, the default assignment of objects is reference assignment. Many people have not noticed this, and I hope beginners can pay more attention to it.
Since it is a reference assignment, combined with our understanding of ordinary variables, we quickly thought that the three variable names point to the same storage address. So if that's the case, what does unset($test1) do? ? ? Destroy the variable pointing to the storage address or destroy the content stored in the storage address?
If you understand the usage of the unset() function, please skip this paragraph intuitively.
Considering this painful problem, why not check the manual.
The same is passed by reference, only the variable name pointing to the storage address is destroyed. Combined with the normal function of unset(), we can describe it this way: when multiple variable names or object names point to a storage address, the function of the unset() function is only to destroy the pointers of the variable names and storage addresses. When there is only one variable name Or object name, unset destroys the content at the specified storage address.
We can imagine that the real storage content is a TV. Multiple people (multiple variable names or object names) are watching a TV. After unset(), no one stopped watching and left, but the TV was still on. When only one person is watching TV, after unset(), when the person leaves, the TV must be turned off, which is to release the occupied storage space. If you are interested in this part of the content, you can also take a look at "Three Ways to Implement PHP Recursive Functions".
Okay, back to the topic. After unset($test1), the original object is still there. When the dividing line is output, the script is executed and the destructor is called. Because there is only one object, calling the destructor is only called once. It is natural to output the above results.
Several other related interesting questions: There are many ways to call the destructor in the program. Regardless of whether the object is set to null or false, other objects remain unaffected. This is still different from ordinary variables. (The effect of the unset() function is the same). If you are interested, you can try it.
Another embarrassing thing: we all know that the constructor can use __construct(), but we ignore the constructor with the same name. So, everyone should pay attention.
Finally let’s look at an example
<?php
/*
* Created on 2009-11-18
*
* To change the template for this generated file go to
* Window - Preferences - PHPeclipse - PHP - Code Templates
*/
class student{
//属性
private $no;
private $name;
private $gender;
private $age;
private static $count=0;
function __construct($pname)
{
$this->name = $pname;
self::$count++;
}
function __destruct()
{
self::$count--;
}
static function get_count()
{
return self::$count;
}
}
$s1=new student("Tom");
print(student::get_count());
$s2=new student("jerry");
print(student::get_count());
$s1=NULL;
print(student::get_count());
$s2=NULL;
print(student::get_count());
?>
The above code is the specific method of using the PHP5 destructor. I hope it will be helpful to everyone.