Чтоб не сглазили как пишется

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

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

Зачем это пригодилось нам

Всё началось с того, что команда PVS-Studio начала активно дорабатывать ядро С++ анализатора. Одна из больших задач – внедрение новой системы типов. Сейчас она состоит из специально закодированных строчек, мы же хотим заменить её на иерархическую систему. Подробно на новой системе типов я останавливаться не буду. В общих чертах мы пытаемся сделать из этого:

это:

Подробно и со смешными картинками о нашей новой и старой системе типов не так давно рассказывал мой коллега Юрий на конференции itCppCon21. Сейчас, как мне кажется, у него набралось материала на два или три новых доклада. Будем с нетерпением их ждать

У новой системы типов есть аналоги type_traits, они так же, как и их прародители, помогают модифицировать тип или получить о нём нужную информацию.

Недавно я писал реализацию std::common_type для нашей системы типов. Этот трейт часто применяется в метапрограммировании, когда требуется вывести общий тип для произвольного числа переданных типов. Нам же подобный трейт оказался удобен для вывода результирующего типа, например, когда мы обходим бинарное выражение и встречаем арифметическую операцию:

if (operationInfo->m_type == OperatorType::Arithmetic)
{
  auto leftType  = TypeTraits::ExtractMemberType
                   (result->GetLeftOperand().GetType());
  auto rightType = TypeTraits::ExtractMemberType
                   (result->GetRightOperand().GetType());
  auto resType = Types::Traits::CommonType(leftType, rightType);
  ....
}

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

Зачем он вообще нужен C++ разработчикам

Допустим, что мы хотим написать наивную реализацию шаблона функции для скалярного произведения двух векторов, причем векторы могут быть инстанцированы различными типами. Требуется, чтобы тип скалярного произведения выводился автоматически. Такой шаблон функции начиная с C++14 можно реализовать как-то так:

#include <vector>

template <typename T, typename U>
auto dot_product(const std::vector<T> &a, const std::vector<U> &b)
{
  // some bounds checks

  ??? result {};

  auto a_it = a.begin();
  auto b_it = b.begin();

  while (a_it != a.end())
  {
    result += static_cast<???>(*a_it++) * static_cast<???>(*b_it++);
  }

  return result;
}

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

Итак, функция делает именно то, что мы и хотели. Компилятор сам выводит результирующий тип из return statement за нас. Осталась одна проблема – для переменной result нужно как-то вывести общий тип.

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

Conditional operator

Как мне кажется, приводить описание работы тернарного оператора из стандарта будет лишним, так как оно довольно большое. Поэтому вкратце рассмотрим, как происходит вывод типа в основных случаях.

Для наглядности будем визуализировать результаты с помощью двух вещей:

• вариативный шаблон класса tp без определения, который позволит узнать имя результирующего типа при помощи ошибки компиляции;
• Clang AST: покажет абстрактное синтаксическое дерево программы.

Перейдём к случаям:

Случай 1

Если и второй, и третий операнд имеют тип void, то результат также имеет тип void. Такое возможно, например, если оба выражения содержат throw, либо вызовы функций, возвращающих void, либо явное преобразование к типу void. Пример кода с выводами сообщений компиляторов:

void foo();
void bar();

int foobar();
float barfoo();

template <typename ...>
struct tp;              // type printer

void examples(bool flag)
{
  tp<decltype(flag ? foo() : bar()),                     // void
     decltype(flag ? (void) foobar() : (void) barfoo()), // void
     decltype(flag ? throw 0 : throw 3.14)> _;           // void
}

Если второй или третий операнд – выражение throw, то результирующий тип выводится из другого. Другой операнд при этом не должен быть типа void. Пример кода с выводами сообщений компиляторов:

char arr[16];

template <typename ...>
struct tp;              // type printer

void examples(bool flag)
{
  tp<decltype(flag ? nullptr : throw "abs"), // nullptr_t
     decltype(flag ? 3.14 : throw 3.14),     // double
     decltype(flag ? arr : throw 3.14)> _;   // char (&)[16]
}

Случай 2

Если второй и третий операнд имеют разные типы, и при этом один из них классового типа, то выбирается такая перегрузка, которая сформирует операнды одинаковых типов. Например, может быть выбран конвертирующий конструктор или оператор неявного преобразования. Пример кода c выводами сообщений компиляторов:

template <typename ...>
struct tp;              // type printer

struct IntWrapper
{
  IntWrapper(int) 
  {
    // ....
  }
};

void examples(bool flag)
{
  tp<decltype(flag ? IntWrapper {42} : 42)> _;
}

Если посмотреть Clang AST этого кода, то можно заметить:

....

-FunctionDecl <line:9:1, line:12:1> line:9:6 foo 'IntWrapper (bool)'
 |-ParmVarDecl <col:10, col:15> col:15 used b 'bool'
 `-CompoundStmt <line:10:1, line:12:1>
   `-ReturnStmt <line:11:3, col:34>
     `-ConditionalOperator <col:10, col:34> 'IntWrapper'
       |-ImplicitCastExpr <col:10> 'bool' <LValueToRValue>
       | `-DeclRefExpr <col:10> 'bool' lvalue ParmVar 0x558edcfc99d8 'b' 'bool'
       |-CXXTemporaryObjectExpr <col:14, col:30> 'IntWrapper' 'void (int)' list
       | `-IntegerLiteral <col:27> 'int' 42
       `-ImplicitCastExpr <col:34> 'IntWrapper' <ConstructorConversion>   // <=
         `-CXXConstructExpr <col:34> 'IntWrapper' 'void (int)'
          `-IntegerLiteral <col:34> 'int' 42                              // <=

Здесь Clang неявно вызвал конвертирующий конструктор для третьего операнда, отчего оба операнда стали типа IntWrapper.

Случай 3

Над вторым и третьим операндом применяются standard conversions: lvalue-to-rvalue, array-to-pointer и function-to-pointer. После этих конверсий возможны несколько ситуаций:

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

template <typename ...>
struct tp;              // type printer

struct MyClass
{
  // ....
};

void examples(bool flag)
{
  tp<decltype(flag ? MyClass {} : MyClass {})> _;
}

Также второй и третий операнды могут иметь арифметический тип или тип перечисления. Для арифметических типов и перечислений будут применяться usual arithmetic conversions для формирования общего типа, который и будет результирующим. Пример кода c выводами сообщений компиляторов:

template <typename ...>
struct tp;              // type printer

void examples(bool flag)
{
  char ch                = 1;
  short sh               = 2;
  double d               = 3;
  float f                = 4;
  unsigned long long ull = 5;
  long double ld         = 6;

  tp<decltype(flag ? ch :  sh),
     decltype(flag ? f :  d),
     decltype(flag ? ull : ld) > _;
}

Также один или оба операнда могут иметь тип указателя или указателя на член класса. Тогда применяются правила pointer conversions/pointer-to-member conversions, function pointer conversions и qualification conversions для формирования композитного типа указателя, который и будет результирующим. Пример кода c выводами сообщений компиляторов:

template <typename ...>
struct tp;              // type printer

struct MyBaseClass
{
  // ....
};

struct MyClass : MyBaseClass
{
  // ....
};

void examples(bool flag)
{
  auto a = new MyClass();
  auto b = new MyBaseClass();
  tp<decltype(flag ? a : b)> _;
}

Также оба операнда могут иметь тип std::nullptr_t, либо один из них std::nullptr_t, а другой – константа нулевого указателя. Тогда результирующий тип – std::nullptr_t. Пример кода c выводами сообщений компиляторов:

#include <cstddef>

template <typename ...>
struct tp;              // type printer

void examples(bool flag)
{ 
  tp<decltype(flag ? std::nullptr_t {} : nullptr )> _;
}

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

P.S.: Для того, чтобы написать нужный нам аналог std::common_type для новой системы типов (TypeTraits::CommonType), нам пришлось реализовать все вышеописанные и некоторые нерассмотренные правила вывода общего типа.

Пишем свой common_type

Вернёмся к нашей функции скалярного произведения векторов. Начиная с C++11 в нашем распоряжении есть спецификатор decltype, который возвращает тип переданного в него выражения. Мы уже использовали его выше для работы с type_printer. Из прошлого абзаца мы знаем, что если протолкнуть в него вызов тернарного оператора с объектами двух наших типов, то компилятор сделает за нас вывод общего типа.

Попробуем применить сказанное в действии:

#include <vector>

template <typename T, typename U>
auto dot_product(const std::vector<T> &a, const std::vector<U> &b)
{
  // ....
  decltype(true ? std::declval<T>() : std::declval<U>()) result {};
  // ....
}

Давайте подробно разберем, что делает этот код:

1. При помощи спецификатора decltype мы возвращаем тип выражения в скобках.
2. Внутри decltype применяем тернарный оператор. Первым операндом можно сделать любое выражение, например true.
3. Во второй и третий операнды располагаем переданные шаблонные типы. Только есть одна проблема – тернарный оператор оперирует выражениями. Поэтому «создадим» объекты через std::declval.

std::declval<T> – это шаблон функции без реализации, который возвращает rvalue-ссылку на тип T. При типе T = void возвращает тип void. Этот шаблон чаще всего применяется внутри невычисляемого контекста (decltype, sizeof, requires,….) и позволяет как бы работать с объектом переданного типа, обходя вызов конструктора. Это особенно полезно, если тип T не имеет публичного конструктора по умолчанию либо он удален.

Не забываем, что нам также могут передать ссылки в качестве типа, поэтому стоит применить std::decay. Он уберет CV-квалификаторы, ссылки, добавит указатели функциям (function-to-pointer conversion) и преобразует массивы в указатели (array-to-pointer conversion):

#include <vector>

template <typename T, typename U>
auto dot_product(const std::vector<T> &a, const std::vector<U> &b)
{
  // ....
  std::decay_t<
        decltype( true ? std::declval<typename std::decay<T>::type>()
                       : std::declval<typename std::decay<U>::type>()
        )
  > result {};
  // ....
}

Согласитесь – писать такое в коде совсем не хочется. Попробуем немного причесать код, для этого нам надо написать пару вспомогательных шаблонов классов для удобства. Во-первых, попробуем написать класс для вывода общего типа из двух переданных:

template <class T, class U>
struct common_type
{
  using type = std::decay_t<
      decltype( true ? std::declval< std::decay_t<T> >()
                     : std::declval< std::decay_t<U> >() ) >;
};

Теперь можем применить этот common_type в нашем коде:

#include <vector>

template <typename T, typename U>
auto dot_product(const std::vector<T> &a, const std::vector<U> &b)
{
  // ....
  common_type<T, U>::type result {};
  // ....
}

Отлично, мы избавились от всей этой страшной портянки, код стал лаконичным. Но хочется теперь сделать common_type таким, чтобы он умел работать с любым числом переданных типов – от нуля до произвольного. Тогда немного поменяем наш основной шаблон класса и его специализации:

#include <type_traits>

template <typename ...>
struct common_type; // (1)

template <typename ...Ts>
using common_type_t = typename common_type<Ts...>::type;

template <>
struct common_type<> // (2)
{
};

template <class T>
struct common_type<T> // (3)
{
  using type = std::decay_t<T>;
};

template <class T, class U>
struct common_type<T, U>         // (4)
{
  using type = std::decay_t<
      decltype( true ? std::declval< std::decay_t<T> >()
                     : std::declval< std::decay_t<U> >() ) >;
};

template <class T, class U, class... V>
struct common_type<T, U, V...>         // (5)
{
  using type =  typename common_type
               <typename common_type<T,U>::type, V...>::type;
};

Стоит отметить, что примерно так common_type и реализован в стандартной библиотеке. Теперь, давайте подробно разберём, что тут происходит:

1. Объявляется основной вариативный шаблон класса.
2. Для пустого списка шаблонных аргументов сделаем явную специализацию шаблона, которая ничего не содержит.
3. Для одного шаблонного аргумента сделаем частичную специализацию, внутри которой будет лежать этот же тип после std::decay, который уберёт CV-квалификаторы, ссылки, добавит указатели функциям (function-to-pointer conversion) и преобразует массивы в указатели (array-to-pointer conversion).
4. Для двух шаблонных аргументов сделаем частичную специализацию, которая выведет результирующий тип на основе правила вывода общего типа тернарного оператора, применив перед этим std::decay на переданные аргументы.
5. Для трех и более шаблонных аргументов сделаем частичную специализацию, которая сначала посчитает общий тип для первых двух аргументов при помощи специализации для 2 аргументов. Затем она рекурсивно инстанцирует себя, передав в качестве шаблонных аргументов общий тип для первой пары типов и оставшийся пакет шаблонных параметров. По сути, common_type<a, b, c, d> эквивалентно common_type<common_type<common_type<a, b>, c>, d>. Пример на C++ Insights.

Как я уже говорил выше, более подробно, с правилами вывода типа для самого тернарного оператора можно ознакомиться в стандарте. Я использовал последний актуальный рабочий черновик, там их можно найти в главе 7.6.16. Сами черновики можно посмотреть, например, здесь. Также можно воспользоваться документацией на cppreference.

Заключение

Мы посмотрели, как работает std::common_type и, чтоб более подробно в нём разобраться, написали его реализацию, почитав стандарт, и даже немного затронули логику работы тернарного оператора. Надеюсь, эта статья оказалась полезна. Всем спасибо за внимание!

Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Vladislav Stolyarov, Phillip Khandeliants. An article for those who, like me, do not understand the purpose of std::common_type.

10



0

Разобраться в правописании данного нам слова довольно просто;

Буква «с» являются частью слова- от слова «сглаз»;

В русском языке не существую слово «глазить», поэтому с не может являтся предлогом и писаться раздельно;

Следовательно правильный вариант-«сглазить»­<wbr />,слитно.

5



0

Чтобы ответить на данный вопрос, разберемся с ситуацией.

(С)глазить — что сделать?, слово о правописании которого задан вопрос, отвечает на глагольный вопрос и обозначает действие, поэтому является глаголом.

Теперь воспользуемся методом доказательства «от противного». Предположим, что с пишется с глаголом глазить отдельно ( хотя очевидно, что такого глагола в современном русском языке не существует ). В этом случае слово с должно являться предлогом, а мы знаем, что перед глаголами предлоги не употребляются.

Значит, наше предположение изначально неверно, с и глазить пишется слитно ( в одно слово ): сглазить.

3



0

Слово «с*глазить» связано с суевериями и означает, что можно нанести кому-то вред плохим (дурным) взглядом, от которого человек может заболеть или у него начнется череда несчастий.

Слово является глаголом, который образован от слова «сглаз». А слово «сглаз» сложилось из приставки «с», присоединенной к корню «глаз». Получается, что в глаголе «сглазить» тоже имеется приставка «с». Поскольку слова «глазить», которое можно было бы употреблять с предлогом «с», не существует, то написание слова «сглазить» может быть только слитное, а «с» в нем — приставка.

Пример:

Сглазить — это по сути означает, что кто-то через глаза повлиял на человека отрицательной энергетикой.

2



0

2



0

2



0

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

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

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

1



0

1



0

Глагол сглазить пишется слитно.

А слова «глазить» в русском языке просто не существует- поэтому остаётся только один вариант-

писать глагол именно так — сглазить.

И никак иначе его по правилам современного русского языка нельзя писать.

1



0

1



0

Сглазить — это слово отвечает на вопрос что сделать? И является глаголом, который образован от существительного «сглаз». В суеверных представлениях сглаз означает нанести кому-то вред завистливым взглядом, похвалами.

Буква С является частью слова и не может быть предлогом и писаться отдельно. Так же в нормативном русском языке нет глагола «глазить», поэтому правильное написание этого слова слитно.

0



0

Сглазит)

я не знаю что еще написать надо просто 40 слов)

Разница между этими двумя словами и написаниями в том, что:

Можно за раз увидеть сто зараз. Можно и зараз увидеть за сто раз. Но в этих предложениях мы видим не только зараз, но и следующее:

«За раз» — раздельное написание подсказывает нам о том, что сказано «за один раз». Это и имеется в виду. Вставка слова «один» является вовсе не искусственной. Она как бы дополняет сокращённое высказывание до полного.

«Зараз» — это одна из грамматических форм имени существительного «зараза»: «множество зараз», «нет этих зараз» и так далее. Пишется слитно.

_

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

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

Если есть противопоставление с союзом «а» (пример: «Этот человек не бедный, а богатый»), то «не» пишется раздельно.

Если имеются отрицательные частицы или местоимения, такие как «ничем, никак, нисколько, вовсе не и др., то частица «не» тоже пишется раздельно (пример: «Этот человек вовсе не бедный»).

Прилагательное «небедный» пишется слитно в случае, если к нему можно подобрать синоним. Так, синонимом к слову «небедный» является слово «богатый», значит, «не» пишем слитно.

Если прилагательное употребляется в контексте присоединения, то при отсутствии противопоставления в предложении тоже пишется слитно. (Пример:»Этот человек небогатый и добрый.»).

Начнём с того, что прилагательное «любопытный» имеет 2 значения:

• Отличающийся любопытством.
• Интересный, вызывающий любопытство.

Если к слову «любопытный» добавить приставку НЕ, то образуется слово с противоположным значением, которое пишется слитно: нелюбопытный.

К нему можно подобрать синоним без НЕ:

нелюбопытный — равнодушный (в 1 знач.)

нелюбопытный — малоинтересный, банальный(во 2 знач.)

Примеры предложений:

• Когда квартиру профессора обокрали, он впервые пожалел о том, что его соседка была нелюбопытной особой.
• Едва пробежав глазами первую страницу книги, оставленной кем-то в номере, Михаил тут же отбросил в сторону это нелюбопытное чтиво.

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

Пример:

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

Сначала определим, к какому разряду относится прилагательное фабричный.

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

В русском языке относительные имена прилагательные с частицей НЕ пишутся раздельно.

Примеры:

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