Unique ID of any value(objects, arrays, scalar)

Question

Lets imagine that we have following:

class Foo
{
    public static $foo;
    public static $bar;
    public static $baz;
    public static $str;
    public static $arr;   
}

class Bar
{
    public static $foo;
    public static $bar;
    public static $baz;
    public static $str;
    public static $arr;
}

class Baz
{
    public static $foo;
    public static $bar;
    public static $baz;
    public static $str;
    public static $arr; 
}
Foo::$foo = new Foo();
Bar::$foo = Foo::$foo;
Baz::$foo = Foo::$foo;

Foo::$bar = new Bar();
Bar::$bar = Foo::$bar;
Baz::$bar = Foo::$bar;

Foo::$baz = new Baz();
Bar::$baz = Foo::$baz;
Baz::$baz = Foo::$baz;

Foo::$str = 'cat';
Bar::$str = Foo::$str;
Baz::$str = Foo::$str;

Foo::$arr = [1, 2, 3, 'dog'];
Bar::$arr = Foo::$arr;
Baz::$arr = Foo::$arr;

WHERE:
Foo::$foo, Bar::$foo, Baz::$foo refer same instance of Foo;
Foo::$bar, Bar::$bar, Baz::$bar refer same instance of Bar;
Foo::$baz, Bar::$baz, Baz::$baz refer same instance of Baz;
Foo::$str, Bar::$str, Baz::$str refer same string;
Foo::$arr, Bar::$arr, Baz::$arr refer same array;

Is there any way to identify these values? For instance in C++ I could just use a pointer, which would contain same value for Foo::$foo, Bar::$foo and Baz::$foo.
What is it for?
I have a function which iterates all properties of a given classes and writes property values into common array.
Lets imagine we are iterating over Foo's, Bar's and Baz's properties and adding them into array. In final array we'll have 15 values instead of 5(really different values). If we'll search and compare these values before adding into array then(if `Foo::$str, Bar::$str and BAZ::$str will be not a refs to same value, but just an equal values) we'll have only 5 values instead of 7(3 objects, 1 array and 3 strings).
I hope this edit will help to understand me.

Also:

$a = 1;  
$b = &$a;
$c = 1;

($a == $b) // true  
($a == $c) // true

In both cases result will be true. But how to know that im comparing 2 references of the same value(2 refs that point same memory address) or im comparing 2 different memory addresses and they they are just equal? It will be helpful for solving this problem.

Answer 1

well, i admit i'm not fully aware of what you're trying to do... but i'll take a stab at it and suggest you want a super class to hold your static $foo, $bar etc. then you can extend from there. here's a truncated example.

<?php

abstract class Super
{
    static $foo;
    static $bar;
}

class Foo extends Super
{
    public function test() {
        print "i am foo\n";
    }

}

class Bar extends Super
{
    public function test() {
        print "i am bar\n";
    }
}

$foo = new Foo();
Bar::$foo = $foo;
Bar::$foo->test(); // "i am foo""
$foo->test(); // "i am foo"

Answer 2

As I read it, you seem to be trying to identify if a given reference is unique or not.

Objects

In PHP, when you instantiate an object and assign it to a variable (be it a standard variable in scope, or an object/class property) you are assigning a reference, which is a symbol table alias, not a pointer.

You can use strict equality === to determine if values are the same instance of the same type.

So, given a similar example to the one you provided:

class Foo
{
}

class Bar
{
    public static $bar;
}

$foo = new Foo();
Bar::$foo = $foo;

Both $foo and Bar::$foo refer to the instance of Foo that we created. We can prove this with strict equality:

var_dump($foo === Bar::$foo); // bool(true)    

On the other hand, the following:

$foo = new Foo();
Bar::$foo = new Foo();

var_dump($foo === Bar::$foo); // bool(false)

Because the instances being compared are different in this case.

You can also use spl_object_hash() which returns a unique hash id for an object.

Revisiting first example above:

$foo = new Foo();
Bar::$foo = $foo;

var_dump(spl_object_hash($foo));
var_dump(spl_object_hash(Bar::$foo));

Yields:

string(32) "00000000706dad460000000129210cdf"
string(32) "00000000706dad460000000129210cdf"

Both object hashes are identical for each reference; i.e: the same underlying object.

In contrast, the second example where we create two new instances of Foo:

$foo = new Foo();
Bar::$foo = new Foo();

var_dump(spl_object_hash($foo));
var_dump(spl_object_hash(Bar::$foo));

Yields:

string(32) "0000000004e5dfeb0000000107143bbf"
string(32) "0000000004e5dfe80000000107143bbf"

They look almost identical, but if you look closely, they are different values.

Arrays & Strings

These don't work in the same manner. Given the following example:

Foo::$str = 'cat';
Bar::$str = Foo::$str;

Bar::$str = 'dog';

var_dump(Foo::$str, Bar::$str);

Yields:

string(3) "cat"
string(3) "dog"

You can however assign scalar values by reference with &:

Foo::$str = 'cat';
Bar::$str = &Foo::$str;

Bar::$str = 'dog';

This yields:

string(3) "dog"
string(3) "dog"

The same applies to arrays iirc.

Your update suggests that you are iterating over objects in order to maintain an object store, or store of unique references. I'm not sure about your specific use case but SplObjectStorage might be useful to you.

Hope this helps :)