Wataru

coffeeMachine mix = device + machine;
вызывает перегрузку конструктора копирования, а не перегрузку оператор =, почему?

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

А если написать вот так:
coffeeMachine mix; mix = device + machine;
то ты сначала создаёшь экземпляр со значением по умолчанию, а потом вызываешь оператор =.

#include <random>
#include <iostream>

int main()
{
    auto n = 9;
    auto rnd = std::random_device{};
    auto gen = std::mt19937_64{rnd()};
    auto dis = std::uniform_real_distribution<double>{-0.1, 0.2};
    auto res = std::vector<double>{};
    std::generate_n(
        std::inserter(res, std::end(res)),
        n,
        [&](){ return dis(gen); }); 

    for (const auto& elem: res)
    {
        std::cout << elem << '\n';
    }
}

Это называется rvalue reference

Вот книга "Алгоритмы: построение и анализ"

Как происходит доступ к эл. массива на уровне ядра?

Так же как и на уровне приложения -- через трансляцию виртуального адреса в физический.

Например массив Int* arr = new int[1024*1024*1024] он как храниться?

Если мы для определённости возьмём linux, то у ядра есть несколько разных способов выделения памяти, в зависимости от того, для чего эта память выделяется. Есть наиболее простой и стандартный kmalloc который выделяет память непрерывную как виртуально так и физически. Обычно этим механизмом нельзя выделить большой непрерывный кусок. Есть vmalloc, который выделяет непрерывную виртуально, но возможно прерывную физически память. Есть get_free_pages который выделяет непрерывные страницы физической памяти, возможно, не отображаемые ни в какие виртуальные адреса. Есть Contiguous Memory Allocator который при старте системы резервирует кусок непрерывной физической памяти и может аллоцировать оттуда куски по запросу.
Важный момент состоит в том, что аллокации делаемые ядром linux через упомянутые интерфейсы всегда обеспечиваются физической памятью, у памяти ядра нет пейджинга.

А физическая, для массива то же? Ведь, так будет доступ намного быстрее?

Почему быстрее? С точки зрения процессора всё равно будет трансляция виртуального адреса в физический, если повезёт -- попадание в TLB, если не повезёт -- ходить по каталогам и таблицам страниц в памяти.

получается эмулятор каждый адрес вычислять что ли?

Простой эмулятор -- да, наверно. Умный эмулятор может кешировать эту информацию, например именно это свойство даёт QEMU большую часть его Q.

Раз Unit - интерфейс, то заведи метод OnPlace, но у базового класса Unit он просто будет пустым. Т.е. вызывай его всегда. А конкретный Unit реализует то, что ему надо.
Дженерик тут вообще не нужен. Просто внутри метода Unit проверяй, какой объект вызывал метод

class Solution:
  def rotate(self, matrix: List[List[int]]) -> None:
    length = len(matrix)
    for i in range(0, length // 2):
      for j in range(i, length - i - 1):
        matrix[i][j], \
        matrix[j][length - i - 1], \
        matrix[length - i - 1][length - j - 1], \
        matrix[length - j - 1][i] \
        = \
        matrix[length - j - 1][i], \
        matrix[i][j], \
        matrix[j][length - i - 1], \
        matrix[length - i - 1][length - j - 1]

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

Начиная с С99 (это такой стандарт Си от 1999 года) появились VLA (Variable Length Array). Синтаксис такой же как и у обычных массивов, но они могут иметь изменяемый размер, т.е. размер можно задавать обычной переменной.
Использование VLA влечет дополнительные расходы времени выполнения, поэтому многие принципиально не используют эту возможность (например ядро Linux). И это вполне оправданно еще и потому, что память под VLA массивы выделяется на стеке, пространство стека ограничено, а вы с дуру можете там выделить слишком большой массив, что вызовет переполнение стека.

Большинство компиляторов поддерживают VLA, но судя по ошибке, вы используете микрософтовский компилятор. Микрософт никогда не славилась поддержкой стандартов Си. VLA в ее компилятор не завезли до сих пор.

Потому, что массив "block" живет на стеке и компилятору надо знать его размер еще на этапе компиляции, чтобы правильно посчитать смещения. Если на этапе компиляции Вы не знаете сколько вам может потребоваться памяти, используйте malloc() для ее выделения в куче.

Первое. Тема топика Python + PowerShell. Тоесть непонятно тебе нужно программировать и развивать этот софт или решить задачу 1 раз и забыть. В зависимости от желания - будет разная реализация.

Второе. Есть коробочные утилиты fc (Windows) diff (Linux) которые такое сравнение делают. Но обычно для исходников и при условии что изменений мало. Почитай про них. Возможно это частично решит твою задачу.

Третье. Ты хочешь сравнивать одну строку со всеми из другого файла. Это декартово произведение. В данном случае тебе можно сортировать оба файла и тогда одинаковые значения будут кластеризованы рядом. Sort + Diff решают твою беду.

Вобщем думай. Но лучше 1 раз сделай покрывающий пример двух файлов. И результат чего надо на выходе. Это сэкономит время.

Во многих СУБД есть расширения для работы с пространственными и гео-данными.
Например в postgres - PostGIS.
Тебе нужно просто для каждого пользователя определить геолокацию как широту-долготу, а поиск в определённом радиусе уже будет реализован в postgis.

Это будет сильно быстрее чем "сравнить всех со всеми" благодаря специальным индексам