Когда параметр передается по значению , вызывающий и вызываемый имеют две независимые переменные с одинаковым значением. Если вызываемый изменяет переменную параметра, эффект не отображается вызывающему.
Однако , если рассматриваемое значение является изменчивым объектом ссылочного типа или иным образом косвенно ссылается на другие значения, то вы можете эмулировать call-by-reference в среде с обратным значением: если вызываемый изменяет объект (или другие значения указывают к объекту), эти изменения видны вызывающему. Но эмуляция не совсем то же самое, поскольку видны только изменения объекта , а не переменной . Это приводит к искаженным объяснениям, таким как «вызов по значению, где значение является ссылкой». Это несколько запутанное положение дел состоит в том, как многие популярные языки программирования работают сегодня, и поэтому люди часто путают передачу изменяемых объектов по значению с помощью вызова по ссылке.
Подробнее см. В других ответах ниже.
ПРИМЕЧАНИЕ . В течение долгого времени этот ответ говорил:
Если я распечатаю страницу и даю вам распечатку, я передаю ее значение. Ваша страница является отключенной копией оригинала. Вы не увидите никаких последующих изменений, и любые изменения, которые вы делаете (например, наброски на распечатку), не будут отображаться на исходной странице. Если вы уничтожите распечатку, вы фактически уничтожили свою копию объекта, но исходная веб-страница остается нетронутой.
Это простая аналогия, которую легко понять, которая получила этот пост сотнями голосов. Однако аналогия ошибочна: call-by-reference и call-by-value не похожи на URL-адреса. (Тип ссылки на языке, подобном C #, похож на URL-адрес, см. Замечательную статью Джона Скита о ссылочных типах в.NET для подробностей. Но ссылочные типы – это не то же самое, что передавать по ссылке .)
Поскольку эта аналогия на самом деле не правильная, она удалена из этого ответа. См. Также комментарии ниже, где это обсуждалось.
Это способ передачи аргументов в функции. Передача по ссылке означает, что параметр вызываемых функций будет таким же, как переданный аргумент вызывающих (а не значение, а идентификатор – сама переменная). Передача по значению означает, что параметр вызываемых функций будет копией переданного аргумента вызывающих. Значение будет одинаковым, но идентификатор – переменная – отличается. Таким образом, изменение параметра, выполняемого вызываемой функцией в одном случае, изменяет переданный аргумент, а в другом случае просто изменяет значение параметра в вызываемой функции (которая является только копией). Быстро спешите:
- Java поддерживает только передачу по значению. Всегда копирует аргументы, даже если при копировании ссылки на объект параметр вызываемой функции указывает на тот же объект, и изменения в этом объекте будут отображаться в вызывающем. Поскольку это может сбивать с толку, вот что говорит Джон Скит об этом.
- C # поддерживает передачу по значению и передает по ссылке (ключевое слово ref используемое при вызове и вызываемой функции). У Джона Скита также есть хорошее объяснение этого здесь.
- C ++ поддерживает передачу по значению и передает по ссылке (тип ссылочного параметра, используемый в вызываемой функции). Ниже вы найдете объяснение этого.
Поскольку мой язык – C ++, я буду использовать это здесь
// passes a pointer (called reference in java) to an integer void call_by_value(int *p) { // :1 p = NULL; } // passes an integer void call_by_value(int p) { // :2 p = 42; } // passes an integer by reference void call_by_reference(int & p) { // :3 p = 42; } // this is the java style of passing references. NULL is called "null" there. void call_by_value_special(int *p) { // :4 *p = 10; // changes what p points to ("what p references" in java) // only changes the value of the parameter, but *not* of // the argument passed by the caller. thus it"s pass-by-value: p = NULL; } int main() { int value = 10; int * pointer = &value; call_by_value(pointer); // :1 assert(pointer == &value); // pointer was copied call_by_value(value); // :2 assert(value == 10); // value was copied call_by_reference(value); // :3 assert(value == 42); // value was passed by reference call_by_value_special(pointer); // :4 // pointer was copied but what pointer references was changed. assert(value == 10 && pointer == &value); }
И пример в Java не повредит:
Class Example { int value = 0; // similar to:4 case in the c++ example static void accept_reference(Example e) { // :1 e.value++; // will change the referenced object e = null; // will only change the parameter } // similar to the:2 case in the c++ example static void accept_primitive(int v) { // :2 v++; // will only change the parameter } public static void main(String... args) { int value = 0; Example ref = new Example(); // reference // note what we pass is the reference, not the object. we can"t // pass objects. The reference is copied (pass-by-value). accept_reference(ref); // :1 assert ref != null && ref.value == 1; // the primitive int variable is copied accept_primitive(value); // :2 assert value == 0; } }
Википедия
http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_value
http://en.wikipedia.org/wiki/Pass_by_reference#Call_by_reference
Этот парень довольно много гвоздями:
Вот пример:
#include void by_val(int arg) { arg += 2; } void by_ref(int&arg) { arg += 2; } int main() { int x = 0; by_val(x); std::cout
Многие ответы здесь (и, в частности, самый высокий ответ) фактически неверны, поскольку они неправильно понимают, что означает «вызов по ссылке». Вот моя попытка разобраться.
TL; DR
Проще говоря:
- вызов по значению означает, что вы передаете значения в качестве аргументов функции
- вызов по ссылке означает, что вы передаете переменные как аргументы функции
В метафорических выражениях:
- Вызов по значению – это то, где я записываю что-то на листе бумаги и передаю его вам . Возможно, это URL, может быть, это полная копия «Войны и мира». Независимо от того, что это, это на листе бумаги, который я вам дал, и теперь это фактически ваш лист бумаги . Теперь вы можете писать на этом листе бумаги или использовать этот лист бумаги, чтобы найти что-то в другом месте и поиграть с ним.
- Звоните по ссылке , когда я даю вам свою записную книжку, в которой записано что-то . Вы можете писать в моей записной книжке (может быть, я хочу, чтобы вы это сделали, может быть, я этого не сделаю), а потом я держу свою тетрадь с любыми каракулями, которые вы там положили. Кроме того, если то, что либо вы, либо я написал там, есть информация о том, как найти что-то в другом месте, либо вы, либо я можем пойти туда и поиграть с этой информацией.
Что «вызов по значению» и «вызов по ссылке» не означает
Обратите внимание, что обе эти концепции полностью независимы и ортогональны из концепции ссылочных типов (которые в Java – это все типы, которые являются подтипами Object , а в C # – все типы class) или понятие типов указателей, подобных C (которые семантически эквивалентно «ссылочным типам» Java, просто с различным синтаксисом).
Понятие ссылочного типа соответствует URL-адресу: он сам является частью информации, и это ссылка (указатель , если хотите) на другую информацию. Вы можете иметь много копий URL-адреса в разных местах, и они не изменяют, на каком веб-сайте они все ссылаются; если веб-сайт обновляется, то каждая копия URL-адреса все равно приведет к обновленной информации. И наоборот, изменение URL-адреса в любом месте не повлияет на любую другую письменную копию URL-адреса.
Обратите внимание, что C ++ имеет понятие «ссылки» (например, int&), которое не похоже на «ссылочные типы» Java и C #, но похоже на «вызов по ссылке». «Ссылочные типы» Java и C # и все типы в Python похожи на то, что C и C ++ вызывают «типы указателей» (например, int*).
Хорошо, вот длиннее и более формальное объяснение.
терминология
Для начала я хочу выделить некоторые важные термины терминологии, чтобы помочь прояснить мой ответ и убедиться, что мы все ссылаемся на те же идеи, когда мы используем слова. (На практике я считаю, что подавляющее большинство путаницы в отношении таких тем, как эти, основаны на использовании слов таким образом, чтобы не до конца передать смысл, который был предназначен.)
Для начала, вот пример на каком-нибудь C-подобном языке объявления функции:
Void foo(int param) { // line 1 param += 1; }
И вот пример вызова этой функции:
Void bar() { int arg = 1; // line 2 foo(arg); // line 3 }
Используя этот пример, я хочу определить некоторые важные биты терминологии:
- foo – это функция, объявленная в строке 1 (Java настаивает на том, чтобы делать все функции, но концепция без потери общности, C и C ++ делают различие между декларацией и определением, в которые я не буду входить)
- param является формальным параметром foo , также объявленным в строке 1
- arg – это переменная , в частности локальная переменная функциональной bar , объявленная и инициализируемая в строке 2
- arg также является аргументом для конкретного вызова foo на строку 3
Здесь есть два очень важных набора понятий. Первый – это значение по сравнению с переменной :
- Значение является результатом оценки выражения на языке. Например, в функции bar выше, после строки int arg = 1; , выражение arg имеет значение 1 .
- Переменная – это контейнер для значений . Переменная может быть изменчивой (это по умолчанию используется на большинстве C-подобных языков), только для чтения (например, объявлено с использованием final версии Java или C # только для readonly) или глубоко непреложным (например, с использованием константы C ++).
Другая важная пара понятий для различения – параметр против аргумента :
- Параметр (также называемый формальным параметром ) – это переменная, которая должна быть вызвана вызывающим при вызове функции.
- Аргумент – это значение , которое предоставляется вызывающей функцией для выполнения определенного формального параметра этой функции
Вызов по значению
В вызове по значению формальные параметры функции являются переменными, которые были созданы для вызова функции, и которые инициализируются значениями их аргументов.
Это работает точно так же, как любые другие типы переменных инициализируются значениями. Например:
Int arg = 1; int another_variable = arg;
Здесь arg и another_variable являются полностью независимыми переменными – их значения могут меняться независимо друг от друга. Однако в точке, где объявляется another_variable , она инициализируется для хранения того же значения, которое имеет значение arg которое равно 1 .
Поскольку они являются независимыми переменными, изменения в another_variable не влияют на arg:
Int arg = 1; int another_variable = arg; another_variable = 2; assert arg == 1; // true assert another_variable == 2; // true
Это в точности то же самое, что и отношение между arg и param в нашем примере выше, которое я повторю здесь для симметрии:
Void foo(int param) { param += 1; } void bar() { int arg = 1; foo(arg); }
Это точно так, как если бы мы написали код таким образом:
// entering function "bar" here int arg = 1; // entering function "foo" here int param = arg; param += 1; // exiting function "foo" here // exiting function "bar" here
То есть определяющей характеристикой того, что вызов по значению означает, является то, что вызываемый (foo в этом случае) получает значения в качестве аргументов, но имеет свои собственные переменные для этих значений из переменных вызывающего (в этом случае bar).
Возвращаясь к моей метафоре выше, если я нахожусь в bar а ты – foo , когда я тебя зову, я вручу тебе лист бумаги со значением, написанным на нем. Вы называете этот лист бумаги param . Это значение является копией значения, которое я написал в моей записной книжке (мои локальные переменные), в переменной, которую я вызываю arg .
(В стороне: в зависимости от аппаратного обеспечения и операционной системы существуют различные соглашения о том, как вы вызываете одну функцию из другой. Вызывающее соглашение похоже на то, как мы решаем, записываю ли значение на куске своей бумаги, а затем передаю ее вам, или если у вас есть листок бумаги, на который я его напишу, или если я напишу его на стене перед нами обоими. Это интересная тема, но далеко за frameworks этого уже долгого ответа.)
Вызов по ссылке
Возвращаясь к нашему примеру выше, это эквивалентно:
// entering function "bar" here int arg = 1; // entering function "foo" here // aha! I note that "param" is just another name for "arg" arg /* param */ += 1; // exiting function "foo" here // exiting function "bar" here
Поскольку param является просто другим именем для arg то есть они являются одной и той же переменной , изменения в param отражены в arg . Это основной способ, которым вызов по ссылке отличается от вызова по значению.
Очень немногие языки поддерживают вызов по ссылке, но C ++ может сделать это следующим образом:
Void foo(int& param) { param += 1; } void bar() { int arg = 1; foo(arg); }
В этом случае param имеет не только то же значение, что и arg , но на самом деле это arg (просто другое имя), и поэтому bar может заметить, что arg был увеличен.
Обратите внимание: это не так, как работает любой Java, JavaScript, C, Objective-C, Python или почти любой другой популярный язык. Это означает, что эти языки не звонят по ссылке, они вызывают по значению.
Добавление: вызов по обмену объектами
Если то, что у вас есть, является вызовом по значению , но фактическое значение является ссылочным типом или типом указателя , тогда само значение «значение» не очень интересно (например, в C это всего лишь целое число определенного для платформы размера) – что Интересно то, на что указывает это значение.
Если то, что указывает этот ссылочный тип (то есть указатель), является изменчивым, тогда возможен интересный эффект: вы можете изменить указанное значение, и вызывающий может наблюдать изменения указательного значения, даже если вызывающий не может наблюдать изменения самого указателя.
Чтобы заимствовать аналогию с URL-адресом еще раз, тот факт, что я дал вам копию URL-адреса на веб-сайт, не особенно интересен, если мы обоим заботимся о веб-сайте, а не о URL-адресе. Тот факт, что вы нацарапаете свою копию URL-адреса, не влияет на мою копию URL-адреса, это не то, о чем мы заботимся (и на самом деле, на таких языках, как Java и Python, «URL» или ссылочное значение типа, вообще не изменяйтесь, только то, на что указывает, может).
Барбара Лисков, когда она придумала язык программирования CLU (который имел эти семантики), понял, что существующие термины «вызов по значению» и «вызов по ссылке» не были особенно полезны для описания семантики этого нового языка. Поэтому она придумала новый термин: вызов путем совместного использования объектов .
При обсуждении языков, которые технически вызывают по значению, но где обычные типы используются, являются ссылочными или указательными типами (то есть: почти каждый современный императивный, объектно-ориентированный или многопарадигменный язык программирования), я считаю, что это намного менее запутанно просто не говорите о вызове по значению или вызовите по ссылке . Придерживайтесь вызова путем совместного использования объектов (или просто вызывайте объект ), и никто не будет путать. 🙂
Прежде чем понимать 2 условия, вы ДОЛЖНЫ понимать следующее. Каждый объект имеет две вещи, которые могут отличить его.
- Его ценность.
- Его адрес.
Так что если вы скажете employee.name = "John"
знайте, что есть 2 вещи о name . Его значение, которое есть "John" а также его расположение в памяти, которое является шестнадцатеричным числом, может быть примерно таким: 0x7fd5d258dd00 .
В зависимости от архитектуры языка или типа (classа, структуры и т. Д.) Вашего объекта вы будете либо передавать "John" либо 0x7fd5d258dd00
Передача "John" считается передачей по значению. Передача 0x7fd5d258dd00 считается передачей по ссылке. Любой, кто указывает на это место памяти, будет иметь доступ к значению "John" .
Самый простой способ получить это – в файле Excel. Скажем, например, что у вас есть два числа, 5 и 2 в ячейках A1 и B1 соответственно, и вы хотите найти их сумму в третьей ячейке, скажем, A2. Вы можете сделать это двумя способами.
Либо передавая их значения ячейке A2 , введя в эту ячейку = 5 + 2 . В этом случае, если значения ячеек A1 или B1 меняются, сумма в A2 остается неизменной.
Или путем передачи «ссылок» на ячейки A1 и B1 на ячейку A2 , набрав = A1 + B1 . В этом случае, если значения ячеек A1 или B1 меняются, сумма в A2 также изменяется.
Pass By Value Локальные параметры – это копии исходных аргументов, переданных в Изменения, внесенные в функцию, к этим переменным , не влияют на оригиналы
Передача по ссылке Локальные параметры – это ссылки на места хранения исходных аргументов. Изменения этих переменных в функции влияют на оригиналы. Копирование не производится, поэтому сохраняются накладные расходы на копирование (время, память)
При передаче по ref вы в основном передаете указатель на переменную. Переходите по значению, вы передаете копию переменной. При базовом использовании это обычно означает, что с помощью ref изменения переменной будут рассматриваться как вызывающий метод и передаются по их значению.
Передача по значению отправляет КОПИЮ данных, хранящихся в указанной вами переменной, передает по ссылке отправляет прямую ссылку на эту переменную. Поэтому, если вы передаете переменную по ссылке и затем измените переменную внутри блока, в который вы ее передали, исходная переменная будет изменена. Если вы просто переходите по значению, исходная переменная не сможет быть изменена блоком, в который вы его передали, но вы получите копию того, что она содержала во время разговора.
Основное различие между ними заключается в том, что значения переменных типа хранят значения, поэтому указание переменной типа значения в вызове метода передает копию значения этой переменной методу. Переменные ссылочного типа хранят ссылки на объекты, поэтому указание переменной ссылочного типа в качестве аргумента передает методу копию фактической ссылки, относящейся к объекту. Несмотря на то, что сама ссылка передается по значению, метод все равно может использовать ссылку, которую он получает, для взаимодействия с возможным и, возможно, модификацией исходного объекта. Аналогично, при возврате информации из метода с помощью оператора return метод возвращает копию значения, хранящегося в переменной типа значения, или копию ссылки, хранящейся в переменной ссылочного типа. Когда ссылка возвращается, вызывающий метод может использовать эту ссылку для взаимодействия с указанным объектом. Таким образом, объекты фактически передаются по ссылке.
В c #, чтобы передать переменную по ссылке, чтобы вызываемый метод мог изменять переменную, C # предоставляет ключевые слова ref и out. Применение ключевого слова ref к объявлению параметра позволяет передать переменную методу по ссылке – вызываемый метод сможет изменить исходную переменную в вызывающем. Ключевое слово ref используется для переменных, которые уже были инициализированы в вызывающем методе. Обычно, когда вызов метода содержит неинициализированную переменную в качестве аргумента, компилятор генерирует ошибку. Предшествующий параметр с выделением ключевого слова создает выходной параметр. Это указывает компилятору, что аргумент будет передан вызываемому методу по ссылке и что вызываемый метод назначит значение исходной переменной в вызывающем. Если метод не присваивает значение выходному параметру во всех возможных путях выполнения, компилятор генерирует ошибку. Это также мешает компилятору генерировать сообщение об ошибке для неинициализированной переменной, которая передается в качестве аргумента методу. Метод может возвращать только одно значение своему вызывающему абоненту через оператор return, но может возвращать многие значения, задавая несколько параметров вывода (ref и / или out).
см. обсуждение c # и примеры здесь текст ссылки
Pass by value – функция копирует переменную и работает с копией (поэтому она не меняет ничего в исходной переменной)
Пример (скопируйте и используйте / попробуйте сами и посмотрите):
#include using namespace std; void funct1(int a){ //pass-by-value a = 6; //now "a" is 6 only in funct1, but not in main or anywhere else } void funct2(int &a){ //pass-by-reference a = 7; //now "a" is 7 both in funct2, main and everywhere else it"ll be used } int main() { int a = 5; funct1(a); cout
Держи это просто, заглядывает. Стены текста могут быть плохой привычкой.
Class Dog { public: barkAt(const std::string& pOtherDog); // const reference barkAt(std::string pOtherDog); // value };
const & обычно лучше. Вы не берете на себя штраф за строительство и уничтожение. Если ссылка не const, ваш интерфейс предполагает, что он изменит переданные данные.
Короче говоря, Passed by value WHAT это и передается по ссылке WHERE.
Если ваше значение VAR1 = «Счастливый парень!», Вы увидите только «Счастливый парень!». Если VAR1 изменится на «Happy Gal!», Вы этого не узнаете. Если он передан по ссылке, а VAR1 изменится, вы это сделаете.
По определению pass by value означает, что вы делаете копию в памяти фактического значения параметра, которое передается, копия содержимого фактического параметра. Используйте pass by value, когда вы только «используете» параметр для некоторых вычислений, не изменяя его для клиентской программы.
pass by value означает, как передать значение функции, используя аргументы. в проходе по значению мы копируем данные, хранящиеся в указанной нами переменной, и она медленнее, чем передача по ссылке bcse. Данные копируются. мы вносим изменения в скопированные данные, исходные данные не затрагиваются. nd в pass by refernce или передать по адресу, мы отправляем прямую ссылку на самую переменную. или передавая указатель на переменную. это быстрее bcse меньше времени потребляется
Если вы не хотите изменять значение исходной переменной после передачи ее в функцию, функция должна быть построена с параметром « pass by value ».
Тогда функция будет иметь ТОЛЬКО значение, но не адрес переданной переменной. Без адреса переменной код внутри функции не может изменить значение переменной, как видно из внешней функции.
Но если вы хотите, чтобы функция * изменяла значение variabl * e, как видно извне, вам нужно использовать pass by reference . Поскольку и значение, и адрес (ссылка) передаются и доступны внутри функции.
Вот пример, демонстрирующий различия между pass by value – значением указателя – reference :
Void swap_by_value(int a, int b){ int temp; temp = a; a = b; b = temp; } void swap_by_pointer(int *a, int *b){ int temp; temp = *a; *a = *b; *b = temp; } void swap_by_reference(int &a, int &b){ int temp; temp = a; a = b; b = temp; } int main(void){ int arg1 = 1, arg2 = 2; swap_by_value(arg1, arg2); cout
Метод «передача по ссылке» имеет важное ограничение . Если параметр объявлен как переданный по ссылке (поэтому ему предшествует знак &), его соответствующий фактический параметр должен быть переменной .
Фактический параметр, относящийся к формальному параметру «переданный по значению», может быть выражением в целом, поэтому ему разрешено использовать не только переменную, но и литерал или даже результат вызова функции.
Функция не может поместить значение в нечто иное, кроме переменной. Он не может назначить новое значение литералу или заставить выражение изменить его результат.
PS: Вы также можете проверить ответ Дилана Битти в текущем streamе, который объясняет это простыми словами.
По значению: когда аргументы передаются по значению методу, это означает, что копия фактической переменной отправляется методу, а не фактическая, поэтому любые изменения, применяемые внутри метода, фактически влияют на версию копирования.
Проверьте эту статью для получения дополнительных примеров.
Оба слова: difference и distinction обозначают различие между чем-либо или кем-либо. Однако есть некоторые особенности их употребления. В этой статье вы узнаете, в какой ситуации мы используем одно слово, а в какой другое.
Difference
Произношение и перевод:
Difference [’dɪfərəns] / [ди"фрэнс] - различие
Значение слова:
Ситуация, когда две или более вещи не похожи друг на друга.
Употребление:
Мы используем это слово, когда говорим о том, что что-то или кто-то отличается друг от друга. То есть указываем на факт
того, что кто-либо или что-либо имеет различный набор качеств или черт.
Пример:
I didn"t realize the difference
between them.
Я не понимаю разницу между ними.
We had a slight difference
of opinion.
У нас было небольшое различие мнений.
Distinction
Произношение
и перевод:
Distinction / [дисти"нкшен] - различие
Значение слова:
Очевидное различие или разделение между двумя похожими вещами.
Употребление:
Мы используем это слово, когда что-либо или кто-либо имеет какие-то специфические качества
. И именно эти качества помогают нам легко отличить это от других вещей/людей такого же типа.
Пример:
В чем разница?
Мы используем distinction , когда сравниваем что-либо одного типа или вида. И говорим что у чего-то/кого-то, есть специфическое качество, которое явно отличает это от остальных. Например, у одной собаки в стае на боку есть большое черное пятно, это и есть ее distinction от остальных.
Мы используем difference , когда просто отмечаем сам факт "непохожести". Причем сравнивать мы можем вещи как и одного типа, так и совершенно разные. Например, собаки имеют difference от кошек.
Упражнение на закрепление
Вставьте правильное слово в следующие предложения:
1. Она никогда не заметит ___.
2. ___ в возрасте не имеет значения.
3. Даже ребенок заметит ___ между ними.
4. ___ между двумя машинами очевидна.
5. Часто людям трудно заметить ___ между близнецами.
6. Эту ___ вы сразу заметите.
7. Между этими двумя предложениями она видела огромную ___.
8. Два этих галстука имеют ___.
Свои ответы пишите в комментариях под статьей, а я их проверю.
Как и оператор & и && , двойной оператор является оператором «короткого замыкания».
Например:
If(condition1 || condition2 || condition3)
Если условие 1 истинно, условия 2 и 3 НЕ будут проверяться.
If(condition1 | condition2 | condition3)
Это проверит условия 2 и 3, даже если 1 уже верно. Поскольку ваши условия могут быть довольно дорогими функциями, вы можете получить хороший прирост производительности, используя их.
Существует одно большое оговорка, NullReferences или аналогичные проблемы. Например:
If(class != null && class.someVar < 20)
Если класс равен null, if-statement остановится после class != null – false. Если вы используете только &, он попытается проверить class.someVar, и вы получите красивое NullReferenceException . С Or-Operator, который может быть не такой ловушкой, как маловероятно, что вы запускаете что-то плохое, но это то, что нужно иметь в виду.
Никто никогда не использует сингл & or | однако, если у вас нет дизайна, где каждое условие является функцией, которая должна выполняться. Звучит как дизайнерский запах, но иногда (редко) это чистый способ делать вещи. Оператор & выполняет «эти 3 функции, и если один из них возвращает false, выполните блок else», а | «запускает только блок else, если не возвращает false» – может быть полезным, но, как сказано, часто это запах дизайна.
Существует второе использование | и & оператор: Побитовые операции.
|| является логическим оператором OR. Похоже, вы в основном знаете, что это такое. Он используется в условных операторах, таких как if, while и т. Д.
Condition1 || condition2
Вычисляет значение true, если условие condition1 ИЛИ condition2 истинно.
| является побитовым оператором ИЛИ. Он используется для работы с двумя номерами. Вы смотрите каждый бит каждого номера отдельно и, если один из битов равен 1, по крайней мере, одному из чисел, тогда результирующий бит будет равен 1. Вот несколько примеров:
A = 01010101 B = 10101010 A | B = 11111111 A = 00000001 B = 00010000 A | B = 00010001 A = 10001011 B = 00101100 A | B = 10101111
Надеюсь, это имеет смысл.
Поэтому, чтобы ответить на два последних вопроса, я бы не сказал, что есть какие-то оговорки, кроме «знать разницу между двумя операторами». Они не взаимозаменяемы, потому что они делают две совершенно разные вещи.
Один из них «побитовое».
10011b | 01000b => 11011b
Другая логика или.
true или false => true
Хороший вопрос. Эти два оператора работают одинаково в PHP и C #.
| является побитовым ИЛИ. Он будет сравнивать два значения по их битам. Например 1101 | 0010 = 1111. Это очень полезно при использовании опций бит. Например, Read = 01 (0X01) Запись = 10 (0X02) Чтение-запись = 11 (0X03). Один из полезных примеров – открытие файлов. Простой пример:
File.Open(FileAccess.Read | FileAccess.Write); //Gives read/write access to the file
|| является логическим ИЛИ. Так обстоит дело с большинством людей и сравнивает два значения, основанные на их истине. Например, я еду в магазин, или я пойду в торговый центр. Это чаще всего используется в коде. Например
If(Name == "Admin" || Name == "Developer) { //allow access } //checks if name equals Admin OR Name equals Developer
Простой пример в java
Public class Driver { static int x; static int y; public static void main(String args) throws Exception { System.out.println("using double pipe"); if(setX() || setY()) {System.out.println("x = "+x); System.out.println("y = "+y); } System.out.println("using single pipe"); if(setX() | setY()) {System.out.println("x = "+x); System.out.println("y = "+y); } } static boolean setX(){ x=5; return true; } static boolean setY(){ y=5; return true; } }
Using double pipe x = 5 y = 0 using single pipe x = 5 y = 5
Один канал, |, является одним из побитовых операторов.
Из Википедии:
В семействе языков программирования C побитовый оператор OR является «|» (Труба). Опять же, этот оператор не следует путать с его логическим «логическим» или «параллельным», который обрабатывает его операнды как булевы значения и записывается «||», (две трубы).
& – (Условие 1 и Условие 2): проверяет оба случая, даже если первый – false
&& – (Условие 1 && Условие 2): не надо проверять второй случай, если случай один неверен
&& – оператор сделает ваш код быстрее, профессионально и редко используется
| – (Условие 1 | Условие 2): проверяет оба случая, даже если случай 1 истинен
|| – (Условие 1 || Условие 2): не надо проверять второй случай, если первое верно
|| – оператор сделает ваш код быстрее, профессионально | редко используется
По их математическому определению OR и AND являются бинарными операторами; они проверяют условия LHS и RHS независимо от того, как | а также &.
|| и && изменяют свойства операторов OR и AND, останавливая их, когда условие LHS не выполняется.
| оператор выполняет побитовое ИЛИ своих двух операндов (что означает, что обе стороны должны оценивать значение false, чтобы оно возвращало false), в то время как || оператор будет оценивать только второй оператор, если это необходимо.
Синяя труба "|" является «поразрядным» или его следует использовать только тогда, когда вы знаете, что делаете. Двойная труба "||" является логическим или может использоваться в логических операторах, таких как «x == 0 || x == 1».
Вот пример того, что поразрядно или делает: если a = 0101 и b = 0011, тогда a | b = 0111. Если вы имеете дело с логической системой, которая обрабатывает любые ненулевые значения как истинные, то побитовое или будет действовать так же, как логическое или, но это аналог (побитовое и, «&») будет NOT. Также побитовое или не выполняет оценку короткого замыкания.
Один канал (|) является побитовым оператором OR .
Две трубы (||) являются логическим оператором ИЛИ.
Они не взаимозаменяемы.
|| (две трубы), как правило, логично или пока | (одна труба) является двоичной или. В верхней части моей головы я не могу думать, что разница была бы большой, если бы вы назначили результат чему-то еще. Однако я уверен, что у кого-то еще будет ситуация, когда это имеет значение.
Редактировать: Вау, шесть других ответов за то время, когда мне потребовалось написать это.
Побитовое (|) против логического (||)! Подумайте логично, как объекты Comparable в Java, сравнивая некоторые отличимые «части», в то время как побитовый оператор смотрит на эти объекты и вместо того, чтобы видеть, являются ли они визуально близнецами (как и логические), делает ли образец ДНК и смотрит на 0 и 1 вместо.
Бабушка надвое сказала: либо дождик, либо снег, либо будет, либо нет. (народное)
ЛИБО = ИЛИ в значениях 1, 2, 3, приведённых ниже. А в значениях 4 и 5 употребляется ТОЛЬКО «ИЛИ»!
ИЛИ.
1. союз одиночный или повторяющийся. Соединяет два или несколько предложений, а также однородные члены предложения, находящиеся в отношениях взаимоисключения. Он или я. Или он уйдет, или я. Завтра или послезавтра. В понедельник, вторник или в среду. Или в понедельник, или в среду.
2. союз одиночный или повторяющийся. Употр. при присоединении последнего члена перечисления, при дополнении предшествующего. Поищи на столе, на полках или в шкафу.
3. союз одиночный или. повторяющийся. Употр. При противопоставлении: иначе, в противном случае. Уйди, или мы поссоримся.
4.союз. Употр. для соединения разных названий одного и того же понятия, для пояснения, в знач. иными словами, то есть. Аэроплан, или самолет.
5. частица. Употр. в начале предложения в знач. разве (в 1 знач.), неужели (в 1знач.) с оттенком противопоставления чему-н. другому, возможному (разг.).Или ты не знаешь об этом? Или ты решил остаться?
ИСТОЧНИК: СЛОВАРЬ ОЖЕГОВА
ДЛЯ ЧЕГО НУЖНЫ СИНОНИМЫ? Вот как на этот вопрос отвечают школьники в сочинениях:
Синонимы не нужны- синонимы необходимы. Потому что бывает необходимо слово, которое приходится повторять и если мы поставим одно и то же слово два раза, то получится повтор, то есть ошибка. И тогда мы используем слово близкое по смыслу, то есть синоним. Таким образом, избегаем назойливого повторения одного и того же слова.
Вo-вторых, синонимы служат для выразительности речи. Они помогают также уточнить, более четко и ярко передать мысль.
Приведу замечательный отрывок из «Мёртвых душ» Гоголя:
Читатель, я думаю, уже заметил, что Чичиков, несмотря на ласковый вид, говорил, однако же, с большею свободою, нежели с Маниловым, и вовсе не церемонился. Надобно сказать, кто у нас на Руси если не угнались еще кой в чем другою за иностранцами, то далеко перегнали их в умении обращаться. Пересчитать нельзя всех оттенков и тонкостей нашего обращения. Француз или немец век не смекнет и не поймет всех его особенностей и различий; он почти тем же голосом и тем же языком станет говорить и с миллионщиком, и с мелким табачным торгашом, хотя, конечно, в душе поподличает в меру перед первым. У нас не то: у нас есть такие мудрецы, которые с помещиком, имеющим двести душ, будут говорить совсем иначе, нежели с тем, у которого их триста, а у которого их триста, будут говорить опять не так, как с тем, у которого их пятьсот, а с тем, у которого их пятьсот, опять не так, как с тем, у которого их восемьсот, - словом, хоть восходи до миллиона, всь найдут оттенки. Положим, например, существует канцелярия, не здесь, а в тридевятом государстве, а в канцелярии, положим, существует правитель канцелярии. Прошу смотреть на него, когда он сидит среди своих подчиненных, - да просто от страха и слова не выговоришь! гордость и благородство, и уж чего не выражает лицо его? просто бери кисть, да и рисуй: Прометей, решительный Прометей! Высматривает орлом, выступает плавно, мерно. Тот же самый орел, как только вышел из комнаты и приближается к кабинету своего начальника, куропаткой такой спешит с бумагами под мышкой, что мочи нет. В обществе и на вечеринке, будь все небольшого чина, Прометей так и останется Прометеем, а чуть немного повыше его, с Прометеем сделается такое превращение, какого и Овидий не выдумает: муха, меньше даже мухи, уничтожился в песчинку! "Да это не Иван Петрович, - говоришь, глядя на него. - Иван Петрович выше ростом, а этот и низенький и худенький; тот говорит громко, басит и никогда не смеется, а этот черт знает что: пищит птицей и все смеется". Подходишь ближе, глядишь - точно Иван Петрович! "Эхе-хе", - думаешь себе..
Слова «в отличие» и «в отличии» пишутся по-разному, потому что относятся к разным частям речи. Правильность их написания следует проверять по контексту, в котором «в отличие» проявляет себя как производный предлог, а «в отличии» является сочетанием простого предлога с именем существительным.
Производный предлог «в отличие » образован путем соединения простого предлога в и существительного отличие , употребленного в именительном падеже.
Предлог «в отличие» используется для указания на конкретный предмет, явление или лицо при сравнении его с чем-либо или кем-либо. В речевых конструкциях предлог «в отличие» употребляется с предлогом «от»:
В отличие от других цитрусовых грейпфрут имеет горьковатый вкус;
В отличие от дождя снег здесь выпадал нечасто;
В отличие от сестры она была не по годам серьезной.
Сочетания с предлогом «в отличие» могут быть обособленными членами предложения, если присутствует интонация обособления:
С Петровым, в отличие от Сидорова , приходилось считаться.
Погода, в отличие от прогноза , выдалась безветренная и ясная.
Предлог «в отличие» не является самостоятельным членом предложения.
В сочетании с простым предлогом в имя существительное отличие употребляется в предложном падеже. К существительному можно поставить вопрос с предлогом в :
Все дело в отличии частей речи. (дело в чем? )
Суть спора проявилась в отличии мнений оппонентов. (проявилась в чем?)
Между предлогом и существительным можно вставить определение:
В отличии цветов радуги трудно найти резкий переход. (в незначительном отличии )
В предложении имя существительное с предлогом в выступает в роли дополнения:
Проблема (в чем?) в отличии наших позиций.
Выводы сайт
- «В отличие» является производным предлогом и не бывает самостоятельным членом предложения.
«В отличии» представляет собой сочетание простого предлога «в» с именем существительным «отличие» в творительном падеже, которое в предложении выступает в роли дополнения. - Предлог «в отличие» — неделимое целое. Между предлогом «в» и падежной формой «отличии» можно вставить определение.