tsarevfs

for (int i = 0, j = 10; i < j; ++i, --j)
{
   const int l = a[i] + 1;
   const int r = a[j] + 1;
   const std::string msg = std::to_string(l + r) + " bottles of rum";
   std::cout << msg << std::endl; 
}

1) i, j обьявлены в заголовке цикла. Они создаются 1 раз и живут до конца цикла.
2) l, r обьявлены в теле цикла. Каждую итерацию мы присваиваем им нове значение. Поскольку int это базовый тип, переменная просто записывется на стек без дополнительного выделения памяти.
3) msg это уже переменная более сложного типа. Хотя она и создается на стеке, внутри конструктора она может выделять память с помощью new. И это будет происходить на каждой итерации.
4) Более того, std::to_string(l + r) создаст временный объект std::string, который удалится после завершения operator+

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

Скорее с тем что пропущены многие #include. Не то что-бы тут что-то одно.
Например в UserDB.h используется класс User, который описан в Auth.h. #include "Auth.h" исправит первую ошибку.
Там где используется string тоже должен быть #include . Причем нельзя просто так опускать имя неймспейса
std::
Короче код не дописан.

Кажется dllmain это то что вам нужно.
Пример использования: https://stackoverflow.com/a/14273614
Для shared libraries под Linux аналог attribute__((constructor))

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

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

На самом деле разница между "кучей" и "не кучей" не такая и большая с точки зрения указателей.
У нас есть 3 варианта размещения переменных:

1. Куча. int* a = new int(3);
   
2. Стек. int b = 5;
   
3. Константная память, инициализируемая на старте приложения. char* c = "hello world";
   

С точки зрения процесса есть большой непрерывный кусок памяти, который называется виртуальная память.
Куча это кусок этой памяти, который хранит сами данные плюс некоторую служебную информацию, которая позволяет например находить свободные места в памяти.
Стек это другой кусок, для которого дополнительно хранится указатель на "голову", который мы сдвигаем при push и pop. Но данные по прежнему в том же большом куске виртуальной памяти с той же адресацией.
Константная память это третья зона с самым простым устройством. Туда записываются значения при старте программы и больше не меняются до конца ее работы.

Также полезно понимать что ссылка и указатель это по сути одно и то же "под капотом". Просто в языке работа с ними выглядит немного по-разному. Ну и ссылка имеет меньше возможностей (а значить меньше простор для ошибки) вроде указывания в никуда (nullptr).

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

Копия это отдельный участок в памяти. Указатели на оригинал и копию будут иметь разные значения. при изменении копии оригинал не будет затронут.
Аналогия с почтовыми адресами более чем уместна. Адрес дома записанный на бумаге - указатель. Сам дом по этому адресу - значение. Создание копии - построить такой же дом в другом месте города. Адрес у копии дома будет разумеется другой.

Реализацию метода отделить, плюс передавать по константной ссылке вместо копии forInt(const forFloat& arg);

Вектор передаете по значению. При каждом вызове функции будет создаваться копия. Исправить эту ошибку так: void Quicksort(vector<int> &A, int p, int r)

MyClass_L.cpp и MyClass_W.cpp нужно тоже целиком завернуть в ifdef
Либо, что наверно более правильно, надо сказать вашей системе сборки (qmake я так понимаю), что надо собирать только нужные cpp.
doc.qt.io/archives/qt-4.8/qmake-tutorial.html "Adding Platform-Specific Source Files"

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

Структуры. Ключевое слово struct. Именно они будут элементами. Прочитайте про них.
Структуры данных на указателях. Дерево -- сложная структура. Начните с односвязного списка. Примеров куча в сети. Тут вам не обойтись без функций. А еще лучше написать класс LinkedList.
Итераторы. Когда написан список, попробуйте разобраться с итераторами. Написать итератор для списка не сложно, но тут уже нужно иметь минимальные представления о классах, методах, перегрузке операторов.
Если сложно, то можно обойтись без них, задача не сильно пострадает.
Деревья. После того как написан список, разобраться с деревьями будет проще. Забейте на "элемент данных void*", пусть у вас это будет то же что и в любом понравившемся примере из интернета. Тем более, в C++ стараются избегать void*.
Обход дерева. Итераторы предполагают, что вы сможете перебирать элементы дерева в некотором порядке. В основном используют 2 подхода: обход в глубину и обход в ширину. Первый несколько проще реализовывать с помощью рекурсии. Для второго может потребоваться структура данных очередь, которую будет полезно написать на основе односвязного списка.
Дерево поиска. Вас просят сделать так, чтобы меньшие элементы были ближе к корню дерева. Есть структура данных "куча"(обычно бинарная куча) , которая это обеспечивает. Но на практике чаще используют деревья поиска, которые тоже это гарантируют. Это достаточно непростая тема, к ней можно вернуться как закончите с остальным.

Первый вариант -- просто сделать это:

std::erase(
	std::remove_if(myVec.begin(), myVec.end(), 
		[&newVec](const A &a)
		{
			return std::find_if(newVec.begin(), newVec.end(), [&a](const A &newA){ return a.id ==  newA.id; }) == newVec.end();
		}),
	myVec.end());

Для упрощения можно перегрузить оператор == для A так, чтобы он сравнивал id:

struct A
{
	//...
	bool operator==(const A &other) const
	{
		return a.id == other.id;
	}
	//...
};

std::erase(
	std::remove_if(myVec.begin(), myVec.end(), 
		[&newVec](const A &a)
		{
			return std::find(newVec.begin(), newVec.end(), a) == newVec.end();
		}),
	myVec.end());

Эти решения будут пробегать по всем элементам из newVec для каждого элемента в myVec. Уже при размере в 1000 элементов для каждого, надо будет сделать 1 000 000 сравнений. ВЫход -- использовать set или unordered_set:

namespace std
{
	//для unordered_set
	template<>
	struct hash<A>
	{
		std::size_t operator()(const A &a)
		{
			return std::hash<int>()(a.id);
		}
	}

	//для std::set
	template<>
	struct less<A>
	{
		bool operator()(const A &lha, const A &rha)
		{
			return lha.id < rha.id;
		}
	}
}

std::unordered_set<A> newSet;
//std::set<A> newSet

newSet.insert(a);
newSet.insert(b);
newSet.insert(d);

std::erase(
	std::remove_if(myVec.begin(), myVec.end(), 
		[&newSet](const A &a)
		{
			return newSet.find(a) == newSet.end();
		}),
	myVec.end());