Евгений Шатунов

1. Списковые включения - это пример декларативного подхода, поэтому неправильно пытаться их осмыслить с императивных позиций, но переменную i можно считать переменной цикла, принимающей на каждой итерации новое значение итератора. Обратиться к ней после построения списка нельзя.
   
2. Потому что строка - это последовательность символов.
   

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

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

Переформатировал код под себя. Не могу воспринимать египетские скобки.

void Printer::addM(Moved obj) 
{
  Moved* tmp = new Moved[mSize];
  for (int i = 0; i < mSize; i++) 
  {
      tmp[i] = objs[i];
  }
  objs = new Moved[++mSize];
  for (int i = 0; i < mSize - 1; i++)
  {
    objs[i] = tmp[i];
  }
  objs[mSize - 1] = obj; 
  Car mytmp; // для теста
  cout << mytmp.getType() << endl; // для теста
  cout << objs[mSize-1].getType() << endl; 
  Sleep(100);
}

У вас две проблемы. Во-первых вы зачем-то переизобрели std::vector, поэтому вам приходится писать примерно в 5 раз больше кода чем надо.

Во-вторых, вам надо хранить не объекты Moved, а указатели на них, и тогда ваша гомологическая иерархия классов заработает.

Как я и говорил выше, addM работает не так, как вы ожидаете. Когда вы ее вызываете, у вас происходит создание Moved на основе Car или Walker, что исключает полиморфизм.

Нужна const-корректность, также важно отсутствие лишнего копирования. Пример оператора, определённого в классе:

bool operator >(const triple& n) const
{
    return c > n.c;
}

А вообще, такое ощущение, что весь класс можно заменить на:
using triple = std::tuple<int, int, int>;

"Отодвинуть" звучит как сдвинуть так, чтобы центры остались на той же прямой. Это было бы
логично.
Уравнение прямой y = kx + b строится по двум точкам. Для простоты перенесем центр одной из окружностей в начало координат, тогда уравнение будет y = kx.
Из условия расстояния строим ещё одно уравнение:
y^2 + x^2 = 4r^2
Решаем систему из двух уравнений, получаем x и y, затем переносим центры обратно.

Отдельно рассмотреть случай, когда центры совпадают, и выбрать тривиальную прямую y = 0, например.

this — это указатель на текущий объект. *this — это ссылка на текущий объект. Пример:

class A {
public:
  int x;
  A(const A& other) = default;
  A& operator=(const A& other) {
    x = other.x;
    return *this;
  }
};

void test() {
  A a(1);  // a.x == 1
  A b(2);  // b.x == 2
  A c(3);  // c.x == 3

  a = b = c;
  // a.x == 3
  // b.x == 3
  // c.x == 3
}

Как работает вот это присваивание? Оператор присваивания право-ассоциативен, то есть компилятор видит это как a = (b = c);. Итак, вначале b = c. Вызывается b.operator=(c). Там мы вначале присваиваем c.x (3) в b.x, затем (и это здесь самое главное!) возвращаем ссылку на b. Далее в a = (результат) объекту a присваивается та самая возвращённая ссылка на b, благодаря чего в a.x тоже оказывается 3.

Очередной "я не читал мануалы, памагити" вопрос.

Читайте Снейдер, Й. "Эффективное программирование TCP/IP".

Кратко - функции send() и recv() не гарантируют, что будет записано или прочитано столько байт, сколько вы в них передали. Нужно анализировать возвращенное этими функциями значение - если оно 0 или < 0 - что-то поломалось и нужно анализировать errorno, в противном случае, вот столько байт и передалось.

https://qna.habr.com/help/rules

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

Скорее всего жаловаться надо

const нужен потому, что если компаратор будет что-то в контейнере менять, у контейнера явно поедет крыша. Профессионалы вешают const (а еще лучше - constexpr) на любую сущность, которая не должна меняться по логике алгоритма.

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

Это называется Non Type Template Parameter (NTTP). Передавать туда можно только константы (если не пытаться взорвать себе мозг). Объявить такой шаблон можно следующим образом:

template <size_t size>
struct Array {
    MyClass data[size];
};

Array<5> a;
a.data[2] = ...;

Определение методов оставлю как упражнение для читателя.
В std::array два параметра шаблона: тип и константа, так что он применим не только для MyClass, но и для любых других типов.

Создавать объекты виртуальных классов следует только через:

std::vector<std::unique_ptr<object>> world;

auto terr = std::make_unique<Terrain>();
world.push_back(std::move(terr));

Или:
world.push_back(std::make_unique<Terrain>());

Чтобы устранить утечку памяти, которая сейчас присутствует в коде, нужно обязательно добавить в object:

object& operator=(object&&) = delete;
virtual ~object() = default;

1) Не следует допускать торчания из классов полей с данными - все поля, кроме, быть может, констант, следует делать приватными.
2) В таком случае, у ваших классов появятся методы для доступа к этим полям, которые нужно будет объявить виртуальными
3) Вместо хранения экземпляров в векторе объектов, следует сделать вектор из умных указателей на эти объекты
4) Базовый класс для этих объектов желательно сделать абстрактным, на худой конец - интерфейсным.

После этого, ваша гомологическая иерархия классов станет вести себя так, как вы этого хотите.