Объекты и lvalue(адреса)


Содержание

Что такое rvalues, lvalues, xvalues, glvalues ​​и prvalues?

В С++ 03 выражение имеет значение rvalue или lvalue.

В С++ 11 выражение может быть:

  • Rvalue
  • именующего
  • xvalue
  • glvalue
  • prvalue

Две категории стали пятью категориями.

  • Что представляют собой эти новые категории выражений?
  • Как эти новые категории относятся к существующим категориям rvalue и lvalue?
  • Являются ли категории rvalue и lvalue в С++ 0x такими же, как в С++ 03?
  • Почему нужны эти новые категории? Являются ли боги WG21 просто путают нас простых смертных?

Я предполагаю, что этот документ может стать не столь коротким введением: n3055

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

Из того, что я думаю, основываясь на проекте, различие значений r/l остается неизменным, только в контексте перемещения вещей становится беспорядочным.

Они нужны? Наверное, нет, если мы хотим потерять новые возможности. Но чтобы обеспечить лучшую оптимизацию, мы должны, вероятно, охватить их.

Цитата n3055:

  • lvalue (так называемый, исторически, потому что lvalues ​​могут появляться на левая часть задания выражение) обозначает функцию или объект. [Пример: если E является выражение типа указателя, затем *E является выражением lvalue, относящимся к объект или функцию, к которой E точки. В качестве другого примера результат вызова функции, чья Тип возврата — это значение lvalue lvalue.]
  • xvalue ( Значение «eXpiring» также относится к объект, обычно ближе к концу (так что его ресурсы могут например, перемещаются). Значение x равно результат определенных видов выражения, содержащие rvalue Рекомендации. [Пример: результат вызова функции, чья Тип возврата — это rvalue reference xvalue.]
  • glvalue ( «обобщенное» значение lvalue) lvalue или xvalue.
  • rvalue (так называемый, исторически, поскольку rvalues ​​могли появляются в правой части выражение присваивания) является значением x, временный объект или его подобъектом или значением, которое не связанный с объектом.
  • prvalue ( «чистое» rvalue) является rvalue это не значение x. [Пример: результат вызова функции, чья тип возврата не является ссылкой prvalue]

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

Что представляют собой эти новые категории выражений?

FCD (n3092) имеет отличное описание:

— lvalue (так называемый, исторически, поскольку lvalues ​​могут появляться на левая часть задания выражение) обозначает функцию или объект. [Пример: если E является выражение типа указателя, тогда * E — выражение lvalue, относящееся к объекту или функции, к которым E точки. В качестве другого примера, результат вызова функции, возвращение которой type является ссылкой на lvalue именующий. -end пример]

— значение x (an Значение «eXpiring» также относится к объект, обычно ближе к концу (так что его ресурсы могут быть перемещен, например). Значение x является результат определенных видов выражений с использованием ссылок rvalue (8.3.2). [ Пример: результат вызова функция, возвращающий тип которой Ссылка rvalue — это значение x. -конец пример]

— Значение glvalue ( «обобщенное» lvalue) является lvalue или xvalue.

— Rvalue (так называемый, исторически, потому что rvalues ​​могут появиться на правая часть задания выражения) является x значением, временным объект (12.2) или его подобъект или значение, которое не связано с объект.

— PRvalue ( «чистое» значение r) значение r, которое не является значением x. [ Пример: результат вызова функция, тип возврата которой не является ссылка — это prvalue. Значение a буквальный, такой как 12, 7.3e5, или true также prvalue. -end пример]

Каждый выражение принадлежит точно одному из фундаментальные классификации в эта таксономия: lvalue, xvalue или prvalue. Это свойство выражение называется его значением категория. [Примечание: обсуждение каждый встроенный оператор в разделе 5 указывает категорию ее ценности доходности и категории значений операндов, которых он ожидает. Например, встроенные операторы присваивания ожидают что левый операнд является lvalue и что правый операнд является prvalue и в результате получим lvalue. Определяемые пользователем операторы — это функции, и категории ценностей, которые они ожидание и доходность определяются их параметров и типов возврата. -конец примечание

Я предлагаю вам прочитать весь раздел 3.10 Lvalues ​​и rvalues ​​, хотя.

Как эти новые категории относятся к существующим категориям rvalue и lvalue?

Являются ли категории rvalue и lvalue в С++ 0x такими же, как и в С++ 03?

Семантика rvalues ​​развилась особенно с введением семантики перемещения.

Почему нужны эти новые категории?

Таким образом, конструкция/назначение перемещения можно определить и поддерживать.

Я начну с вашего последнего вопроса:

Почему нужны эти новые категории?

Стандарт С++ содержит множество правил, относящихся к категории значений выражения. В некоторых правилах проводится различие между значениями lvalue и rvalue. Например, когда дело доходит до разрешения перегрузки. Другие правила делают различие между glvalue и prvalue. Например, вы можете иметь glvalue с неполным или абстрактным типом, но не существует prvalue с неполным или абстрактным типом. Прежде, чем мы получили эту терминологию, правила, которые действительно должны различать glvalue/prvalue, относящиеся к lvalue/rvalue, и они либо были непреднамеренно неправильными, либо содержали множество объяснений и исключений из правила a la «. если значение r должно быть вызвано неназванным rvalue reference. «. Таким образом, кажется хорошей идеей просто дать понятия glvalues ​​и prvalues ​​собственное имя.

Что это за новые категории выражений? Как эти новые категории относятся к существующим категориям rvalue и lvalue?

Мы все еще имеем слова lvalue и rvalue, которые совместимы с С++ 98. Мы просто разделили rvalues ​​на две подгруппы, xvalues ​​и prvalues, и мы будем называть lvalues ​​и xvalues ​​как glvalues. Xvalues ​​являются новой категорией значений для неназванных ссылок rvalue. Каждое выражение является одним из трех: lvalue, xvalue, prvalue. Диаграмма Венна будет выглядеть так:

Примеры с функциями:

Но также не забывайте, что названные ссылки rvalue являются lvalues:

Почему нужны эти новые категории? Являются ли боги WG21 просто путают нас простых смертных?

Я не чувствую, что другие ответы (хорошо, хотя многие из них) действительно фиксируют ответ на этот конкретный вопрос. Да, эти категории и такие существуют, чтобы позволить семантику перемещения, но сложность существует по одной причине. Это одно нерушимое правило перемещения вещей в С++ 11:

Ты должен двигаться только тогда, когда это, безусловно, это безопасно.

Вот почему существуют эти категории: иметь возможность говорить о ценностях, где можно безопасно переходить от них, и говорить о том, где это не так.

В ранней версии ссылок r-value движение происходило легко. Слишком легко. Достаточно легко, что существует много возможностей для неявного перемещения вещей, когда пользователь на самом деле не имел в виду.

Вот обстоятельства, при которых безопасно что-то перемещать:

  1. Когда это временный или подобъект. (Prvalue)
  2. Когда пользователь явно сказал, чтобы переместить его.

Если вы это сделаете:

Что это делает? В более старых версиях спецификации до появления 5 значений это спровоцировало бы движение. Конечно. Вы передали ссылку rvalue на конструктор и, таким образом, привязываетесь к конструктору, который принимает ссылку rvalue. Это очевидно.

Если это не временное, и вы не просили его переместить, то перемещение происходит неправильно.

Очевидное решение состоит в том, чтобы сделать val значением lvalue. Это означает, что вы не можете перейти от него. Хорошо; он назвал, поэтому его значение.

Как только вы это сделаете, вы уже не можете сказать, что SomeType&& означает одно и то же. Теперь вы сделали различие между названными ссылками rvalue и неназванными ссылками rvalue. Ну, названные ссылки rvalue — lvalues; это было наше решение выше. Итак, что мы называем неназванными ссылками rvalue (возвращаемое значение из Func выше)?

Это не lvalue, потому что вы не можете перейти от lvalue. И мы должны иметь возможность двигаться, возвращая && ; как еще вы могли бы прямо сказать что-то переместить? Это то, что std::move возвращает, в конце концов. Это не rvalue (old-style), потому что это может быть в левой части уравнения (вещи на самом деле немного сложнее, см. Этот вопрос и комментарии ниже). Это ни lvalue, ни rvalue; это новый вид вещей.

У нас есть ценность, которую вы можете рассматривать как lvalue, за исключением того, что она неявно перемещается. Мы называем это значением x.

Обратите внимание, что xvalues — это то, что заставляет нас получать две другие категории значений:

Prvalue на самом деле просто новое имя для предыдущего типа rvalue, то есть они являются значениями, которые не являются значениями xvalues.

Glvalues — это объединение значений x и lvalues в одной группе, потому что они действительно имеют много общих свойств.

Так что действительно, все сводится к значениям x и необходимости ограничивать движение точно и только в определенных местах. Эти места определяются категорией rvalue; prvalues — это неявные движения, а xvalues — явные перемещения ( std::move возвращает значение xvalue).

ИМХО, лучшее объяснение его значения дало нам Страуструпу + принять во внимание примеры Даниэля Шандора и Мохана:

Страуструп:

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

  • has identity — то есть и адрес, указатель, пользователь может определить, идентичны ли две копии и т.д.
  • can be moved from — т.е. нам разрешено выходить к источнику «копии» в каком-то неопределенном, но действительном состоянии

Это привело меня к выводу, что существует ровно три вида значений (используя нотацию регулярных выражений с использованием заглавной буквы для обозначения отрицательного значения — я торопился):

  • iM : имеет личность и не может быть перемещен из
  • im : имеет идентичность и может быть перемещен из (например, результат преобразования lvalue в ссылку на rvalue)

Im : не имеет идентичности и может быть перемещен из.

Четвертая возможность, IM , (не имеет идентичности и не может быть перемещена) бесполезна в C++ (или, я думаю) на любом другом языке.

В дополнение к этим трем основным классификациям значений у нас есть два очевидных обобщения, которые соответствуют двум независимым свойствам:

  • i : есть личность
  • m : может быть перемещен из

Это заставило меня поставить эту диаграмму на доске:

Именование

Я заметил, что у нас была только ограниченная свобода имен: две точки слева (обозначенные iM и i ) — это то, что люди с более или менее формальной lvalues назвали lvalues а две точки справа (обозначенные m и Im ) — это то, что люди с более или менее формальной rvalues назвали rvalues . Это должно быть отражено в наших именах. То есть левая «нога» W должна иметь имена, связанные с lvalue а правая «нога» W должна иметь имена, связанные с rvalue. Я отмечаю, что вся эта дискуссия/проблема возникают из-за введения ссылок на rvalue и семантики перемещения. Эти понятия просто не существуют в мире Stracheys, состоящем только из rvalues и lvalues . Кто-то заметил, что идеи, которые

  • Каждое value является либо lvalue либо rvalue
  • lvalue не является rvalue и rvalue не является lvalue

глубоко укоренились в нашем сознании, очень полезные свойства, и следы этой дихотомии можно найти по всему проекту стандарта. Мы все согласились с тем, что мы должны сохранить эти свойства (и сделать их точными). Это еще больше ограничило наш выбор имен. Я заметил, что формулировка стандартной библиотеки использует rvalue для обозначения m (обобщение), так что для сохранения ожидания и текста стандартной библиотеки правая нижняя точка W должна быть названа rvalue.

Это привело к целенаправленному обсуждению имен. Сначала нам нужно было определиться с lvalue. Должно ли lvalue означать iM или обобщение i ? Во главе с Дагом Грегором мы перечислили места в основной формулировке языка, где слово lvalue было квалифицировано для обозначения того или другого. Список был составлен, и в большинстве случаев и в самом хитром/хрупком тексте lvalue настоящее время означает iM . Это классическое значение lvalue, потому что «в старые времена» ничего не двигалось; move является новым понятием в C++0x . Кроме того, присвоение имени максимальной точке значения W lvalue дает нам свойство, что каждое значение является lvalue или rvalue , но не обоими.

Итак, верхняя левая точка W — это lvalue а нижняя правая точка — rvalue. Что это делает нижнюю левую и верхнюю правую точки? Нижняя левая точка является обобщением классического lvalue, позволяющего двигаться. Так что это generalized lvalue. Мы назвали это glvalue. Вы можете поспорить о сокращении, но (я думаю) не с логикой. Мы предполагали, что при серьезном использовании generalized lvalue каким-то образом будет сокращено, так что лучше сделать это немедленно (или рискнуть путаницей). Верхняя правая точка W является менее общей, чем нижняя правая (теперь, как всегда, называется rvalue ). Эта точка представляет собой исходное чистое понятие объекта, с которого вы можете двигаться, потому что на него нельзя ссылаться снова (кроме как деструктором). Мне понравилась фраза specialized rvalue в отличие от generalized lvalue но pure rvalue сокращенное до prvalue победило (и, вероятно, это правильно). Таким образом, левая нога W является lvalue и glvalue а правая нога — prvalue и rvalue. Кстати, каждое значение является либо glvalue, либо prvalue, но не обоими.

Это оставляет верхнюю середину W : im ; то есть значения, которые имеют идентичность и могут быть перемещены. У нас действительно нет ничего, что помогло бы нам найти хорошее имя для тех эзотерических зверей. Они важны для людей, работающих с (черновым) стандартным текстом, но вряд ли станут нарицательным. Мы не нашли каких-либо реальных ограничений для именования, чтобы направлять нас, поэтому мы выбрали x для центра, неизвестного, странного, только для xpert или даже с рейтингом x.

ВСТУПЛЕНИЕ

ISO C++ 11 (официально ISO/IEC 14882: 2011) является самой последней версией стандарта языка программирования C++. Он содержит некоторые новые функции и концепции, например:

  • Rvalue ссылки
  • xvalue, glvalue, prvalue выражения значения категории
  • переместить семантику

Если мы хотим понять концепции новых категорий значений выражений, мы должны знать, что существуют ссылки на rvalue и lvalue. Лучше знать, что значения могут быть переданы неконстантным ссылкам.

Мы можем получить некоторое представление о концепциях категорий значений, если процитируем подраздел «Значения и значения» из рабочего проекта N3337 (наиболее похожего на опубликованный стандарт ISO C++ 11).

3.10 Lvalues и rvalues [basic.lval]

1 Выражения классифицированы в соответствии с таксономией на рисунке 1.

  • Lvalue (исторически так называемое lvalue, которое может появляться в левой части выражения присваивания) обозначает функцию или объект. [Пример: если E является выражением типа указателя, тогда * E является выражением lvalue, ссылающимся на объект или функцию, на которые указывает E. В качестве другого примера, результатом вызова функции, тип возвращаемой которой является ссылкой на lvalue, является lvalue. — конец примера]
  • Значение xvalue (значение «eXpiring») также относится к объекту, обычно ближе к концу его времени жизни (например, чтобы его ресурсы могли быть перемещены). Xvalue — это результат некоторых видов выражений, включающих ссылки на rvalue (8.3.2). [Пример: Результатом вызова функции, тип возвращаемой которой является ссылкой на rvalue, является значение xvalue. — конец примера]
  • Glvalue («обобщенное» lvalue) — это lvalue или xvalue.
  • Rvalue (исторически так называемое, потому что rvalue может появляться в правой части выражения присваивания) — это xvalue, a
    временный объект (12.2) или его подобъект, или значение, которое не является
    связанный с объектом.
  • Prvalue («чистое» rvalue) — это rvalue, которое не является xvalue. [Пример: результат вызова функции, тип возвращаемой которой не является
    ссылка является prvalue. Значение литерала, такого как 12, 7.3e5 или
    истина также prvalue. — конец примера]

Каждое выражение относится к одной из основных классификаций в этой таксономии: lvalue, xvalue или prvalue. Это свойство выражения называется его категорией значений.

Но я не совсем уверен в том, что этого подраздела достаточно для четкого понимания концепций, потому что «обычно» не является действительно общим, «ближе к концу его жизненного цикла» не является действительно конкретным, «использование ссылок на значения» не совсем понятно, и «Пример. Результатом вызова функции, тип возвращаемой которой является ссылкой на rvalue, является значение xvalue». Похоже, змея кусает свой хвост.

ПЕРВИЧНАЯ ЦЕННОСТЬ КАТЕГОРИИ

Каждое выражение принадлежит ровно одной категории первичных значений. Этими категориями значений являются категории lvalue, xvalue и prvalue.

lvalues

Выражение E относится к категории lvalue тогда и только тогда, когда E относится к объекту, у которого УЖЕ есть идентификатор (адрес, имя или псевдоним), который делает его доступным вне E.

xvalues

Выражение E относится к категории xvalue тогда и только тогда, когда оно

— результат вызова функции, неявно или явно, чей тип возврата является ссылкой на тип возвращаемого объекта, или

— приведение к rvalue ссылке на тип объекта, или

— выражение доступа к члену класса, обозначающее нестатический член данных не ссылочного типа, в котором объектное выражение является значением xvalue, или

— выражение указателя на член, в котором первый операнд является значением x, а второй операнд — указателем на элемент данных.

Обратите внимание, что эффект приведенных выше правил заключается в том, что именованные ссылки на значения rvalue обрабатываются как lvalues, а безымянные ссылки на значения rvalue на объекты обрабатываются как xvalues; rvalue ссылки на функции обрабатываются как lvalues независимо от того, названы они или нет.

prvalues

Выражение E относится к категории prvalue тогда и только тогда, когда E не принадлежит ни к lvalue, ни к категории xvalue.

СМЕШАННЫЕ ЗНАЧЕНИЯ КАТЕГОРИИ

Есть еще две важные категории смешанных значений. Этими категориями значений являются категории rvalue и glvalue.

rvalues

Выражение E принадлежит категории rvalue тогда и только тогда, когда E принадлежит категории xvalue или категории prvalue.

Обратите внимание, что это определение означает, что выражение E принадлежит категории rvalue тогда и только тогда, когда E относится к объекту, у которого нет какой-либо идентичности, которая делает его доступным вне E YET.

glvalues

Выражение E принадлежит категории glvalue тогда и только тогда, когда E принадлежит категории lvalue или категории xvalue.

ПРАКТИЧЕСКОЕ ПРАВИЛО

Скотт Мейер опубликовал очень полезное практическое правило, позволяющее отличать значения от значений.

  • Если вы можете взять адрес выражения, выражение будет lvalue.
  • Если тип выражения является ссылкой на lvalue (например, T & или const T & и т.д.), Это выражение является lvalue.
  • В противном случае выражение является значением. Концептуально (и обычно также фактически) значения соответствуют временным объектам, таким как возвращаемые из функций или созданные неявными преобразованиями типов. Большинство литеральных значений (например, 10 и 5.3) также являются r-значениями.

С++ 03 слишком ограничены, чтобы правильно вносить ссылки rvalue в атрибуты выражений.

С их введением было сказано, что ссылка на неназванный rvalue оценивается как rvalue, так что разрешение перегрузки будет предпочтительнее привязки ссылок rvalue, что сделает его выборными конструкторами перемещения над конструкторами копирования. Но было обнаружено, что это вызывает проблемы вокруг, например, с Динамические типы и с квалификацией.

Чтобы показать это, рассмотрим

В предварительных черновиках это было разрешено, потому что в С++ 03 значения типов неклассов никогда не имеют квалификации. Но предполагается, что const применяется в случае с rvalue-reference, потому что здесь мы ссылаемся на объекты (= память!), А drop const из неклассических значений r главным образом по той причине, что вокруг объекта нет объекта.

Проблема для динамических типов имеет сходный характер. В С++ 03 значения типа класса имеют известный динамический тип — это статический тип этого выражения. Потому что, чтобы иметь это по-другому, вам нужны ссылки или различия, которые оцениваются до значения lvalue. Это неверно с неназванными ссылками rvalue, но они могут демонстрировать полиморфное поведение. Чтобы решить эту проблему,

ссылки без имени rvalue становятся xvalues ​​. Они могут быть квалифицированными и потенциально отличаться от их динамического типа. Они, как и предполагалось, предпочитают ссылки rvalue во время перегрузки и не свяжутся с неконстантными ссылками lvalue.

То, что раньше было rvalue (литералы, объекты, созданные приведениями к типам без ссылки), теперь становится prvalue. Они имеют то же предпочтение, что и значения x во время перегрузки.

То, что ранее было lvalue, остается lvalue.

И две группы выполняются для захвата тех, которые могут быть квалифицированы и могут иметь разные динамические типы (glvalues ​​) и те, где перегрузка предпочитает привязку ссылки rvalue ( rvalues ​​).

Объекты и lvalue(адреса)

Язык программирования C++ — это C* 1 , расширенный введением классов, inline-функций, перегруженных операций, перегруженных имен функций, константных типов, ссылок, операций управления свободной памятью, проверки параметров функций. Коротко различия между С++ и «старым С» приведены в #15 В этом руководстве описывается язык по состоянию на Июнь 1985

2 Договоренности о Лексике

Есть шесть классов лексем: идентификаторы, ключевые слова, константы, строки, операторы и прочие разделители. Символы пробела, табуляции и новой строки, а также комментарии (собирательно — «белые места»), как описано ниже, игнорируются, за исключением тех случаев, когда они служат разделителями лексем. Некое пустое место необходимо для разделения идентификаторов, ключевых слов и констант, которые в противном случае окажутся соприкасающимися.
Если входной поток разобран на лексемы до данного символа, принимается, что следующая лексема содержит наиболее длинную строку символов из тех, что могут составить лексему.

21 Комментарии

Символы /* задают начало комментария, заканчивающегося символами */. Комментарии не могут быть вложенными. Символы // начинают комментарий, который заканчивается в конце строки, на которой они появились.

22 Идентификаторы (имена)

Идентификатор — последовательность букв и цифр произвольной длины; первый символ обязан быть буквой; подчерк ‘_’ считается за букву; буквы в верхнем и нижнем регистрах являются различными.

23 Ключевые слова

Следующие идентификаторы зарезервированы для использования в качестве ключевых слов и не могут использоваться иным образом:
Идентификаторы signed и volatile зарезервированы для применения в будущем.

24 Константы

Как описано ниже, есть несколько видов констант. В #26 приводится краткая сводка аппаратных характеристик, которые влияют на их размеры.

241 Целые константы

Целая константа, состоящая из последовательности цифр, считается восьмиричной, если она начинается с 0 (цифры ноль), и десятичной в противном случае. Цифры 8 и 9 не являются восьмиричными цифрами. Последовательность цифр, которой предшествует 0х или 0Х, воспринимается как шестнадцатеричное целое. В шестнадцатеричные цифры входят буквы от а или А до f или F, имеющие значения от 10 до 15 Десятичная константа, значение которой превышает наибольшее машинное целое со знаком, считается длинной (long); восьмеричная и шестнадцатеричная константа, значение которой превышает наибольшее машинное целое со знаком, считается long; в остальных случаях целые константы считаются int.

242 Явно заданные длинные константы

Десятичная, восьмиричная или шестнадцатиричная константа, за которой непосредственно стоит l (латинская буква «эль») или L, считается длинной константой.


243 Символьные константы

Символьная константа состоит из символа, заключенного в одиночные кавычки (апострофы), как, например, ‘х’. Значением символьной константы является численное значение символа в машинном наборе символов (алфавите). Символьные константы считаются данными типа int.
Некоторые неграфические символы, одиночная кавычка ‘ и обратная косая \, могут быть представлены в соответствие со следующей таблицей escape-последовательностей:

символ новой строки NL(LF) \n
горизонтальная табуляция NT \t
вертикальная табуляция VT \v
возврат на шаг BS \b
возврат каретки CR \r
перевод формата FF \f
обратная косая \ \\
одиночная кавычка (апостроф) \’
набор битов 0ddd \ddd
набор битов 0xddd \xddd

Escape-последовательность \ddd состоит из обратной косой, за которой следуют 1, 2 или 3 восьмеричных цифры, задающие значение требуемого символа. Специальным случаем такой конструкции является \0 (не следует ни одной цифры), задающая пустой символ NULL. Escape-последовательность \xddd состоит из обратной косой, за которой следуют 1, 2 или 3 шестнадцатиричных цифры, задающие значение требуемого символа. Если следующий за обратной косой символ не является одним из перечисленных, то обратная косая игнорируется.

244 Константы с плавающей точкой

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

245 Перечислимые константы

Имена, описанные как перечислители, (см. #85) являются константами типа int.

246 Описанные константы

Объект (#5) любого типа может быть определен как имеющий постоянное значение во всей области видимости (#41) его имени. В случае указателей для достижения этого используется декларатор *const; для объектов, не являющихся указателями, используется описатель const (#82).

25 Строки

Строка есть последовательность символов, заключенная в двойные кавычки: «. «. Строка имеет тип «массив символов» и класс памяти static (см. #4), она инициализируется заданными символами. Все строки, даже если они записаны одинаково, различны. Компилятор располагает в конце каждой строки нулевой (пустой) байт \0 с тем, чтобы сканирующая строку программа могла найти ее конец. В строке перед символом двойной кавычки » обязательно должен стоять \; кроме того, могут использоваться те же escape-последовательности, что были описаны для символьных констант. И, наконец, символ новой строки может появляться только сразу после \; тогда оба, — \ и символ новой строки, — игнорируются.

26 Характеристики аппаратного обеспечения

В нижеследующей таблице собраны некоторые характеристики аппаратного обеспечения, различающиеся от машины к машине.

3 Запись Синтаксиса

По используемым в данном руководстве синтаксическим правилам записи синтаксические категории выделяются курсивом а литеральные слова и символы шрифтом постоянной ширины* 2 . Альтернативные категории записываются на разных строках. Необязательный терминальный или нетерминальный символ обозначается нижним индексом «opt», так что
указывает на необязательность выражения в фигурных скобках. Синтаксис кратко изложен в #14.

4 Имена и Типы

Имя обозначает (денотирует) объект, функцию, тип, значение или метку. Имя вводится в программе описанием (#8). Имя может использоваться только внутри области текста программы, называемой его областью видимости. Имя имеет тип, определяющий его использование. Объект — это область памяти. Объект имеет класс памяти, определяющий его время жизни. Смысл значения, обнаруженного в объекте, определяется типом имени, использованного для доступа к нему.

41 Область видимости

Есть четыре вида областей видимости: локальная, файл, программа и класс.

Локальная: Имя, описанное в блоке (#92), локально в этом блоке и может использоваться только в нем после места описания и в охватываемых блоках. Исключение составляют метки (#912), которые могут использоваться в любом месте функции, в которой они описаны. Имена формальных параметров функции рассматриваются так, как если бы они были описаны в самом внешнем блоке этой функции.
Файл: Имя, описанное вне любого блока (#92) или класса (#85), может использоваться в файле, где оно описано, после места описания.
Класс: Имя члена класса локально для его класса и может использоваться только в функции члене этого класса (#852), после примененной к объекту его класса (#71) операции . или после примененной к указателю на объект его класса (#71) операции ->. На статические члены класса (#851) и функции члены можно также ссылаться с помощью операции :: там, где имя их класса находится в области видимости. Класс, описанный внутри класса (#8515), не считается членом, и его имя принадлежит охватывающей области видимости.

Имя может быть скрыто посредством явного описания того же имени в блоке или классе. Имя в блоке или классе может быть скрыто только именем, описанным в охватываемом блоке или классе. Скрытое нелокальное имя также может использоваться, когда его область видимости указана операцией :: (#71). Имя класса, скрытое именем, которое не является именем типа, все равно может использоваться, если перед ним стоит class, struct или union (#82). Имя перечисления enum, скрытое именем, которое не является именем типа, все равно может использоваться, если перед ним стоит enum (#82).

42 Определения

Описание (#8) является определением, за исключением тех случаев, когда оно описывает функции, не задавая тела функции (#10), когда оно содержит спецификатор extern (1) и в нем нет инициализатора или тела функции, или когда оно является описанием класса (#88).

43 Компоновка

Имя в файловой области видимости, не описанное явно как static, является общим для каждого файла многофайловой программы. Таковым же является имя функции. О таких именах говорится, что они внешние. Каждое описание внешнего имени в программе относится к тому же объекту (#5), функции (#87), классу (#85), перечислению (#810 ) или значению перечислителя (#810).
Типы, специфицированные во всех описаниях внешнего имени должны быть идентичны. Может быть больше одного определения типа, перечисления, inline-функции (#81) или несоставного const (#82), при условии, что определения идентичны, появляются в разных файлах и все инициализаторы являются константными выражениями (#12). Во всех остальных случаях должно быть ровно одно определение для внешнего имени в программе.
Реализация может потребовать, чтобы составное const, использованное там, где не встречено никакого определения const, должно быть явно описано extern и иметь в программе ровно одно определение. Это же ограничение может налагаться на inline-функции.

44 Классы памяти

Есть два описываемых класса памяти: автоматический и статический.

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

Статические объекты существуют и сохраняют свое значение в течение выполнения всей программы.

Некоторые объекты не связаны с именами и их времена жизни явно управляются операторами new и delete ; см. #72 и #914

45 Основные типы

Объекты, описанные как символы (char), достаточны для хранения любого элемента машинного набора символов, и если принадлежащий этому набору символ хранится в символьной переменной, то ее значение равно целому коду этого символа.
В настоящий момент имеются целые трех размеров, описываемые как short int, int и long int. Более длинные целые (long int) предоставляют не меньше памяти, чем более короткие целые (short int), но при реализации или длинные, или короткие, или и те и другие могут стать эквивалентными обычным целым. «Обычные» целые имеют естественный размер, задаваемый архитектурой центральной машины; остальные размеры делаются такими, чтобы они отвечали специальным потребностям.
Каждое перечисление (#89) является набором именованных констант. Свойства enum идентичны свойствам int.
Целые без знака, описываемые как unsigned, подчиняются правилам арифметики по модулю 2n, где n — число бит в их представлении.
Числа с плавающей точкой одинарной (float) и двойной (double) точности в некоторых машинных реализациях могут быть синонимами.
Поскольку объекты перечисленных выше типов вполне можно интерпретировать как числа, мы будем говорить о них как об арифметических типах. Типы char, int всех размеров и enum будут собирательно называться целыми типами. Типы float и double будут собирательно называться плавающими типами.
Тип данных void (пустой) определяет пустое множество значений. Значение (несуществующее) объекта void нельзя использовать никаким образом, не могут применяться ни явное, ни неявное преобразования. Поскольку пустое выражение обозначает несуществующее значение, такое выражение такое выражение может использоваться только как оператор выражение (#91) или как левый операнд в выражении с запятой (#715). Выражение может явно преобразовываться к типу void (#72).

44 Производные типы

Кроме основных арифметических типов концептуально существует бесконечно много производных типов, сконструированных из основных типов следующим образом:

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


В целом эти способы конструирования объектов могут применяться рекурсивно.
Объект типа void* (указатель на void) можно использовать для указания на объекты неизвестного типа.

5 Объекты и lvalue(адреса)

Объект есть область памяти; lvalue (адрес) есть выражение, ссылающееся на объект. Очевидный пример адресного выражения — имя объекта. Есть операции, дающие адресные выражения: например, если Е — выражение типа указатель, то *Е — адресное выражение, ссылающееся на объект, на который указывает Е. Термин «lvalue» происходит из выражения присваивания Е1=Е2, в котором левый операнд Е1 должен быть адресным (value) выражением. Ниже при обсуждении каждого оператора указывается, требует ли он адресные операнды и возвращает ли он адресное значение.

6 Преобразования

Определенные операции могут в зависимости от их операндов вызывать преобразование значения операнда от одного типа к другому. В этой части объясняется, каков ожидаемый результат таких преобразований. В #66 содержится краткое описание преобразований, требуемых наиболее стандартными операциями; оно будет дополняться по мере надобности в процессе обсуждения каждой операции. В #856 описываются преобразования, определяемые пользователем.

61 Символы и целые

Символ или короткое целое могут использоваться, если может использоваться целое. Во всех случаях значение преобразуется к целому. Преобразование короткого целого к длинному всегда включает в себя знаковое расширение; целые являются величинами со знаком. Содержат символы знаковый разряд или нет, является машинно зависимым; см. #26. Более явный тип unsigned char ограничивает изменение значения от 0 до машинно зависимого максимума.
В машинах, где символы рассматриваются как имеющие знак (знаковые), символы множества кода ASCII являются положительными. Однако, символьная константа, заданная восьмеричной esc- последовательностью подвергается знаковому расширению и может стать отрицательным числом; так например, ‘\377’ имеет значение -1
Когда длинное целое преобразуется в короткое или в char, оно урезается влево; избыточные биты просто теряются.

62 Float и double

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

63 Плавающие и целые

Преобразования плавающих значений в интегральный тип имеет склонность быть машинно зависимым. В частности, направление усечения отрицательных чисел различается от машины к машине. Если предоставляемого пространства для значения не хватает, то результат не определен.
Преобразование интегрального значения в плавающий тип выполняются хорошо. При нехватке в аппаратной реализации требуемых бит возникает некоторая потеря точности.

64 Указатели и целые

Выражение целого типа можно прибавить к указателю или вычесть из него; в таком случае первый преобразуется, как указывается при обсуждении операции сложения.
Можно производить вычитание над двумя указателями на объекты одного типа; в этом случае результат преобразуется к типу int или long в зависимости от машины; см. #74

65 Unsigned

Всегда при сочетании целого без знака и обычного целого обычное целое преобразуется к типу unsigned и результат имеет тип unsigned. Значением является наименьшее целое без знака, равное целому со знаком (mod 2**(размер слова)) (т.е. по модулю 2**(размер слова)). В дополнительном двоичном представлении это преобразование является пустым, и никаких реальных изменений в двоичном представлении не происходит.
При преобразовании целого без знака в длинное значение результата численно совпадает со значением целого без знака. Таким образом, преобразование сводится к дополнению нулями слева.

66 Арифметические преобразования

Большое количество операций вызывают преобразования и дают тип результата одинаковым образом. Этот стереотип будет называться «обычным арифметическим преобразованием».

Во-первых, любые операнды типа char, unsigned char или short преобразуются к типу int.
Далее, если один из операндов имеет тип double, то другой преобразуется к типу double и тот же тип имеет результат.
Иначе, если один из операндов имеет тип unsigned long, то другой преобразуется к типу unsigned long и таков же тип результата.
Иначе, если один из операндов имеет тип long, то другой преобразуется к типу long и таков же тип результата.
Иначе, если один из операндов имеет тип unsigned, то другой преобразуется к типу unsigned и таков же тип результата.
Иначе оба операнда должны иметь тип int и таков же тип результата.

67 Преобразования указателей

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

Константа 0 может преобразовываться в указатель, и гарантируется, что это значение породит указатель, отличный от указателя на любой объект.
Указатель любого типа может преобразовываться в void*.
Указатель на класс может преобразовываться в указатель на открытый базовый класс этого класса; см. #853
Имя вектора может преобразовываться в указатель на его первый элемент.
Идентификатор, описанный как «функция, возвращающая . «, всегда, когда он не используется в позиции имени функции в вызове, преобразуется в «указатель на функцию, возвращающую . «.

68 Преобразования ссылок

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

Ссылка на класс может преобразовываться в ссылку на открытый базовый класс этого класса; см. #863

7 ВЫРАЖЕНИЯ

Приоритет операций в выражениях такой же, как и порядок главных подразделов в этом разделе, наибольший приоритет у первого. Так например, выражения, о которых говорится как об операндах операции + (#74) — это те выражения, которые определены в ##71-74Внутри каждого подраздела операции имеют одинаковый приоритет. В каждом подразделе для рассматриваемых в нем операций определяется их левая или правая ассоциативность (порядок обработки операндов). Приоритет и ассоциативность всех операций собран вместе в описании грамматики в ##14
В остальных случаях порядок вычисления выражения не определен. Точнее, компилятор волен вычислять подвыражения в том порядке, который он считает более эффективным, даже если подвыражения вызывают побочные эффекты. Порядок возникновения побочных эффектов не определен. Выражения, включающие в себя коммутативные и ассоциативные операции (*, +, &, |, ^), могут быть реорганизованы произвольным образом, даже при наличии скобок; для задания определенного порядка вычисления выражения необходимо использовать явную временную переменную.
Обработка переполнения и контроль деления при вычислении выражения машинно зависимы. В большинстве существующих реализаций C++ переполнение целого игнорируется; обработка деления на 0 и всех исключительных ситуаций с числами с плавающей точкой различаются от машины к машине и обычно могут регулироваться библиотечными функциями.
Кроме стандартного значения, описанного в ##72-715, операции могут быть перегружены* 3 , то есть, могут быть заданы их значения для случая их применения к типам, определяемым пользователем; см. #716

71 Основные выражения

Основные выражения, включающие в себя . , -> , индексирование и вызовы функций, группируются слева направо.
Идентификатор есть первичное выражение, причем соответственно описанное (#8). Имя_функции_операции есть идентификатор со специальным значением; см. #716 и #851
Операция . за которой следует идентификатор из файловой области видимости, есть то же, что и идентификатор. Это позволяет ссылаться на объект даже в том случае, когда его идентификатор скрыт (#41).
Typedef-имя (#88) , за которым следует . после чего следует идентификатор, является первичным выражением. Typedef-имя должно обозначать класс (#85), и идентификатор должен обозначать член этого класса. Его тип специфицируется описанием идентификатора. Typedef-имя может быть скрыто именем, которое не является именем типа. В этом случае typedef-имя все равно может быть найдено и его можно использовать.
Константа является первичным выражением. Ее тип должен быть int, long или double в зависимости от ее формы.
Строка является первичным выражением. Ее тип — «массив символов». Обычно он сразу же преобразуется в указатель на ее первый символ (#67).
Ключевое слово this является локальной переменной в теле функции члена (см. #85) . Оно является указателем на объект, для которого функция была вызвана.
Выражение, заключенное в круглые скобки, является первичным выражением, чей тип и значение те же, что и у незаключенного в скобки выражения. Наличие скобок не влияет на то, является выражение lvalue или нет.
Первичное выражение, за которым следует выражение в квадратных скобках, является первичным выражением. Интуитивный смысл — индекс. Обычно первичное выражение имеет тип «указатель на . «, индексирующее выражение имеет тип int и тип результата есть «. «. Выражение Е1[Е2] идентично (по определению) выражению *((E1)+(E2)). Все тонкие места, необходимые для понимания этой записи, содержатся в этом разделе вместе с обсуждением в ## 71, 72 и 74, соответственно, идентификаторов, * и + ; ниже, в #842 приводятся следствия из этого.
Вызов функции является первичным выражением, за которым следуют скобки, содержащие список (возможно, пустой) разделенных запятыми выражений, составляющих фактические параметры для функции. Первичное выражение должно иметь тип «функция, возвращающая . » или «указатель на функцию, возвращающую . «, и результат вызова функции имеет тип «. «.
Каждый формальный параметр инициализируется фактическим параметром (#86). Выполняются стандартные (#66-8) и определяемые пользователем преобразования (#856). Функция может изменять значения своих формальных параметров, но эти изменения не могут повлиять на значения фактических параметров за исключением случая, когда формальный параметр имеет ссылочный тип.
Функция может быть описана как получающая меньше или больше параметров, чем специфицировано в описании функции (#84). Каждый фактический параметр типа float, для которого нет формального параметра, преобразуются к типу double; и, как обычно, имена массивов преобразуются к указателям. Порядок вычисления параметров не определен языком; имейте в виду различия между компиляторами.
Допустимы рекурсивные вызовы любых функций.
Первичное выражение, после которого стоит точка, за которой следует идентификатор (или идентификатор, уточненный typedef-именем с помощью операции ::) является выражением. Первое выражение должно быть объектом класса, а идентификатор должен именовать член этого класса. Значением является именованный член объекта, и оно является адресным, если первое выражение является адресным. Следует отметить, что «классовые объекты» могут быть структурами (#8512) или объединениями (#8513).
Первичное выражение, после которого стоит стрелка ( -> ), за которой следует идентификатор (или идентификатор, уточненный typedef-именем с помощью операции ::) является выражением. Первое выражение должно быть указателем на объект класса, а идентификатор должен именовать член этого класса. Значение является адресом, ссылающимся на именованный член класса, на который указывает указательное выражение. Так, выражение E1->MOS есть то же, что и (*E1).MOS. Классы обсуждаются в #85
Если первичное выражение дает значение типа «указатель на . » (см. #84 и #863), значением выражения был объект, обозначаемый ссылкой. Ссылку можно считать именем объекта; см. #863

72 Унарные операции

Выражения с унарными операциями группируют справа налево:
Унарная операция * означает косвенное обращение: выражение должно быть указателем и результатом будет lvalue, ссылающееся на объект, на который указывает выражение. Если выражение имеет тип «указатель на . «, то тип результата есть «. «.
Результатом унарной операции & является указатель на объект, на который ссылается операнд. Операнд должен быть lvalue. Если выражение имеет тип «. «, то тип результата есть «указатель на . «.
Результатом унарной операции + является значение ее операнда после выполнения обычных арифметических преобразований. Операнд должен быть арифметического типа.
Результатом унарной операции — является отрицательное значение ее операнда. Операнд должен иметь целый тип. Выполняются обычные арифметические преобразования. Отрицательное значение беззнаковой величины вычисляется посредством вычитания ее значения из 2n, где n -число битов в целом типа int.
Результатом операции логического отрицания ! является 1, если значение операнда 0, и 0, если значение операнда не 0 Результат имеет тип int. Применима к любому арифметическому типу или к указателям.
Операция

дает дополнение значения операнда до единицы. Выполняются обычные арифметические преобразования. Операнд должен иметь интегральный тип.

721 Увеличение и Уменьшение

Операнд префиксного ++ получает приращение. Операнд должен быть адресным . Значением является новое значение операнда, но оно не адресное. Выражение ++x эквивалентно x+=1 По поводу данных о преобразованиях см. обсуждение операций сложения (#74) и присваивания (#714).
Операнд префиксного — уменьшается аналогично действию префиксной операции ++.
Значение, получаемое при использовании постфиксного ++, есть значение операнда. Операнд должен быть адресным. После того, как результат отмечен, объект увеличивается так же, как и в префиксной операции ++. Тип результата тот же, что и тип операнда.
Значение, получаемое при использовании постфиксной —, есть значение операнда. Операнд должен быть адресным. После того, как результат отмечен, объект увеличивается так же, как и в префиксной операции ++. Тип результата тот же, что и тип операнда.

722 Sizeof

Операция sizeof дает размер операнда в байтах. (Байт не определяется языком иначе, чем через значение sizeof. Однако, во всех существующих реализациях байт есть пространство, необходимое для хранения char.) При применении к массиву результатом является полное количество байтов в массиве. Размер определяется из описаний объектов, входящих в выражение. Семантически это выражение является беззнаковой константой и может быть использовано в любом месте, где требуется константа.
Операцию sizeof можно также применять к заключенному в скобки имени типа. В этом случае она дает размер, в байтах, объекта указанного типа.

723 Явное Преобразование Типа

Простое_имя_типа (#82), возможно, заключенное в скобки, за которым идет заключенное в скобки выражение (или список_выражений, если тип является классом с соответствующим образом описанным конструктором #855) влечет преобразование значения выражения в названный тип. Чтобы записать преобразование в тип, не имеющий простого имени, имя_типа (#87) должно быть заключено в скобки. Если имя типа заключено в скобки, выражение заключать в скобки необязательно. Такая запись называется приведением к типу.
Указатель может быть явно преобразован к любому из интегральных типов, достаточно по величине для его хранения. То, какой из int и long требуется, является машинно зависимым. Отобразующая функция также является машинно зависимой, но предполагается, что она не содержит сюрпризов для того, кто знает структуру адресации в машине. Подробности для некоторых конкретных машин были приведены в #26
Объект интегрального типа может быть явно преобразован в указатель. Отображающая функция всегда превращает целое, полученное из указателя, обратно в тот же указатель, но в остальных случаях является машинно зависимой.
Указатель на один тип может быть явно преобразован в указатель на другой тип. Использование полученного в результате указателя может привести к исключительной ситуации адресации, если исходный указатель не указывает на объект, соответствующим образом выравненный в памяти. Гарантируется, что указатель на объект данного размера может быть преобразован в указатель на объект меньшего размера и обратно без изменений. Различные машины могут различаться по числу бит в указателях и требованиям к выравниванию объектов. Составные объекты выравниваются по самой строгой границе, требуемой каким-либо из его составляющих.
Объект может преобразовываться в объект класса только если был описан соответствующий конструктор или операция преобразования (#856).
Объект может явно преобразовываться в ссылочный тип &X, если указатель на этот объект может явно преобразовываться в X*.

724 Свободная Память

Операция new создает объект типа имя_типа (см. #87), к которому он применен. Время жизни объекта, созданного с помощью new, не ограничено областью видимости, в которой он создан. Операция new возвращает указатель на созданный ей объект. Когда объект является массивом, возвращается указатель на его первый элемент. Например, и new int и new int[10] возвращают int*. Для объектов некоторых классов надо предоставлять инициализатор (#862). Операция new (#72) для получения памяти вызывает функцию
Параметр задает требуемое число байтов. Память будет инициализирована. Если operator new() не может найти требуемое количество памяти, то она возвращает ноль.
Операция delete уничтожает объект, созданный операцией new. Ее результат является void. Операнд delete должен быть указателем, возвращенным new. Результат применения delete к указателю, который не был получен с помощью операции new. Однако уничтожение с помощью delete указателя со значением ноль безвредно.
Чтобы освободить указанную память, операция delete вызывает функцию
В форме
второй параметр указывает на вектор, а первое выражение задает число элементов этого вектора. Задание числа элементов является избыточным за исключением случаев уничтожения векторов некоторых классов; см. #858

73 Мультипликативные операции

Мультипликативные операции *, / и % группируют слева направо. Выполняются обычные арифметические преобразования.

мультипликативное_выражение:
Бинарная операция * определяет умножение. Операция * ассоциативна и выражения с несколькими умножениями на одном уровне могут быть реорганизованы компилятором.
Бинарная операция / определяет деление. При делении положительных целых округление осуществляется в сторону 0, но если какой-либо из операндов отрицателен, то форма округления является машинно зависимой. На всех машинах, охватываемых данным руководством, остаток имеет тот же знак, что и делимое. Всегда истинно, что (a/b)*b + a%b равно a (если b не 0).
Бинарная операция % дает остаток от деления первого выражения на второе. Выполняются обычные арифметические преобразования. Операнды не должны быть числами с плавающей точкой.

74 Аддитивные операции

Аддитивные операции + и — группируют слева направо. Выполняются обычные арифметические преобразования. Каждая операция имеет некоторые дополнительные возможности, связанные с типами.

аддитивное_выражение:
Результатом операции + является сумма операндов. Можно суммировать указатель на объект массива и значение целого типа. Последнее во всех случаях преобразуется к смещению адреса с помощью умножения его на длину объекта, на который указывает указатель. Результатом является указатель того же типа, что и исходный указатель, указывающий на другой объект того же массива и соответствующим образом смещенный от первоначального объекта. Так, если P есть указатель на объект массива, то выражение P+1 есть указатель на следующий объект массива.
Никакие другие комбинации типов для указателей не допустимы.
Операция + ассоциативна и выражение с несколькими умножениями на одном уровне может быть реорганизовано компилятором.
Результатом операции — является разность операндов. Выполняются обычные арифметические преобразования. Кроме того, значение любого целого типа может вычитаться из указателя, в этом случае применяются те же преобразования, что и к сложению.
Если вычитаются указатели на объекты одного типа, то результат преобразуется (посредством деления на длину объекта) к целому, представляющему собой число объектов, разделяющих объекты, указанные указателями. В зависимости от машины результирующее целое может быть или типа int, или типа long; см. #26 Вообще говоря, это преобразование будет давать неопределенный результат кроме тех случаев, когда указатели указывают на объекты одного массива, поскольку указатели, даже на объекты одинакового типа, не обязательно различаются на величину, кратную длине объекта.

75 Операции сдвига

Операции сдвига > группируют слева направо. Обе выполняют одно обычное арифметическое преобразование над своими операндами, каждый из которых должен быть целым. В этом случае правый операнд преобразуется к типу int; тип результата совпадает с типом левого операнда. Результат не определен, если правый операнд отрицателен или больше или равен длине объекта в битах.

сдвиговое_выражение:
Значением Е1 > Е2 является Е1 , сдвинутое вправо на Е2 битовых позиций. Гарантируется, что сдвиг вправо является логическим (заполнение нулями), если Е1 является unsigned; в противном случае он может быть арифметическим (заполнение копией знакового бита).

76 Операции отношения

Операции отношения (сравнения) группируют слева направо, но этот факт не очень-то полезен: a (больше чем), = все дают 0, если заданное соотношение ложно, и 1, если оно истинно. Тип результата int. Выполняются обычные арифметические преобразования. Могут сравниваться два указателя; результат зависит от относительного положения объектов, на которые указывают указатели, в адресном пространстве. Сравнение указателей переносимо только если указатели указывают на объекты одного массива.

77 Операции равенства

выражение_равенства:
Операции == и != в точности аналогичны операциям сравнения за исключением их низкого приоритета. (Так, a

78 Операция побитовое И

И-выражение:
Операция & ассоциативна, и выражения, содержащие &, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция И операндов. Операция применяется только к целым операндам.

79 Операция побитовое исключающее ИЛИ

исключающее_ИЛИ_выражение:
Операция ^ ассоциативна, и выражения, содержащие ^, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция исключающее ИЛИ операндов. Операция применяется только к целым операндам.

710 Операция побитовое включающее ИЛИ

включающее_ИЛИ_выражение:
Операция | ассоциативна, и выражения, содержащие |, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция включающее ИЛИ операндов. Операция применяется только к целым операндам.

711 Операция логическое И

логическое_И_выражение:
Операция && группирует слева направо. Она возвращает 1, если оба операнда ненулевые, и 0 в противном случае. В противоположность операции & операция && гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд есть 0
Операнды не обязаны иметь один и тот же тип, но каждый из них должен иметь один из основных типов или быть указателем. Результат всегда имеет тип int.

712 Операция логическое ИЛИ

логическое_ИЛИ_выражение:
Операция || группирует слева направо. Она возвращает 1, если хотя бы один из ее операндов ненулевой, и 0 в противном случае. В противоположность операции | операция || гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд не есть 0
Операнды не обязаны иметь один и тот же тип, но каждый из них должен иметь один из основных типов или быть указателем. Результат всегда имеет тип int.

713 Условная операция

условное_выражение:
Условная операция группирует слева направо. Вычисляется первое выражение, и если оно не 0, то результатом является значение второго выражения, в противном случае значение третьего выражения. Если это возможно, то выполняются обычные арифметические преобразования для приведения второго и третьего выражения к общему типу. Если это возможно, то выполняются преобразования указателей для приведения второго и третьего выражения к общему типу. Вычисляется только одно из второго и третьего выражений.

714 Операции присваивания

Есть много операций присваивания, все группируют слева направо. Все в качестве левого операнда требуют lvalue, и тип выражения присваивания тот же, что и у его левого операнда. Это lvalue не может ссылаться на константу (имя массива, имя функции или const). Значением является значение, хранящееся в левом операнде просле выполнения присваивания.

операция_присваивания: одна из
В простом присваивании с = значение выражения замещает собой значение объекта, на который ссылается операнд в левой части. Если оба операнда имеют арифметический тип, то при подготовке к присваиванию правый операнд преобразуется к типу левого. Если аргумент в левой части имеет указательный тип, аргумент в правой части должен быть того же типа или типа, кторый может быть преобразован к нему, см. #67 Оба операнда могут быть объектами одного класса. Могут присваиваться объекты некоторых производных классов; см. #853
Присваивание объекту типа «указатель на . » выполнит присваивание объекту, денотируемому ссылкой.
Выполнение выражения вида E1 op= E2 можно представить себе как эквивалентное E1 = E1 op (E2); но E1 вычисляется только один раз. В += и -= левый операнд может быть указателем, и в этом случае (интегральный) правый операнд преобразуется так, как объяснялось в #74; все правые операнды и не являющиеся указателями левые должны иметь арифметический тип.

715 Операция запятая

запятая_выражение:
Пара выражений, разделенных запятой, вычисляется слева направо, значение левого выражения теряется. Тип и значение результата являются типом и значением правого операнда. Эта операция группирует слева направо. В контексте, где запятая имеет специальное значение, как например в списке фактических параметров функции (#71) и в списке инициализаторов (#86), операция запятая, как она описана в этом разделе, может появляться только в скобках; например,
имеет три параметра, вторым из которых является значение 5

716 Перегруженные операции

Большинство операций может быть перегружено, то есть, описано так, чтобы они получали в качестве операндов объекты классов (см. #8511). Изменить приоритет операций невозможно. Невозможно изменить смысл операций при применении их к неклассовым объектам. Предопределенный смысл операций = и & (унарной) при применении их к объектам классов может быть изменен.
Эквивалентность операций, применяемых к основным типам (например, ++a эквивалентно a+=1), не обязательно выполняется для операций, применяемых к классовым типам. Некоторые операции, например, присваивание, в случае применения к основным типам требуют, чтобы операнд был lvalue; это не требуется для операций, описанных для классовых типов.

7161 Унарные операции

Унарная операция, префиксная или постфиксная, может быть определена или с помощью функции члена (см. #854), не получающей параметров, или с помощью функции друга (см. #8510), получающей один параметр, но не двумя способами одновременно. Так, для любой унарной операции @, x@ и @x могут интерпретироваться как x.операция@() или операция@(x). При перегрузке операций ++ и — невозможно различить префиксное и постфиксное использование.

7162 Бинарные операции

Бинарная операция может быть определена или с помощью функции члена (см. #854), получающей один параметр, или с помощью функции друга (см. #859), получающей два параметра, но не двумя способами одновременно. Так, для любой бинарной операции @, x@y может быть проинтерпретировано как x.операция@(y) или операция@(x,y).

«Адресное выражение должно быть lvalue или обозначением функции» при передаче адреса объекта

2 Reck Hou [2012-05-09 15:52:00]

Вот часть моего кода:

После компиляции у меня возникло 2 проблемы:

_pObject = pObject; : нет жизнеспособного перегруженного ‘=’

pClassA->init(&this); : выражение адреса должно быть lvalue или обозначением функции

Я запутался в этих проблемах. Как я могу это исправить?

2 ответа

2 Решение Gorpik [2012-05-09 16:30:00]

Во-первых, в вопросе есть опечатка. Я предполагаю, что A и classA относятся к тому же классу, что и для B и classB .

1) Одно из немногих различий между ссылкой и указателем заключается в том, что вы не можете назначить другое значение ссылке после ее инициализации. Таким образом, вы просто не можете назначить _pObject , хотя вы можете инициализировать его в списке инициализации конструктора для класса A :

2) &this — это адрес this , но вам действительно нужна ссылка на значение, на которое указывает this . Вместо этого вам нужно использовать *this . Хотя мы уже видели, что нет способа заставить функцию classA::init работать с вашим текущим классом. Если вы действительно хотите изменить значение _pObject после того, как объект был создан, вам нужно сделать его classB* вместо classB& .

1) В этом контексте вы должны использовать *this , поскольку &this имеет тип ClassB** , а не ClassB& ;

2) Вы можете только инициализировать переменные-члены-ссылки в конструкторе:

(Кстати, я полагаю, что вы просто опустили оператор delete только для краткости)

Углубляемся в C++: move семантика и rvalue

В этой статье разобраны основные преимущества и нюансы move семантики в C++11 и старше. Всё описанное в этой статье было проверено на компиляторе Clang 6.0.1 с библиотекой libc++ на x86, GNU/Linux.

Введение в move

Move семантика позволяет переместить объект вместо его копирования для увеличения производительности. Проще всего понять семантику перемещения на примере. В качестве этого примера будет использоваться класс String :

При передаче объекта этого класса в функцию, принимающую его по значению, — назовём её by_value() — произойдёт следующее:

Получается 4 обращения к аллокатору, что достаточно накладно. Но если объект String больше не понадобится, а функцию by_value() менять нельзя, то можно переместить объект, а не копировать. Для этого необходимо написать конструктор перемещения для класса String :

Параметр конструктора перемещения other , во-первых, неконстантный, т.к. конструктор его изменяет; во-вторых, является rvalue -ссылкой ( && ), а не lvalue -ссылкой ( & ). Об их отличиях будет сказано далее. Сам конструктор переносит Си-строку с other на this , делая other пустым.

Конструктор перемещения в общем случае не медленнее, а зачастую даже быстрее конструктора копирования, но ничего не мешает программисту поместить sleep(10’000) в конструктор перемещения.

Для вызова конструктора перемещения вместо конструктора копирования можно использовать std::move() . Теперь пример выглядит следующим образом:

Количество обращений к аллокатору уменьшилось вдвое!

rvalue и lvalue

Основное отличие rvalue от lvalue в том, что объекты rvalue могут быть перемещены, тогда как объекты lvalue всегда копируются.

Это «могут быть» лучше всего демонстрируют следующие два примера:

Этот код работает не так, как от него ожидается. std::move() всё ещё конвертирует lvalue в rvalue , но конвертация сохраняет все модификаторы, в том числе и const . Затем компилятор выбирает среди двух конструкторов класса String самый подходящий. Из-за того что компилятор не может отправить const rlvaue туда, где ожидается non-const rvalue , он выбирает конструктор копирования, и const rvalue конвертируется обратно в const lvalue . Вывод: следите за модификаторами объектов, т.к. они учитываются при выборе одной из перегрузок функции.

Второй пример демонстрирует правило: аргументы и результат функции могут быть как rvalue , так и lvalue , но параметры функций могут быть только lvalue . Аргумент — это то, что передаётся в функцию. Он инициализирует параметр, который доступен непосредственно внутри функции.

Хотя параметр string функции f() и имеет тип rvalue -ссылки, он является lvalue и требует явной конвертации в rvalue перед передачей в функцию g() . Этим и занимается std::move() .

Универсальные ссылки

Универсальные ссылки могут быть как rvalue -, так и lvalue -ссылкой в зависимости от аргументов или результата функции. Используются в шаблонах и в auto&& :

Компилятор на основе этого шаблона генерирует 2 функции, одна из которых принимает lvalue , другая — rvalue , если они будут использоваться. Если программист хочет использовать перемещение для rvalue -ссылки и простое копирование для lvalue -ссылки, то он может использовать std::forward() , который приводит свой аргумент к rvalue только тогда, когда его тип является rvalue -ссылкой. std::forward() требует явного указания шаблонного параметра даже с автоматическим выводом шаблонов в С++17.

Универсальная ссылка обязана быть шаблонным параметром (отсюда такое странное определение шаблона функции в примере) в формате T&& . Например, std::vector && уже не универсальная, а rvalue -ссылка.


Свёртывание ссылок

На самом деле разницы между rvalue -ссылкой и универсальной ссылкой нет. Универсальная ссылка — лишь удобная абстракция над rvalue -ссылкой, которой многие пользуются. Но как тогда rvalue -ссылка превращается в lvalue -ссылку при lvalue аргументе? Всё дело в свёртывании ссылок.

При вызове template_func(string) компилятор генерирует следующий заголовок функции:

И получается ссылка на ссылку! Вручную так сделать нельзя, но шаблоны могут. Далее компилятор свёртывает ссылку на ссылку. Свертывание производится по следующему правилу: результатом свертывания будет rvalue -ссылка только тогда, когда обе ссылки являются rvalue -ссылками.

Именно из-за этого безобразия проще использовать абстракцию универсальных ссылок.

Подробнее о move семантике и rvalue можно узнать из книги С. Мейерса «Эффективный и современный С++: 42 рекомендации по использованию С++ 11 и С++14» ISBN: 978-5-8459-2000-3.

Copy/move elision

Copy/move elision — это оптимизация, при которой компилятор может убрать некоторые вызовы конструктора копирования и деструктора, но в данный момент только при возврате объекта из функции, и только если тип возвращаемого объекта полностью совпадает с типом функции.

Поэтому при возврате из функции использование std::move() может снизить производительность, ограничив компилятор в Copy elision оптимизации, ведь отсутствие конструктора быстрее, чем конструктор перемещения.

Здесь std::move() только замедляет код, добавляя лишний вызов String(String&& other) и

В C++20 copy/move elision может быть расширен, благодаря чему в некоторых случаях использование std::move() также снизит производительность. Подробнее о расширении copy/move elision можно узнать из видеозаписи со встречи рабочей группы по стандартизации С++ в московском офисе Яндекса.

lvalue to rvalue conversion

Что такое lvalue to rvalue conversion? В этой статье непонятно следующее:

Очевидно, что если мы будем использовать любое из приведенных ранее lvalue-выражений в контексте, требующем значения объекта (например, в правой части операции присваивания), использование компилятором адресов будет ошибкой. Т.е., хотя выражение i является lvalue («адрес и значение»), компилятор должен использовать соответствующее rvalue («значение»). В терминах стандарта C++ это называется преобразованием lvalue к rvalue (lvalue-to-rvalue conversion).

Что же это такое glvalue, xvalue, prvalue

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

Выражением мы будем называть один или несколько операндов, которые правильным образом соединены знаками операций. Каждое выражение имеет тип, значение, являющееся результатом вычисления этого выражения, и категорию значения. В простейшем случае выражением является одна единственная переменная, и в этом случае значением такого выражения будет значение данной переменной, ну и, разумеется, типом его будет тот тип, к которому относится данная переменная. С категорией значения все обстоит значительно сложнее. До недавнего времени C++ вполне обходился всего двумя категориями значения, а теперь их стало целых пять.

К большому сожалению, чтобы полностью понять, что такое категория значения, нужно изучить C++ практически до конца, а вот пользоваться этим нужно уже с самого начала. Трудности здесь возникают в связи с тем, что у некоторых значений, которые Вы используете в своих программах, могут быть адреса, одни из которых доступны для использования, а другие не доступны. Ещё одним фактором, который несколько осложняет понимание того, что из себя представляет категория значения, состоит в том, что классификация выражений, по категориям их значений осуществляется при помощи таксономии, которую мы приводим на следующем рисунке:

Рис. 2.1 Таксономия категорий выражений

В конечном счёте, каждое выражение будет иметь одну из следующих категория: lvalue, xvalue или prvalue.

  • Категорией glvalue представлены выражения, вычисления которых дают нам возможность отождествлять из с конкретными объектами, битовыми полями или функциями.
  • Категорией prvalue представлены выражения, результатами вычисления которых инициализируются объекты и битовые поля, а также те выражения, результаты вычисления которых используются для вычисления значений операндов тех или иных операций в соответствии с контекстом, в котором они применяются.
  • Категорией xvalue представлены выражения, которые являются glvalue и относящиеся к объекту или битовому полю, ресурсы которых можно использовать повторно (обычно поскольку время жизни любого такого объекта подходит к своему концу).
  • Категорией lvalue представлены выражения, являющиеся glvalue, но не являющиеся xvalue.
  • Категорией rvalue представлены выражения, являющиеся либо prvalue, либо xvalue.

Как видите, а это определение из стандарта C++, здесь все смешалось в кучу. Сразу бросается в глаза, что простого и ясного определения, что есть что, не получилось, во всяком случае, с первого взгляда разобраться в этом зоопарке не так-то уж и легко. Вот нам теперь и предстоит понять, хотя бы приблизительно, что означает каждая категория значения. Кстати, здесь тоже есть небольшой подвох, поскольку на самом деле, категория значения не является атрибутом значения, а атрибутом выражения, а точнее значения, в которое это выражение вычисляется, но в конечном счёте все-таким выражения.

И как же нам поступать в таком случае, чтобы успешно двигаться вперёд? Один из проверенных способов состоит в том, чтобы опираться на классику. На данный момент, пока наши знания по C++ весьма скудные, мы будем опираться на так называемый упрощённый подход к категориям значения. Все glvalue выражения мы будем рассматривать пока, как lvalue выражения, отбрасывая возможные нюансы, присущие xvalue, что, кстати, так и было в не таком уж далёком прошлом. Выражения, которые относятся к категории glvalue, характеризуются тем, что они несут некоторую идентичность тем объектам и значениям, в которые они вычисляются. Такая идентичность в языках программирования связывается с тем, что мы можем отличить один объект на основе их расположения в памяти. Иными словами, каждый такой объект имеет некоторый вполне определённый адрес в памяти. Это и есть главное отличие выражений glvalue от остальных, но не только.

Другая характеристика glvalue выражений состоит в том, что мы до них можем дотянуться простым и естественным способом. Зная адреса таких объектов, мы можем легко манипулировать ими, используя для этой цели весь штатный набор средств C++. Другие выражения, такие как xvalue, тоже могут иметь вполне определённые адреса, но дело в том, что в силу специфики использования таких объектов, эти адреса могут быть известны только компьютеру, а не Вам, а поэтому дотянуться до таких объектов бывает порою сложно и обычно это делается в тот момент, когда такой объект готовится завершить своё существование. С такими объектами мы столкнёмся ещё не скоро.

Ещё одной категорией значения является prvalue, которая представляет так называемые чистые значения. Конечно, это не означает, что есть каки-то грязные значения. Просто этим термином обозначаются такие сущности, которые характеризуются исключительно одними значениями, а больше ничего у них нет. Никаких адресов и какой-либо иной идентифицирующей их информации для них не предусмотрено. Наверно категория prvalue – это самая простая категория значения из всех имеющихся. Примером выражений, принадлежащих этой категории, являются обычные литералы встроенных типов, за исключением строковых литералов, которые принадлежат к категории lvalue. Вообще если то или иное выражение позволяет в каком-либо его месте использовать prvalue, то в этом месте Вы можете использовать выражение из любой другой категории, конечно, при условии совместимости этого другого выражения по типу.

Таким образом, мы постепенно начинаем понимать, что же роднит друг с другом категории xvalue и prvalue. В первом случае использование адреса, в которое вычисляется это выражение, затруднено, а объект, в который это выражение вычисляется, уже готовится покинуть этот бренный мир. Во втором же случае такого адреса просто нет. Ну а коли нет адреса, то туда и занести ничего нельзя. C++ – это ведь не сказка, типа присвой туда, не знаю куда и присвой то, не знаю что. Вот теперь мы потихоньку подходим к тому, чтобы яснее понять, что же из себя представляет rvalue. Исторически в C++ rvalue называлось все то, что можно было использоваться в правой части операции присваивания и нельзя было использовать в его левой части. Сейчас же rvalue является все то, что действительно нельзя использовать в левой части операции присваивания, а также все то, что можно, но совсем не для этого, а для того, чтобы позаимствовать у объекта какие-либо ресурсы, которыми он может владеть, перед тем как этот объект тихо скончается.

Значения выражений, относящиеся к категории lvalue, представляют такие объекты, которые, обладая идентичностью, то есть уникальным адресом в памяти, могут в принципе стоять в левой части операции присваивания. Некоторые из них действительно могут, а некоторым это специальным образом запрещают, когда такие объекты создаются в форме именованных констант. Но природу объекта это не меняет, поскольку внешнее ограничение на набор допустимых методов по работе с данным объектом природу этого объекта и его идентичность нисколько не изменяют. И хотя на рисунке, который приведён выше, это никак не указано, в первом случае мы говорим о модифицируемых lvalue, а во втором случае о немодифицируемых lvalue.

Когда Вы познакомитесь со ссылками связь между различными категориями значения и так называемой ссылочностью типов будет представляться в следующем упрощённом виде: категорией значения выражений, вычисляющихся в обычный не ссылочный тип, будет prvalue. Категорией значения выражений, вычисляющихся в некоторую обычную левостороннюю ссылку, будет lvalue. И, наконец, категорией значения выражений, вычисляющихся в некоторую правостороннюю ссылку, будет xvalue. Проще всего в коде это можно выразить следующим образом:

Давайте ещё раз вернёмся к рисунку и обсудим оставшиеся детали, которые могли ускользнуть от нас при первом рассмотрении. Первое, что бросается в глаза, так это то, что виновником и смутьяном, из-за которого и возникла вся эта чехарда, без сомнения является xvalue. Выражения с категорией xvalue являются одновременно и glvalue, и rvalue. И хотя они обладают некоторыми свойствами и тех и других, но не в такой абсолютной и ультимативной форме, в какой они выражены у lvalue и prvalue соответственно. Абсолютно не исключено, что в будущем не будут внесены какие-либо изменения, как в терминологию, так и в саму схематику, а пока в виде нескольких таблиц мы приводим небольшую шпаргалку, которой также можно пользоваться для того, чтобы определить категорию значения, к которой принадлежит то или иное выражение.

Выражения, принадлежащие к категории prvalue:

1) Все литералы за исключением строковых литералов принадлежат к категории prvalue. Строковые литералы принадлежат к категории lvalue.
2) Любой вызов функции, возвращающий не ссылочный тип, включая и указатели, принадлежат к категории prvalue.
3) Как и в случае любой функции, возвращающей не ссылочный тип, результат арифметического выражения относится к prvalue в том случае, если не задействован ни одна из операций составного присваивания, такая как +=.
4) Адрес любого lvalue принадлежат к категории prvalue. Ещё раз обращаем Ваше внимание на то, что адрес prvalue получить нельзя.
5) Результат приведения lvalue к не ссылочному типу принадлежат к категории prvalue. Точно такое же поведение и у типов, которые не являются тривиальными.
6) Анонимные функции вне зависимости от их захвата принадлежат к категории prvalue, как и любые другие литералы.
7) Постфиксные операции, которые возвращают копию прежнего значения, тип которого не является ссылочным, принадлежат к категории prvalue.
8) Конструкция любого типа, использующая универсальную инициализацию, которая не является переменной или определением члена, принадлежат к категории prvalue. Точно такое же поведение и у типов, которые не являются тривиальными.
9) Аргументы, передаваемые функциям, в том числе и конструкторы, которые подвергаются неявным преобразованиям, принадлежат к категории prvalue. Такое поведение легко наблюдать у типа std::string и у различных интеллектуальных указателей.

Выражения, принадлежащие к категории lvalue:

1) В отличие от других литералов строковые литералы принадлежат к категории lvalue. Это повелось ещё в C, где строковые литералы являются массивами, а массивы в C могут быть представлены только выражениями, принадлежащими к категории lvalue.
2) Вызов функции принадлежат к категории lvalue, если эта функция возвращает ссылку на объект, при этом сама эта ссылка может быть как ссылкой на константный объект, так и ссылкой на неконстантный объект.
3) Префиксная операция всегда возвращает ссылку на объект, который принадлежат к категории lvalue.
4) И хотя операция записи во входной поток может оперировать значением 42 (cout 0

2. Договоренности о лексике

Название 2. Договоренности о лексике
страница 4/10
Тип Обзор

rykovodstvo.ru > Руководство эксплуатация > Обзор

5. Объекты и LVALUE(адреса)

6. Преобразования

6.1 Символы и целые

Символ или короткое целое могут использоваться, если может использоваться целое. Во всех случаях значение преобразуется к целому. Преобразование короткого целого к длинному всегда включает в себя знаковое расширение; целые являются величинами со знаком. Содержат символы знаковый разряд или нет, является машинно-зависимым; см. #2.6. Более явный тип unsigned char ограничивает изменение значения от 0 до машинно-зависимого максимума.

В машинах, где символы рассматриваются как имеющие знак (знаковые), символы множества кода ASCII являются положительными. Однако, символьная константа, заданная восьмеричной esc- последовательностью подвергается знаковому расширению и может стать отрицательным числом; так например, ‘\377’ имеет значение -1.

Когда длинное целое преобразуется в короткое или в char, оно урезается влево; избыточные биты просто теряются.

6.2 Float и doublе

6.3 Плавающие и целые

Преобразования плавающих значений в интегральный тип имеет склонность быть машинно-зависимым. В частности, направление усечения отрицательных чисел различается от машины к машине. Если предоставляемого пространства для значения не хватает, то результат не определен.

Преобразование интегрального значения в плавающий тип выполняются хорошо. При нехватке в аппаратной реализации требуемых бит возникает некоторая потеря точности.

6.4 Указатели и целые

Выражение целого типа можно прибавить к указателю или вычесть из него; в таком случае первый преобразуется, как указывается при обсуждении операции сложения.

Можно производить вычитание над двумя указателями на объекты одного типа; в этом случае результат преобразуется к типу int или long в зависимости от машины; см. #7.4.

6.5 Unsigned

Всегда при сочетании целого без знака и обычного целого обычное целое преобразуется к типу unsigned и результат имеет тип unsigned. Значением является наименьшее целое без знака, равное целому со знаком (mod 2**(размер слова)) (т.е. по модулю 2**(размер слова)). В дополнительном двоичном представлении это преобразование является пустым, и никаких реальных изменений в двоичном представлении не происходит.

При преобразовании целого без знака в длинное значение результата численно совпадает со значением целого без знака. Таким образом, преобразование сводится к дополнению нулями слева.

6.6 Арифметические преобразования

Большое количество операций вызывают преобразования и дают тип результата одинаковым образом. Этот стереотип будет называться «обычным арифметическим преобразованием».

Во-первых, любые операнды типа char, unsigned char или short преобразуются к типу int.

Далее, если один из операндов имеет тип double, то другой преобразуется к типу double и тот же тип имеет результат.

Иначе, если один из операндов имеет тип unsigned long, то другой преобразуется к типу unsigned long и таков же тип результата.

Иначе, если один из операндов имеет тип long, то другой преобразуется к типу long и таков же тип результата.

Иначе, если один из операндов имеет тип unsigned, то другой преобразуется к типу unsigned и таков же тип результата.

Иначе оба операнда должны иметь тип int и таков же тип результата.

6.7 Преобразования указателей

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

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

Указатель любого типа может преобразовываться в void*.

Указатель на класс может преобразовываться в указатель на открытый базовый класс этого класса; см. #8.5.3.

Имя вектора может преобразовываться в указатель на его первый элемент.

Идентификатор, описанный как «функция, возвращающая . «, всегда, когда он не используется в позиции имени функции в вызове, преобразуется в «указатель на функцию, возвращающую . «.

6.8 Преобразования ссылок

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

Что представляет собой адрес ссылки lvalue на prvalue?

Когда параметр функции имеет тип lvalue ссылка lref :

а также lref связан с prvalue:

что представляет собой адрес? Что там живет?

Prvalue не может иметь свой адрес. Но ссылка lvalue в prvalue Можно его адрес взят, что мне любопытно.

Решение

Короче говоря, потому что срок службы prvalue был продлен. Если время его жизни увеличено — по любой ссылке — это lvalue, и, следовательно, можно получить его адрес.

что представляет собой адрес? Что там живет?

Адрес представляет объект, объект, на который ссылается lref ,

Prvalue недолгим, он не живет долго. Фактически, он будет уничтожен, когда оператор, создающий его, закончится.

Но когда вы создаете ссылку на prvalue (либо ссылку на rvalue, либо ссылку на const lvalue), время ее жизни увеличивается. Ref .: :

Rvalue может быть использован для инициализации const lvalue [Rvalue] ссылка, в этом случае время жизни объекта, идентифицируемого Rvalue является продлен до конца области ссылки.

Теперь имеет смысл взять его адрес, так как это значение для всех намерений и целей. Теперь, когда prvalue имеет неопределенное время жизни, это lvalue.

Однако брать адрес prvalue не имеет смысла, и, вероятно, поэтому он запрещен:

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

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

Таким образом, получение адреса prvalue приведет к тому, что компилятор не сможет полностью исключить значение без каких-либо преимуществ (см. Пункт 1).

Другие решения

Внутри функции lref это не prvalue, это lvalue, и вы можете взять его адрес.

Существует распространенное заблуждение о rvalues ​​против lvalues.
Именованный параметр всегда является lvalue. Независимо от того, является ли это ссылочным типом, связанным с rvalue. Через const & ссылочный тип, вы даже не можете сказать, какую категорию значений имеет объект на самом деле в точке, где вызывается функция. Ссылки Rvalue и неконстантные ссылки Lvalue дают вам эту информацию:

Временная строка является prvalue в контексте вызывающей стороны (в точке PrintAddress называется). В контексте вызываемого абонента (в PrintAddress ) lref является ссылкой на lvalue, потому что в этом контексте это фактически lvalue.

PrintAddress не знает об ограниченном времени жизни переданного аргумента и от PrintAddress С точки зрения объекта «всегда» там.

где временный испытывает продление его жизни до конца области, в которой lref определяется (что до конца PrintAddress область действия функции в настоящем примере).

что представляет собой адрес? Что там живет?

std::string объект, содержащий переданный контент.

И является ли законным (в C ++ и в отношении памяти) запись по этому адресу?

Нет, было бы законно, если бы вы использовали ссылку rvalue:

То же самое относится и здесь: rref это lvalue (у него есть имя), так что вы можете взять его адрес и он изменчив.

На простом английском:

Любой объект, имеющий имя, является lvalue следовательно, любое использование lref в рамках вышеуказанной функции lvalue использовать.

Когда вы вызвали функцию с помощью:

Конечно, lref.substr() производит временный, который является rvalue , но rvalues может связываться с (время его продления увеличивается) ссылками const lvalue или ссылками rvalue.

Даже если вы предоставили rvalue перегрузки, за то, что у него есть имя, это «ценность чего-то» в рамках своей области, пример:

В C ++ любой объект (будь то тип ценности, тип ссылки или же тип указателя) который имеет название является именующий

Также знаю, что некоторые выражения производить lvalues тоже.

indbooks

Читать онлайн книгу

2.1.2 Объекты и Адреса (Lvalue)

Можно назначать и использовать переменные, не имеющие имен, и можно осуществлять присваивание выражениям странного вида (например, *p[a+10]=7). Следовательно, есть потребность в имени «нечто в памяти». Вот соответствующая цитата из справочного руководства по С++: «Объект есть область памяти.

lvalue есть выражение, ссылающееся на объект» (#с.5). Слово «lvalue» первоначально было придумано для значения «нечто, что может стоять в левой части присваивания». Однако не всякое lvalue можно использовать в левой части присваивания; бывают lvalue, ссылающиеся на константу (см. #2.4).

Углубляемся в C++: move семантика и rvalue

В этой статье разобраны основные преимущества и нюансы move семантики в C++11 и старше. Всё описанное в этой статье было проверено на компиляторе Clang 6.0.1 с библиотекой libc++ на x86, GNU/Linux.

Введение в move

Move семантика позволяет переместить объект вместо его копирования для увеличения производительности. Проще всего понять семантику перемещения на примере. В качестве этого примера будет использоваться класс String :

При передаче объекта этого класса в функцию, принимающую его по значению, — назовём её by_value() — произойдёт следующее:

Получается 4 обращения к аллокатору, что достаточно накладно. Но если объект String больше не понадобится, а функцию by_value() менять нельзя, то можно переместить объект, а не копировать. Для этого необходимо написать конструктор перемещения для класса String :

Параметр конструктора перемещения other , во-первых, неконстантный, т.к. конструктор его изменяет; во-вторых, является rvalue -ссылкой ( && ), а не lvalue -ссылкой ( & ). Об их отличиях будет сказано далее. Сам конструктор переносит Си-строку с other на this , делая other пустым.

Конструктор перемещения в общем случае не медленнее, а зачастую даже быстрее конструктора копирования, но ничего не мешает программисту поместить sleep(10’000) в конструктор перемещения.

Для вызова конструктора перемещения вместо конструктора копирования можно использовать std::move() . Теперь пример выглядит следующим образом:

Количество обращений к аллокатору уменьшилось вдвое!

rvalue и lvalue

Основное отличие rvalue от lvalue в том, что объекты rvalue могут быть перемещены, тогда как объекты lvalue всегда копируются.

Это «могут быть» лучше всего демонстрируют следующие два примера:

Этот код работает не так, как от него ожидается. std::move() всё ещё конвертирует lvalue в rvalue , но конвертация сохраняет все модификаторы, в том числе и const . Затем компилятор выбирает среди двух конструкторов класса String самый подходящий. Из-за того что компилятор не может отправить const rlvaue туда, где ожидается non-const rvalue , он выбирает конструктор копирования, и const rvalue конвертируется обратно в const lvalue . Вывод: следите за модификаторами объектов, т.к. они учитываются при выборе одной из перегрузок функции.

Второй пример демонстрирует правило: аргументы и результат функции могут быть как rvalue , так и lvalue , но параметры функций могут быть только lvalue . Аргумент — это то, что передаётся в функцию. Он инициализирует параметр, который доступен непосредственно внутри функции.

Хотя параметр string функции f() и имеет тип rvalue -ссылки, он является lvalue и требует явной конвертации в rvalue перед передачей в функцию g() . Этим и занимается std::move() .

Универсальные ссылки

Универсальные ссылки могут быть как rvalue -, так и lvalue -ссылкой в зависимости от аргументов или результата функции. Используются в шаблонах и в auto&& :

Компилятор на основе этого шаблона генерирует 2 функции, одна из которых принимает lvalue , другая — rvalue , если они будут использоваться. Если программист хочет использовать перемещение для rvalue -ссылки и простое копирование для lvalue -ссылки, то он может использовать std::forward() , который приводит свой аргумент к rvalue только тогда, когда его тип является rvalue -ссылкой. std::forward() требует явного указания шаблонного параметра даже с автоматическим выводом шаблонов в С++17.

Универсальная ссылка обязана быть шаблонным параметром (отсюда такое странное определение шаблона функции в примере) в формате T&& . Например, std::vector && уже не универсальная, а rvalue -ссылка.

Свёртывание ссылок

На самом деле разницы между rvalue -ссылкой и универсальной ссылкой нет. Универсальная ссылка — лишь удобная абстракция над rvalue -ссылкой, которой многие пользуются. Но как тогда rvalue -ссылка превращается в lvalue -ссылку при lvalue аргументе? Всё дело в свёртывании ссылок.

При вызове template_func(string) компилятор генерирует следующий заголовок функции:

И получается ссылка на ссылку! Вручную так сделать нельзя, но шаблоны могут. Далее компилятор свёртывает ссылку на ссылку. Свертывание производится по следующему правилу: результатом свертывания будет rvalue -ссылка только тогда, когда обе ссылки являются rvalue -ссылками.

Именно из-за этого безобразия проще использовать абстракцию универсальных ссылок.

Подробнее о move семантике и rvalue можно узнать из книги С. Мейерса «Эффективный и современный С++: 42 рекомендации по использованию С++ 11 и С++14» ISBN: 978-5-8459-2000-3.

Copy/move elision

Copy/move elision — это оптимизация, при которой компилятор может убрать некоторые вызовы конструктора копирования и деструктора, но в данный момент только при возврате объекта из функции, и только если тип возвращаемого объекта полностью совпадает с типом функции.

Поэтому при возврате из функции использование std::move() может снизить производительность, ограничив компилятор в Copy elision оптимизации, ведь отсутствие конструктора быстрее, чем конструктор перемещения.

Здесь std::move() только замедляет код, добавляя лишний вызов String(String&& other) и

В C++20 copy/move elision может быть расширен, благодаря чему в некоторых случаях использование std::move() также снизит производительность. Подробнее о расширении copy/move elision можно узнать из видеозаписи со встречи рабочей группы по стандартизации С++ в московском офисе Яндекса.

Илон Маск рекомендует:  Больше не таблица
Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL