Wataru

Для преобразования из строки в число можно восспользоваться atoi().

Однако, если в строке фиксированное заранее известное количество чисел, то лучше воспользуйтесь sscanf(). Можно указать нужное вам количество %d через запятую примерно так:
sscanf(s, "%d, %d", &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.

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

Проблема вашего кода в том, что вы берете лишь первые 4 байта из 8 в double.

Копируете в uint64_t. Если надо меньше бит, то можно домножить на большое простое число и потом взять xor младших и старших бит.

Это задача - вариант Subset sum problem.

Она NP-полная - тут нет быстрых и простых решений. В общем случае, возможно только решение полным перебором за N*3^N. Что-то вроде того, что предложил Alexandroppolus, только там вообще не рассматривается случай, что текущее число просто пропускается. Еще можно делать это же без рекурсии на основе битовых масок.

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

а весом рёбер будет выступать расстояние между этими полями. для того чтобы после построения этого графа выбрать в нём 2 вершины и найти между ними кратчайший путь ... Двигаться по карте можно только по горизонтали и по вертикали.

Это какой-то бред. Начало фразы подразумевает, что ребра есть между всеми парами вершин, продолжение говорит, что все ребра длины 1 между соседними клетками. Я предполагаю что тут именно второй вариант.

Во-первых, занумеруйте все клетки. Подойдет простая формула вроде i+m*j

Вот у вас уже есть n*m вершин в графе. Теперь добавьте ребра. Для каждой клетки (два цикла) посмотрите 4 соседние клетки. Если обе клетки - ., то добавьте из текущей клетки ребро в соседнюю.

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

const int dx[4]= {1, 0, -1, 0};
const int dy[4]= {0, 1, 0, -1};

Тогда для клетки (i, j) можно перебрать всех соседей одним циклом на 4 итерации - (i+dx[k], j+dy[k]). Надо только не забыть проверить на выход за границы матрицы.

Ну и вам надо написать функцию типа AddEdge(int u, int v) которая будет в удобную для вас структуру данных добавлять ребра. Граф удобно хранить в виде списков смежности. На C++ это можно сделать просто std::vector<std::vector<int>> и добавлять соседей через vector::push_back. Это на практике работает быстрее всяких связных списков.

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

А можно вообще граф не строить. Берете ваш алгоритм поиска кратчайшего пути (BFS, Dijkstra или A*) и там везде, где перебираются соседи одной вершины, вставляете код проверки четырех направлений через dx/dy. Вершины можно или нумеровать их координатами, и тогда все массивы пометок будут двумерными, или можно использовать формулу u = i+j*m, (i,j) = (u%m, u/m) для преобразования координат в номер вершины и назад.

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

У вас в input_matrix выход за границы массива: в массиве n-1 элемент, а вы читаете n.

Массив лежит на стеке, там же где локальная переменная n. Так получилось, что n лежит сразу за matrix (или в пределах восьми байт) и оказывается испорчена. Данные кажутся вам случайными, потому что читаете вы double и какая-то его часть попадает в область памяти int n.

Смотрите внимательно - какие переменные вы выводите и как они меняются в коде. Нормальные названия кстати упростили бы вам поиск ошибки.