Возвращения массива из функции

Господа отцы!
Пытаюсь разобраться в оптимизации кода. В частности - оптимизация скорости возвращаемых из функций массивов.

PHP:

1. <?
2. function test1($A){  return $A; }
3. function &test2($A){ return $A; }
4.  
5. // $A - массив с очень большим количеством элементов, но для теста возьмем простой массив
6. $A=Array('первый элемент','второй элемент');
7.  
8. $A1=test1(&$A);
9. $A2=test2(&$A);
10.  
11. // Проверим то, что $A,$A1,$A2 ссылаются на разные массивы
12. $A[0]='A';
13. $A1[0]='A1';
14. $A2[0]='A2';
15.  
16. /*
17. Если вывести массивы получим:
18.  
19. A: Array
20. (
21. [0] => A
22. [1] => второй элемент
23. )
24.  
25. A1: Array
26. (
27. [0] => A1
28. [1] => второй элемент
29. )
30.  
31. A2: Array
32. (
33. [0] => A2
34. [1] => второй элемент
35. )
36. */
37.  

Как вы считаете, какая функция работает быстрее?
Мне кажется что test2.

 

topas, я имел ввиду с пояснением ответа.

 

topas, пока я писал данное сообщение, появились предыдущие. Я их прочел. Я рассуждал неверно (не знал о "ленивом" копировании). Мои рассуждения были такие (они неверные, кто не хочет может не читать):


Обратите внимание, на то что аргумент функции передаётся как ссылка. Тогда если записать так:

PHP:

1. <?
2.  function test1($A){  return $A; }
3.  function &test2($A){ return $A; }
4.  
5.  // $A - массив с очень большим количеством элементов, но для теста возьмем простой массив
6.  $A=Array('первый элемент','второй элемент');
7.  
8.  $A1=&test1(&$A);
9.  $A2=&test2(&$A);
10.  
11.  // Проверим то, что $A,$A1,$A2 ссылаются на разные массивы
12.  $A[0]='A';
13.  $A1[0]='A1';
14.  $A2[0]='A2';
15.  
16.  /*
17.  Если вывести массивы получим:
18.  
19.  A: Array
20.  (
21.  [0] => A2 //--------------------------------- АЙ-АЙ-АЙ
22.  [1] => второй элемент
23.  )
24.  
25.  A1: Array
26.  (
27.  [0] => A1
28.  [1] => второй элемент
29.  )
30.  
31.  A2: Array
32.  (
33.  [0] => A2
34.  [1] => второй элемент
35.  )
36.  */

Т.е. после операции $A2=&test2(&$A); $A и $A2 ссылаются на один и тот же массив.

Абстрактно я себе представляю процесс так:

PHP:

1. <?
2. $A1=&test1(&$A); // 1). $ReturnValue=$A; 2). $A1=&$ReturnValue;
3. $A2=&test2(&$A); // 1). $ReturnValue=&$A; 2). $A2=&$ReturnValue;
4. // аналогично:
5. $A1=test1(&$A); // 1). $ReturnValue=$A; 2). $A1=$ReturnValue;
6. $A2=test2(&$A); // 1). $ReturnValue=&$A; 2). $A2=$ReturnValue;
7.  

Как видно, пятая строка использует двойное копирование массива, а шестая - только одно

 

topas, не мог ли ты дать ссылочку на этот момент в спецификации (как говориться - носом ткнуть).
Заранее спасибо.

 

Нашел книгу (точнее только её обложку):

Где бы теперь саму книгу найти... (риторический вопрос)

А что... просто в документации к PHP (та, которая на этом сайте) нет ничего про это?

 

Ух... Скачал... ЁПРСТ... Книга в формате djvu - одни картинки (поиск не работает)... Страниц 613... Хорошо хоть ещё, что на русском. Первый проссмотр по оглавлению не дал результатов. 613/50=12 дней уйдет на прочтение данной книги.

P.S. Как вам такая формулировка из документации PHP.chm:

.
ИМХО: сианистов эта фраза может ввести в тупик.

 

Как будет по английски ссылка и как - указатель?

 

Перевод:
ссылка - reference
указатель - reference
reference - ссылка (значение, уникально идентифицирующее объект или переменную во время выполнения; особый вид указателя в C++)

Так, что я не понимаю, за что добивать сианистов...

 

Чем отличается скомпилированный код
int ReturnMe(int *Value){ return *Value; }
от
int ReturnMe(int &Value){ return Value; }


Ничем. Отличие только в семантике. А суть - одна и та же.

Код (Text):

1.  
2. mov eax,[eax]
3. ret

 

Пардон за оффтоп.

 

Ну.. прочел я В чем проблема?.
И ещё раз убедился, что отличие только в семантике (тобищ в способе записи).
Код то генерируется один и тот же... Если не так, то, пожайлуста, приведи контр пример.

UPD. Приведи, пожайлуста пример с использованием ссылок, который невозможно записать при помощи указателей.

 

Семантика ссылок: (пример с http://window.edu.ru/window_catalog/pdf ... 2&p_page=4)

Семантика указателей:

Код (Text):

1.  
2.         #include <iostream.h>
3.         void main()
4.         {
5.         int I=123;
6.         int *si=&I;
7.         cout<<”\ni=”<<I<<” si=”<<(*si);
8.         I=456;
9.         cout<<”\ni=”<<I<<” si=”<<(*si);
10.         I=0; cout<<”\ni=”<<I<<” si=”<<(*si);
11.         }
12. Выведется
13. I=123 si=123
14. I=456 si=456
15. I=0 si=0

Если откомпилировать два варианта то экзешники получаются одинаковы.

Повторяю - отличие только в способе записи.

 

Штудирую книгу... Пока, к сожалению, не могу найти про "ленивые" загрузки массивов. Читаю далее.