Денис Загаевский

Это какая-то разновидность нотации Бэкуса-Наура, по-моему. Запись вида

X:
    A
    B
    C

Следует читать как "X - это А или B или C". Когда два определения идут подряд - это значит, что они следуют друг за другом. Те определения, которые определяются через другие - это нетерминалы, те, которые понятны сами по себе - терминалы. Всё это работает рекурсивно. Короче, примерно вам даст понять вот это https://ru.m.wikipedia.org/wiki/Форма_Бэкуса_—_Наура

Ну и читать это так: идентификатор(identifier) - это последовательность символов, которая может быть не цифрой(identifier-nondigit) или начинаться с идентификатора(рекурсия) и продолжаться не цифрой, или начинаться с идентификатора и продолжаться цифрой(digit)
Дальше идёт углубление - что такое identifier-nondigit, что такое digit и тд.

Тут ошибка

if ( one == 2 && two == 2 && three == 2 ) 
          {
            losNL[ i ].priority = 3;
          } 

          if ( one == 2 && two == 2 || one == 2 && three == 2 || two == 2 && three == 2 ) 
          { 
            losNL[ i ].priority = 2;
          }

          if ( one == 2 || two == 2 || three == 2 ) 
          { 
            losNL[ i ].priority = 1;
          }

Если есть хоть одна двойка, то приоритет будет 1. Заметьте, не "ровно одна", а хотя бы одна. Нужно else вставить после if'oв.

Просто описание класса заканчивайте точкой с запятой. Сразу после }. Ну и ещё ссылки вперёд запрещены. Либо описывайте MyClass2 перед MyClass1, либо просто объявите его:

class MyClass2;
class MyClass1
{
   public:
   MyClass2 mc2;
   ..{пустой конструктор}
};

class MyClass2
{
   public:
   int A,B,C;
   ..{пустой конструктор}
};

Надеюсь, это чисто академическая задача:)
Вообще, классическое решение состоит в том, чтобы когда стек пуст, top == null. То есть, в самом начале вы НЕ запихиваете top(null, null).

Это называется "динамический полиморфизм".
Виртуальные методы полезны тем, что вызывая метод через ссылку или указатель на базовый класс, на самом деле вы вызываете метод дочернего класса:

class B {
public:
    virtual void f() {}
    ...
}

class D: public B{
public:
    void f(){}
    ...
}
...
doF(D());
...
void doF(const B& b){
    b.f();// вызовется D::f() 
}

Если написать вместо тела виртуальной функции "=0;", то получится чисто виртуальный класс. Это уже полноценный аналог абстрактного класса в джаве. А если сделать все методы чисто виртуальными и не делать полей-данных, то получится аналог интерфейса.

Виртуальным обязательно должен быть деструктор у класса, который создаётся для наследования. Иначе сделав так:

B *d = new D();
delete d;

вы вызовете только деструктор базового класса.

Стоит ли смотреть в любую сторону - зависит от того, чем вы хотите заниматься. Перейти можно с любого языка на любой, и С++ тут ничем особым не выделяется. У меня есть даже пример, когда команде переход с С++ на Java дался очень плохо.
Да, в С++ вы должны управлять памятью, это отличный способ выстрелить себе в ногу, и поэтому сейчас советуют отходить от сырых указателей к shared/unique/etc_ptr.
В Java сборщик мусора, да, но это давно не проблема в обычных приложениях. Управлять памятью в С++ - сложно.

Методы из java-байткода в рантайме компилируются в платформенный код, это ускоряет очень сильно.

По моему опыту, операторы нужны, если вы используете шаблоны.
Например, запихните ваши объекты в std::vector и вызовите std::sort(vec.begin(), vec.end());
В этом случае будет использоваться operator< для того, чтобы отсортировать значения.
или например, напишите свою функцию

<template class T>
T sum3(T t1, T t2, T3) {
   return t1 + t2 + t3;
}

sum3(MyClass(), MyClass(), MyClass());

этот код скомпилируется только если вы определите MyClass::operator+.
Тот же std:: sort может использовать operator() для сравнения объектов, прямо из доков.
Ну и в таком духе дальше.

А что в этом такого? Вы сделали виртуальный метод с реализацией. Затем унаследовали класс, не переопределив метод. Метод публичный. То, что он внутри обращается к приватным полям - без разницы. Приватные поля содержатся в наследнике, просто они ему не доступны.

Во-первых, байт неделим, это вы чушь несёте.
Во-вторых, число хранится не в hex, а в бинарном виде:
2016 == 0b111_11100000
first = 0b111 == 7
second = 224 == 0b11100000
Собственно, вам надо first сдвинуть влево на 8 и прибавить к этому second.
int year = (first << 8) + second;
Тут сложение эквивалентно "логическому или":
int year = (first << 8) | second;