Что именно означает "пройти по ссылке"?

кто имеет право решать? Никто, и все. Вы решаете за себя, писатель решает за свою книгу, а читатель решает, соглашаться ли с писателем.

чтобы понять этот термин, нужно пойти под капотом языка (и объяснить их в терминах кода C, а не упускает суть). Стили передачи параметров относятся к механизмам, которые компиляторы обычно используют для создания определенного поведения. Следующий обычно определено:

• pass by value: аргумент копируется в параметр при вводе подпрограммы
• pass by result: параметр не определен при вводе подпрограммы и копируется в аргумент при возврате подпрограммы
• pass by value-result: аргумент копируется в параметр при входе, а параметр копируется в аргумент при возврате
• pass by reference: ссылка на переменную аргумента копируется в параметр; любой доступ переменной параметра прозрачно переводится в доступ переменной аргумента

(терминологическое Примечание: параметр-это переменная, определенная в подпрограмме, аргумент-это выражение, используемое в вызове.)

учебники обычно также определяют pass по имени, но это редко и нелегко объяснить здесь. Пройти мимо потребности также существует.

важность стиля передачи параметра-его эффект: в pass by value любые изменения, внесенные в параметр, не сообщаются аргументу; в pass by result любые изменения, внесенные в параметр, сообщаются аргументу в конце; в pass by reference любые изменения, внесенные в параметр, сообщаются аргументу по мере их внесения.

некоторые языки определяют более одного стиля передачи, позволяя программисту выбрать предпочтительный стиль для каждого параметра отдельно. Например, в Pascal по умолчанию используется стиль передаче по значению, но программист может использовать var ключевое слово для указания pass by reference. Некоторые другие языки задают один стиль передачи. Существуют также языки, которые задают разные стили для разных типов (например, в C значение pass by является значением по умолчанию, но массивы передаются по ссылке).

теперь, в Java, технически у нас есть язык с pass-by-value, со значением переменной объекта, являющейся ссылкой на объект. Делает ли это Java pass-by-reference когда речь идет об объектных переменных, это вопрос вкуса.

оба ваших примера C фактически демонстрируют pass-by-value, потому что C не имеет pass-by-reference. Это просто значение, которое вы передаете указатель. Pass-by-reference происходит в таких языках, как Perl:

sub set_to_one($)
{
    $_[0] = 1; # set argument = 1
}
my $a = 0;
set_to_one($a); # equivalent to: $a = 1

здесь переменная $a фактически передается по ссылке, поэтому подпрограмма может изменить его. Это не изменение какого-то объекта, который $a указывает на косвенность; скорее, он изменяет .

Java похож на C в этом уважайте, за исключением того, что в Java объекты являются "ссылочными типами", поэтому все, что у вас есть (и все, что вы можете передать), - это указатели на них. Что-то вроде этого:--8-->

void setToOne(Integer i)
{
    i = 1; // set argument = 1
}

void foo()
{
    Integer a = 0;
    setToOne(a); // has no effect
}

фактически не изменится a; он только передает i.

передача по ссылке, по сути,передача ссылки на значение-а не его копии-в качестве аргумента.

Я думаю, прежде чем мы продолжим, некоторые вещи должны быть определены. Возможно, я использую их иначе, чем вы привыкли видеть.

• An объект молекулы данных. Он занимает хранилище и может содержать другие объекты, но имеет свою собственную идентичность и может быть отнесен к и используется как единое целое.

• A ссылка - псевдоним или дескриптор объекта. На уровне языка ссылка в основном действует как вещь, на которую она ссылается; в зависимости от языка компилятор/интерпретатор/среда выполнения/гномы будут автоматически разыменования это когда фактический объект необходим.

• A стоимостью является результатом оценки выражения. Это конкретный объект, который смогите храниться, быть передано к функциям, etc. (ООП вонкс, обратите внимание, что я использую " объект "здесь в общем смысле" молекула данных", а не" экземпляр класса " ООП.)

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

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

• A ссылка-типизированной переменной (a la Java, C#,...)- это переменная значение которого ссылка.

большинство языков, когда вы передаете переменную в качестве аргумента, по умолчанию создают копию значения переменной и передают копию. Этот callee связывает свое имя для параметра с этой копией. Это называется " передача по значению "(или, более четко,"передача по копии"). Две переменные по обе стороны вызова заканчиваются разными местоположениями хранения и, таким образом, являются совершенно разными переменными (только связанными в том, что они обычно начинаются с равных значений).

пройдя по ссылке, с другой стороны, не делает копии. Вместо этого он передает саму переменную (минус имя). То есть, он передает ссылку на то же самое значение имеет переменная aliases. (Обычно это делается путем неявной передачи указателя на хранилище переменной, но это всего лишь деталь реализации; вызывающий и вызываемый не должны знать или заботиться о том, как это происходит.) Вызываемый объект привязывает имя своего параметра к этому местоположению. Конечный результат заключается в том, что обе стороны используют одно и то же место хранения (возможно, под разными именами). Любые изменения вызываемый делает его переменной, таким образом, также переменная. Например, в случае объектно-ориентированных языков, переменной может быть присвоено совершенно другое значение.

большинство языков (включая Java) не поддерживает Это изначально. Ох, они бы сказать они делают...но это потому, что люди, которые никогда не могли по-настоящему проходим по ссылке, часто не grok тонкая разница между делать так и передача ссылки по значению. Где путаница приходит с этими языками, это с переменные ссылочного типа. Сама Java никогда не работает непосредственно с объектами ссылочного типа, но с ссылки на эти объекты. Разница заключается в переменных, "содержащих" указанные объекты. Значение переменной ссылочного типа является такой ссылкой (или, иногда, специальным ссылочным значением, которое означает "ничего"). Когда Java передает такую ссылку, хотя она не копирует объект, она все равно копирует значение (т. е. ссылка, которую получает функция, является копией значения переменная относится к). То есть, это передача ссылки, но проходит он по стоимости. Это позволяет большинству вещей, которые позволяет передача по ссылке,но не все.

самым очевидным тестом, который я могу придумать для реальной поддержки pass-by-reference, будет "тест подкачки". Язык, который изначально поддерживает передачу по ссылке, должен обеспечивать достаточную поддержку для записи функции swap это меняет значения своих аргументов. Код, эквивалентный этому:

swap (x, y):       <-- these should be declared as "reference to T"
  temp = x
  x = y
  y = temp

--

value1 = (any valid T)
value2 = (any other valid T)

a = value1
b = value2
swap(a, b)
assert (a == value2 and b == value1)

1. должно быть возможно и успешно выполняться - для любого типа T, который разрешает копирование и переназначение-с использованием операторов присваивания языка и строгого равенства (включая любые перегрузки, указанные T); и
2. не должно требовать, чтобы вызывающий преобразовывал или" обертывал " args (например: явно передавая указатель). Требование, чтобы args были отмечены как передаваемые по ссылке, нормально.

(очевидно, языки, которые не имеют изменяемых переменных, не могут быть проверены таким образом , но это нормально, потому что они не имеют значения. Большая семантическая разница между ними заключается в том, насколько модифицируема переменная вызывающего абонента вызываемым абонентом. Когда значение переменной не изменяется в любом случае, разница становится просто детализацией реализации или оптимизацией.)

_{обратите внимание, что большинство разговоров в этом ответе касается "переменных". Ряд языков, таких как C++, также позволяют передача анонимных значений по ссылке. Механизм тот же самый; значение занимает хранилище, а ссылка является псевдонимом к нему. Это просто не обязательно имеет имя в вызывающем абоненте.}

Википедия дает очень четкое определение вызова по ссылке я не могу улучшить:

в оценке call-by-reference (также называемой pass-by-reference) функция получает неявную ссылку на переменную, используемую в качестве аргумента, а не копию ее значения. Это обычно означает, что функция может изменять (т. е. присваивать) переменную, используемую в качестве аргумента, - то, что будет видно ее вызывающему.

обратите внимание, что ни один из ваших примеры-это вызов по ссылке, потому что назначение формального параметра в C никогда не изменяет аргумент, как видно вызывающему.

но этого достаточно для копирования, прочитайте подробное обсуждение (с примерами) в

http://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_reference

Java не проходит по ссылке. Вы всегда передаете значение copy / by. Однако, если вы передадите объект, вы получите копию ссылки. Таким образом, вы можете напрямую редактировать объект, однако если вы перезаписываете локальную ссылку, исходная ссылка на объект не будет переопределена.

передача параметров по ссылке означает, что вложенность указателя параметров глубже, чем вложенность указателя локальных переменных. Если у вас есть переменная с типом класса, переменная является указателем на фактическое значение. Переменная примитивного типа is содержит само значение.

Теперь, если вы передаете эти переменные по значению, вы сохраняете вложенность указателя: ссылка на объект остается указателем на объект, а примитивная переменная остается значением себя.

передача переменных в качестве ссылок означает, что вложенность указателя становится глубже: вы передаете указатель на ссылку на объект, чтобы вы могли изменить ссылку на объект; или вы передаете указатель на примитив, чтобы вы могли изменить его значение.

эти определения используются в C# и Объект Паскаль которые оба имеют ключевые слова для передачи переменной по ссылке.

отвечая на ваш вопрос: потому что последние переменные - whatever в первый пример и thing_pointer во втором - передаются функции через указатель (&), оба передаются по ссылке.

если вы знакомы с C, возможно, следующая аналогия объясняет, как работает Java. Это будет справедливо только для объектов класса (а не фундаментального типа).

в Java мы можем иметь переменную и передать ее функции:

void f(Object x)
{
  x.bar = 5;    // #1j
  x = new Foo;  // #2j
}

void main()
{
  Foo a;
  a.bar = 4;
  f(a);
  // now a.bar == 5
}

в C, это будет выглядеть следующим образом:

void f(struct Foo * p)
{
  p->bar = 5;                      // #1c
  p = malloc(sizeof(struct Foo));  // #2c
}

int main()
{
  struct Foo * w = malloc(sizeof(struct Foo));
  w->bar = 4;
  f(w);
  /* now w->bar = 5; */
}

в Java, переменные типа класса всегда ссылки, который в C был бы наиболее точно сопоставлен с указатели. Но в функция вызывает, сам указатель передается copy. ссылке указатель, как в #1j и #1c, изменяет исходную переменную, поэтому в этом смысле вы передаете ссылку на переменную. Однако сама переменная является только указателем, и она сама передается копией. Поэтому, когда вы назначаете ему что-то другое. как и в #2j и #2c, вы только восстанавливаете скопировать ссылки / указателя в локальной области f. Исходная переменная, a или w в соответствующих примерах, остается нетронутым.

короче: все ссылки и ссылки передаются по значению.

в C, с другой стороны, я мог бы реализовать истинную "передачу по ссылке", объявив void v(struct Foo ** r);, а вызов f(&w); это позволило бы мне изменить внутри f.

Примечание 1: это не верно для фундаментальных типов, таких как int, которые полностью передаются по значению.

Примечание 2: A Пример C++ был бы немного аккуратнее, так как я мог бы передать указатель по ссылке (и мне не нужно было говорить struct): void f(Foo * & r) { r = new Foo; } и f(w);.