Спасибо не надо как пишется

Всего найдено: 89004

Благодарю за оперативные ответы! В предложении «Его характеристика в лучшем случае — пародия» является ли «в лучшем случае» вводным словом и как тогда обосабливать — с одной или с двух сторон?

Ответ справочной службы русского языка

Это не вводные слова, обособление не требуется.

Добрый день! Подскажите, пожалуйста, как пишется словосочетание — голубое топливо. В кавычках или нет?

Ответ справочной службы русского языка

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

Стоит ли обособлять деепричастный оборот в предложении «Это случай из ряда вон выходящий» ? Может быть, это устойчивое сочетание, тогда запятая не нужна?

Ответ справочной службы русского языка

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

Добрый день! Подскажите пожалуйста, как правильно: «Просим Вас разместить объявление по бегущей строке на канале….», или «Просим Вас поместить объявление по бегущей строке на канале….»

Ответ справочной службы русского языка

Можно выбрать любой глагол — поместить и разместить. Но следует использовать другой предлог: в бегущей строке.

В предложении «Все это, по меньшей мере, наивно» «по меньшей мере» является ли вводным словом и тебует ли обособления?

Ответ справочной службы русского языка

Эти слова не вводные, они не требуют обособления.

Добрый день. Как правильно сказать: с шестью детьми или с шестерыми детьми.
Спасибо.

Ответ справочной службы русского языка

Корректно: с шестью детьми. Но в им. п.: шестеро детей и шесть детей.

Как правильно пишется: небеспорочен или — не беспорочен?

Ответ справочной службы русского языка

Возможно и слитное, и раздельное написание.

Разъясните пожалуйста как будет выглядеть глагол «писать» отвечая на вопрос «что делая?»

Ответ справочной службы русского языка

Образование деепричастия в этом случае затруднительно.

Добрый день.Скажите, когда пишешь условие задания, надо ли в конце задания ставить точку или не надо
Образец:Задание 4. Прочитайте текст, составьте вопросы, подготовьте пересказ.

Ответ справочной службы русского языка

Точка ставится.

Уважаемая справка, скажите пожалуйста, является ли грамотным словосочетания _положить слова на музыку_ и _класть слова на музыку_ ? Если нет, то какое словосочетание нужно использовать? Заранее спасибо!
Denghu

Ответ справочной службы русского языка

Сочетание корректное.

Здравствуйте,скажите,пожалуйста,проверочное слова слов «праздник» и «здравствуйте»,если таковые есть.спасибо

Ответ справочной службы русского языка

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

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

Ответ справочной службы русского языка

Словосочетания, состоящие из наречия и прилагательного, пишутся раздельно: гладко выбритый, мелко порезанный, остро наточенный. Исключение составляют слова-сращения, выступающие в качестве терминов (например, быстродействующий препарат – быстро действующий в экстремальных условиях человек). Отметим, что орфографический словарь допускает слитное написание гладковыбритый.

Добрый день!
В предложении «как педагог я считаю это большим достижением» нужно обособлять «как педагог»?

Ответ справочной службы русского языка

Если оборот содержит оттенок причинного значения (как педагог = потому что я педагог), то запятая ставится.

Подъем переворотом или подъем С переворотом. Спасибо.

Ответ справочной службы русского языка

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

Здравствуйте!

Очень интересует вопрос написания слово «запазуха» и почему оно отсутсвует в орфографическом словаре. Это слово присутствует в словаре Даля и, как мне помнится, в школе нам объясняли, что слово запазуха пишется именно вместе, а именно: «достать из запазухи», а не «достать из-за пазухи». Объяснялось слитное написание тем, что за время использования этого оборота оно превратилось в самостоятельное слово из-за редкого использования слова «пазуха» не в контексте оборота.

Надеюсь получить подробные пояснения.
Спасибо!

Ответ справочной службы русского языка

Орфографическая норма: за пазуху, за пазухой, из-за пазухи. Правописание следует проверять при помощи орфографических словарей. Словарь Даля  отражает орфографическую норму позапрошлого века.

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

1. Замените подозрительное слово на «раньше». В предложенном выше предложении можно сказать «Оля сказала спасибо Маше раньше приготовленного домашнего задания». Подходит по смыслу, значит пишем раздельно!
2. Попробуйте поменять местами предлог и наречие. В предложении «Олег попросил отгул за ранее отработанное время» смысл тот же, что в предложении «Олег попросил отгул ранее за отработанное время».

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

В начале я хотел бы сказать спасибо своему коллеге 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.