Символ & перед переменной в php
Что означает & перед переменной при переборе данных массива?
У вас есть два варианта цикла:
и (вариант со ссылкой)
Разница только лишь в возможности во втором случае изменить элемент массива $node простым присвоением $node = 123 .
Никакого замедления или копирования данных, если не используются ссылки, не происходит, поскольку PHP использует механизм Copy-on-Write. В варианте цикла без ссылки программисту просто запрещается использовать ссылку, но внутри движка PHP она все так же имеет место.
Указатель в языке Си
Указатель — переменная, содержащая адрес объекта. Указатель не несет информации о содержимом объекта, а содержит сведения о том, где размещен объект.
Указатели широко используются в программировании на языке Си.
Указатели часто используются при работе с массивами.
Память компьютера можно представить в виде последовательности пронумерованных однобайтовых ячеек, с которыми можно работать по отдельности или блоками.
Каждая переменная в памяти имеет свой адрес — номер первой ячейки, где она расположена, а также свое значение. Указатель — это тоже переменная, которая размещается в памяти. Она тоже имеет адрес, а ее значение является адресом некоторой другой переменной. Переменная, объявленная как указатель, занимает 4 байта в оперативной памяти (в случае 32-битной версии компилятора).
Указатель, как и любая переменная, должен быть объявлен.
Общая форма объявления указателя
Тип указателя — это тип переменной, адрес которой он содержит.
Для работы с указателями в Си определены две операции:
- операция * (звездочка) — позволяет получить значение объекта по его адресу — определяет значение переменной, которое содержится по адресу, содержащемуся в указателе;
- операция & (амперсанд) — позволяет определить адрес переменной.
Для указанного примера обращение к одним и тем же значениям переменной и адреса представлено в таблице
| Переменная | Указатель | |
| Адрес | &c | p |
| Значение | c | *p |
Результат выполнения программы: 
Расположение в памяти переменной a и указателя b: 
Необходимо помнить, что компиляторы высокого уровня поддерживают прямой способ адресации: младший байт хранится в ячейке, имеющей младший адрес.
Комментариев к записи: 81
// Функция кодирования текста
uint32_t* encrypt(uint32_t* v, uint32_t* k)
<
uint32_t v0 = v[0];
uint32_t v1 = v[1];
uint32_t sum = 0;
/* a key schedule constant */
uint32_t delta = 0x9e3779b9;
/* cache key */
uint32_t k0 = k[0];
uint32_t k1 = k[1];
uint32_t k2 = k[2];
uint32_t k3 = k[3];
uint32_t i;
/* basic cycle start */
for (i = 0; i < 32; i++)
<
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
>
/* end cycle */
return v; // Возвращаем указатель на нулевой элемент массива зашифрованного числа
// Функция декодирования текста
uint32_t* decrypt(uint32_t* v, uint32_t* k)
<
/* set up */
uint32_t v0 = v[0];
uint32_t v1 = v[1];
uint32_t sum = 0xC6EF3720;
uint32_t i;
/* a key schedule constant */
uint32_t delta = 0x9e3779b9;
/* cache key */
uint32_t k0 = k[0];
uint32_t k1 = k[1];
uint32_t k2 = k[2];
uint32_t k3 = k[3];
/* basic cycle start */
for (i = 0; i < 32; i++)
<
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum -= delta;
>
/* end cycle */
uint32_t* plain;
char shelf1[8]; // В массив записан текст из 8-символов
char shelf2[8];
plain = (uint32_t*)shelf1; // Загружаем текст в plain
uint32_t* encoded = encrypt(plain, key); // Шифруем текст
uint32_t* decoded = decrypt(plain, key); // Расшифровываем текст
uint32_t* decrypt(uint32_t* v, uint32_t* k)
<
/* set up */
uint32_t v0 = v[0];
uint32_t v1 = v[1];
/Рабочий стол/CodeC$ gcc pointers.c -o pointers.exe pointers.c: In function ‘main’: pointers.c:12:62: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int *’ [-Wformat=] printf("\n Адрес переменной a равен %x шестн.", &a);
%ls pointers.c:14:66: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int *’ [-Wformat=] printf("\n Значение указателя b равно %x шестн.", b);
^ %ls pointers.c:15:85: warning: format ‘%x’ expects argument of type ‘unsigned int’, but argument 2 has type ‘int **’ [-Wformat=] ntf("\n Адрес расположения указателя b равен %x шестн.", &b);
#include <stdlib.h>
#include <gtk/gtk.h>
#include <sqlite3.h>
void helloWorld (GtkWidget *wid, GtkWidget *win)
<
GtkWidget *dialog = NULL ;
dialog = gtk_message_dialog_new (GTK_WINDOW (win), GTK_DIALOG_MODAL,
GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, sqlite3_libversion());
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
>
int main ( int argc, char *argv[])
<
GtkWidget *button = NULL ;
GtkWidget *win = NULL ;
GtkWidget *vbox = NULL ;
/* Initialize GTK+ */
g_log_set_handler ( "Gtk" , G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL );
gtk_init (&argc, &argv);
g_log_set_handler ( "Gtk" , G_LOG_LEVEL_WARNING, g_log_default_handler, NULL );
/* Create the main window */
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width (GTK_CONTAINER (win), 8);
gtk_window_set_default_size (GTK_WINDOW (win), 400, 200);
gtk_window_set_title (GTK_WINDOW (win), "Hello World" );
gtk_window_set_position (GTK_WINDOW (win), GTK_WIN_POS_CENTER);
gtk_widget_realize (win);
g_signal_connect (win, "destroy" , gtk_main_quit, NULL );
/* Create a vertical box with buttons */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_container_add (GTK_CONTAINER (win), vbox);
button = gtk_button_new_from_stock (GTK_STOCK_DIALOG_INFO);
g_signal_connect (G_OBJECT (button), "clicked" , G_CALLBACK (helloWorld), (gpointer) win);
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
g_signal_connect (button, "clicked" , gtk_main_quit, NULL );
gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
/* Enter the main loop */
gtk_widget_show_all (win);
gtk_main ();
return 0;
>
Урок 8: «Первое знакомство с указателями»
Вы уже должны уметь писать простейшие программы на C++. Теперь вы знаете, что такое массивы, функции, переменные и как все это использовать. С этого урока можно сказать, что начинается вторая часть изучения, немного сложнее предыдущей.
В этом уроке мы коснемся, правда пока еще поверхностно, с такими средствами C, как указатели и ссылки. Это очень важная тема, поэтому внимательно читайте урок.
Указатель – это переменная, содержащая адрес памяти, в которой содержится другая переменная. Как это понять? Вы уже знаете, что для каждой переменной вашей программы компилятор выделяет место в памяти. Так вот, указатель как раз содержит адрес этого места. Давайте рассмотрим это на примере.
У нас есть число 27 типа int. Мы используем переменную a для хранения этого числа. В стеке программы выделилось место для хранения этой переменной (что такое стек мы рассмотрим в уроках с динамическими структурами данных). Графически это можно представить так:
Я сильно абстрагируюсь, но примерно в памяти это будет так. Как видите, у меня на рисунке наша переменная содержится во второй ячейке. Естественно, что компьютер переведет для себя в 16 ричный код адрес этой ячейки. И теперь, если воспользоваться указателем и присвоить ему значение этого адреса, то мы получим доступ к этой ячейке. Немного непонятно, не так ли?
Дело в том, что C++, как расширение своего предшественника C, является, как выразился Денис Ричи (создатель C), языком «среднего уровня». В компьютерной литературе вы тщетно можете искать определение этого термина –его просто нет. Тем не менее, C был компромиссом между низкоуровневым языком и высокоуровневым. Дело в том, что раньше системные программы писались на ассемблере, где напрямую можно обращаться к регистрам процессора (регистр в ассемблере это что-то типа переменной в широком смысле этого слова). Если вы никогда не писали программы на ассемблере, поздравляю – вы не убили часть своей жизни на бесполезное занятие. Почему я так говорю? Да просто потому, что ассемблерный код в десятки раз длиннее того же сишного и писать его все же сложнее. Однако операционная система с драйверами это не все, что нужно для комфортного пользования компьютером. Нужны были прикладные программы, писать которые на ассемблере чистой воды безумие. Для этих целей использовался высокоуровневый язык.
Когда была написана операционная система Unix, остро встал вопрос о портировании ее на различные компьютеры (ассемблерный код был привязан только к тому типу процессора, для которого был написан). И тогда встал вопрос о создании языка, на котором можно писать и операционные системы с драйверами, и прикладные программы. Причем все это должно делаться с одинаковым уровнем сложности. В конечном счете был создан С, а потом и С++.
Так вот, указатели перекочевали в C++ из C. Я уже упомянул тот факт, что драйвера и операционные системы обращаются к регистрам процессора. Конечно, можно это сделать при помощи ассемблерных вставок, разумно включенными в язык, а можно использовать указатели, содержащие адрес этих регистров. Алгоритм тогда сводился к следующему – мы получаем адрес ячейки с данными и меняем значение ячейки ( не адреса!) на нужное. Об этом мы поговорим гораздо позже.
Чтобы не быть голословным, продемонстрирую это на примере. Но для начала давайте разберемся с синтаксисом указателей.
В C, равно как и в C++, указатель задается так:
тип переменной* имя_указателя.
Причем звездочка может стоят сразу как после типа, так и перед именем указателя. Это не будет ошибкой. Просто программисты пишут по-разному. Этот пример дань Паскалю. Лично я раньше ставил звездочку перед именем переменной, но потом почему-то стал ставить ее после типа. Важно также ставить префикс перед именем переменной, чтобы знать, что используется указатель. Обычно ставят символ p или ptr, здесь роли не играет. Просто вам самим нужно знать, что это указатель. Еще один важный момент — указатель должен быть именно того же типа, как и переменная, адрес которой вы хотите в него поместить. Представьте себе, что вам нужно купить джинсы 48 размера, а вам настойчиво предлагают 46 или 44. Иными словами, данные просто не влезут в такой указатель.
Давайте теперь немного поясню. Во второй строке я объявил указатель типа int и там же присвоил ему адрес переменной a при помощи оператора изъятия адреса &. Я бы мог написать так:
Просто тот вариант более удобен. Чтобы показать, что сейчас содержится в памяти, я вывел содержимое указателя. А теперь вернемся к тому замечательному свойству, позволяющему через указатель манипулировать данными в ячейке памяти. Для того, чтобы изменить данные, указатель нужно разыменовать. Для этого перед именем указателя нужно поставить *. Теперь мы можем присвоить любое значение. В переменной a сразу же отразятся эти изменения, для чего я и вывел ее содержимое. Поэкспериментируйте. Забегая далеко вперед, все читерские программы, изменяющие значение переменных в играх, делают это при помощи указателей. Вот такое полезное применение. Но не нужно думать, что на этом использование указателей ограничивается.
Мы знаем, что в функцию для гибкости расчетов удобно передавать параметры. Причем параметры передаются по значению и по ссылке. В уроке про функции я этот момент искусственно опустил, но теперь полностью поясню.
Когда вы передаете параметр по значению, компилятор создает копию это переменной и манипулирует уже ей. То есть, если мы передадим в функцию нашу переменную a, содержащую число 27, то компилятор создаст клона этой переменной. Но на это уходит время процессора и глупо расходуется память. Конечно, это не критично, если у вас там используются примитивные типы данных. Но вы же можете передавать структуры или классы в функцию, а они могут занимать большие размеры памяти и процессору необходимо будет время на создание копии такой структуры или класса. Поэтому в таких целях используются параметры по ссылке.
Механизм работы подобного параметра прост – вместо копии переменной мы передаем в функцию ее адрес. Это очень экономит время процессора и часто весьма удобно. Конечно, возникает вопрос о том, что программист может нечаянно изменить данные в этом указателе. Чтобы этого избежать, используется классификатор const в параметре:
Пока этот код не берите во внимание. Я сейчас поговорю еще об одной возможности работы с адресом переменной. Речь пойдет здесь о ссылке.
Ссылка – это не более, чем псевдоним переменной. По сути, это тот же адрес. Применяется ссылка при передаче параметра по ссылке. Честно говоря, о другом применении ссылок я даже и не знаю. Если можете привести такой пример, буду признателен.
Естесственно, что ссылка предваряется оператором изъятия адреса &, о котором я уже говорил. Давайте теперь я покажу сигнатуру функции, в которой передается параметр по ссылке:
Как видите, принцип почти тот же самый, что и с указателями. Теперь с a можно делать все, что душе угодно. Однако, еще раз оговорюсь, лично я ссылки не использую, так же как и мои коллеги. Достаточно указателей. Для сравнения, вышеупомянутая подпрограмма с использованием указателей будет выглядеть так:
При использовании указателей в параметре мы передаем в качестве параметра адрес переменной a. Это почти тоже самое, что и с ссылкой. Важно просто не забывать ставить амперсанд (&).
Пока на этом урок закончен. В следующем уроке мы рассмотрим более углубленно указатели. А пока отдохните.
Что значит перед переменной
Передача через указатель
С точки зрения удобства программирования, передавать значения, которые могут изменяться внутри функции лучше всего через ссылку (а не через указатель). Чтобы в этом разобраться, ниже описан возможный, но не самый лучший способ передачи параметров — по указателю.
Если передавать параметры через указатель (так называемый С-стиль), код функции выглядит так:
mul5(&var); // Здесь символ & обозначает операцию взятия адреса переменной
Такой синтаксис неудобен. Внутри тела функции, перед переменной, которая является указателем, приходится ставить звездочку * для работы со значением, на который указывает указатель. Кроме того, при вызове функции приходится ставить амперсанд & перед именем переменной для того, чтобы передать адрес переменной (который будет принят в функцию как указатель).
Передача через ссылку
Если передавать параметры через ссылку , код функции выглядит так:
А вызов выглядит так:
Видно, что нет никаких разыменовываний в теле функции функции. Так же при таком вызове не требуется передача адреса переменной.
Однако, следует помнить , что такая передача по ссылке возможна только для единичных типов C/C++ . И не работает для передачи массивов!
Поэтому, к примеру, если функция принимает:
- одномерный массив block из элементов char , элементы которого надо изменить внутри функции (обозначим это как сложный/составной тип)
- целочислительную переменную shift , которую тоже надо изменить внутри функции (это простой базовый тип)
то реализация функции будет выглядеть так:
void clear(unsigned char *block, int &shift)
А вызов функции будет выглядеть так:
unsigned char* anyBlock="Long string";
for(int i=0; i<len; ++i)
clear(anyBlock, anyShift); // Вызов функции
То есть, в вызове нет никаких спецсимволов указателей/адресов ни для первого ни для второго параметра. Для первого параметра нет спецсимвола взятия адреса (хоть и идет работа с указателем) из-за того, что имя массива имеет тип указателя. Для второго параметра нет спецсимвола взятия адреса из-за того, что передача идет по ссылке.
При таком вызове будут изменяться как ячейки массива anyBlock , так и переменная anyShift .
