Wataru

Это и есть нормальное преобразование float в int - с округлением вниз.

Edit: Видимо, проблема в том, что 0.9 нельзя идеально точно представить в float. На самом деле там хранится что-то вроде 0.8999999.... При домножении на 10 и округлении вниз вы получите 8, а не 9.

Надо использовать округление к ближайшему - round.

Используйте std::vector. Он автоматически расширяется и при этом работает быстро.

Тут проблема не в том, что член класса char*, а в том, что запись идет в char*, и из-за strict aliasing правил - это может быть запись куда угодно, в том числе в &this. Кешировать пришлось бы любой член структуры, любого типа.

Эту же проблему можно воспроизвести в меньшем масштабе, если у вас в цикле есть запись в int* и чтение какой-то другой не меняющейся int переменной. Особенно, когда переменная в куче и указатель пришел в параметре функции. Вот компилятор офигеет и будет на каждой итерации ее загружать в регистр заново. Опять же, потому что ну не может он понять, что вот этот вот указатель не указывает на вот эту вот переменную.

Частично это можно решить кешированием, можно попробовать поменять типы кое где. Но делать это не стоит - это та самая преждевременная оптимизация, о которой писал Кнут. Лучше алгоритм хороший и структуры данных правильные в вашей программе выберите. А уже дальше, если профилирование покажет, что вот тут вот узкое место, то можно смотреть на ассемблерный код и думать, как убедить компилятор геренировать что-то более быстрое.

Если это С++ и вы используете std::string, то можно строки тупо суммировать через +=.

Если по условию задания вам надо делать все руками, то нужно выделить память, чтобы все поместилось, а дальше можно воспользоваться strcat_s, memcpy или вообще посимвольно копировать.

Ну посмотрите в документацию же.

Там английским по белому написано:

The number of characters successfully read and stored by this function can be accessed by calling member gcount.

И даже пример внизу есть.

is_subsequence написана с ошибкой. Что у вас там за алгоритм? Почему вы считатете, что оно должно работать?

Оно, например, не работает на тесте s="abc" t="zzzzzcba". Ваша реализация скажет, что abc является подпоследовательностью, хотя на самом деле - нет.

Еще хочется отдельно привлечь внимание к гениальности кода:

if (is_sub)
        return true;
    else
        return false;

Он кажется мне немного перемудренным.

Это нормальная практика. Например, ваш браузер скорее всего именно таким инструментом пользуется (если он на хромиуме основан).

Используйте vector<vector<vector<int>>>> - каждая строка/столбец могут быть любого нужного вам размера.

Еще можно хранить ваши массивы как указатели в одном массиве указателей. Ведь эти сишные массивы - это по сути и есть указатели на начало. Вот только в таком виде вам придется как-то где-то помнить их размеры и вручную высчитывать индексацию в виде a[i*6+j], b[i*7+j].

Вы делите два int-а, там где формулу считаете. В языке C++ в этом случае происходит деление нацело. Поскольку числитель меньше знаменателя - всегда получается 0. Или static_cast-ом приводите к double, или тип где-то на double поменяйте (функции или переменной). Или, на худой конец, прибавляйте 0.0 к числителю или знаменателю.

Операторы должны возвращать bool и принимать константные ссылки на структуры.

Но вообще-то раз вы итерируетесь по списку, вы сравниваете итраторы, а не структры. Поэтому достаточно просто использовать страндартную конструкцию:

for (auto it = requests->begin(); it != requests->end(); ++it)

И не надо ничего переопределять. Вы перепутали end и back. Первый возвращает итератор, а второй - элемент.

Проблема в том, что итераторы unordered_set - имеют тип ForwardIterator. Варианты set_intersection, которые ждут вот такой вот итератор для результата, еще хотят и ExecutionPolicy.

Но даже если вы поменяете тип у intersect, чтобы туда можно было вставлять ответ, ваш код не сработает, потому что set_intersection ждет упорядоченные интервалы. Вас unordered в названии контейнеров не смущает?

Используйте getline.

Перебирайте a и b. Потом смотрите, какие значения может принимать c, чтобы ограничения выполнялись. Это будет отрезок чисел. Их не надо перебирать - можно их сразу все подсчитать. Например, если вы видите, что c<=10 удовлетворяет ограничения, то троек с текущими a, b - десять штук.

Ну вот так прнято в С++. Оператор префиксного инкремента (++i) имеет такую сигнатуру - он возвращает ссылку на измененный объект. Если выхотите чтобы у вашего класса Date можно было сделать ++date, то надо переопределить вот такой вот оператор. Это позволяет писать более читаемый и короткий код. Вместо date.IncremeantAndReturn() можно использовать идиоматичное ++date, или даже что-то вроде while (++date < deadline). Это не обязательно делать, но иногда это весьма удобно и полезно.

Оператор должен возвращать измененное значение, поэтому и возвращается *this после его увеличения;

В этом коде Сopy не используется. Оно тут не нужно вообще. копия понадобится для постфиксного инкримента (i++), который должен возвращать неизмененный объект.

Передача *this в конструктор Copy - это для вызова конструктора копирования, чтобы, внезапно, создать копию текущего объекта. Подумайте, как вам скопировать текущий объект? Надо новому объекту присвоить текущий, или в конструктор передать ему текущий объект. Но как передать текущий объект? У вас есть указатель на него this. Разыменовав этот указатель (*this) вы как раз можете передать текущий объект куда надо.

Чтобы скопировать массив можно воспользоваться memcpy, или делать это циклом.

Массив указателей от массива значений не отличается ничем. Просто там значения - это указатели. Аккуратно не допустите ошибки при использовании sizeof - если ему передать сам массив (указатель), то это будет размер указателя, а не всего массива. Надо брать размер одного элемента и домножать на их количество.

Если изначальный объект можно удалить, то вам надо переопределить оператор перемещения, а не копирования. Внутри ваши массивы - это просто указатели и их можно перемещать как переменные:

keys_ = node.keys_;
node.keys_ = nullptr;

Не забудьте изначальное место затереть нулевым указателем, чтобы нечайнно потом два раза не удалить.

Так делать при копировании нельзя - ибо вы создаете несколько указателей на один и тот же массив и вообще непонятно, кто потом должен это удалять. Только при перемещении.

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

Выход за границу массива там где сортируете. Из этой левой памяти вы и получаете случайное значение.

Смотрите внимательно, к каким индексам вы обращаетесь и какое значение может принимать переменная j.

И еще, можно не сортировать итоговый массив, а формировать его уже отсортированным. Это работает сильно быстрее. Называется - процедура слияния.