Wataru

Не работает ваш код потому, что, допустим при i==3 вы удаляете элемент. Теперь элементом по индексу i будет следующий за удаленным элемент. Вы его не проверите и в конце итерации i увеличится на 1. Таким образом, следующие за удаляемым элементом вы просто пропустите.

Есть много способов исправить эту оплошность:
1) При удалении уменьшайте i на 1, чтобы следующее i++ от цикла for было отменено.
2) Вместо цикла for используйте while, где вы инкрементируете i только если элемент не удаляется.
3) Вместо if используйте цикл while, который удялял бы элемент в позиции i, пока его надо удалять (не забудьте проверить, что элемент, таки, существует - вы могли удалить последний элемент и i станет за границей массива).
4) (лучший вариант) Используйте remove. Мало того, что вам не надо изобретать велосипед, так этот метод еще и будет на порядок быстрее удаления по одному элементу. Потому что при каждом удалении у вас сдвигается часть массива и вы получаете квадратичное время работы на ровном месте.

У вас дла regular в программе - это и член класса Parsing и локальная переменная в функции Parse. Инициализируется чем-то только локальная переменная.

Где конкретно и на что именно вы в дебаггере смотрите, мне не понятно, но скорее всего ошибка в том, что вы смотрите не туда.

Используйте memcopy. Копируете из адреса дабловой переменной в адрес интовой.

Трюки с union и реинтерпритацей указателей довольно опасны.

Нет разницы.

Можно же проверить самостоятельно. Технологии нынче - все легко. Вот: https://godbolt.org/z/PKWPdY4nn

Как видите, и то и другое компилируется в практически одинаковые инструкции:

eax, DWORD PTR MyGlobalPool[rip+4]
...
eax, DWORD PTR MyPool1::numOfAllocatedObjects[rip]

И там и там просто загрузка какого-то статичного адреса глобальной переменной. Вообще говоря, в случае с глобальной переменной компилятор мог бы сдлеать и 2 действия: взять адрес переменной и прибавить смещение поля. Но он, как видите, достаточно умный, чтобы сделать все в одну инструкцию.

У вас там такая мешанина... Перепишите с использованием std::vector. Когда вы пытаетесь одновременно использовать указатели на классы и указатели, как массивы, вы все путаете.

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

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

Ну и зачем вам виртуальное GetDest, если оно нигде не перегружается наследником?

Ошибка, если ее перевести, означает: вы вышли за границу массива arr.

Смотрите внимательно, где вы к нему обращаетесь. Особенно на arr[j + 1]. Какие значения может принимать j? Какой размер массива и, соответственно, к каким индексам можно обращаться?

(-1) % 3 = 2

Это математическое определение вычетов по модулю. Все числа, которые отличаются на n, имеют одинаковый остаток по модулю n. Конфуз происходит из-за того, что операция взятия по модулю во многих языках программирования работает не так. Для отрицательных чисел она выдаст отрицательное значение, правда к которому можно прибавить n, что бы получить правильный модуль - число от 0 до n-1.

Поэтому при реализации можно делать (a-b+3)%3 Или преобразовать, чтобы не было вычитания: b == (a+1)%3

Только если вам известен ПРЕДЫДУЩИЙ элемент. Иначе за честные О(1) вы из односвязного списка ничего не удалите.

Можно амортизационно удалить за О(1) просто пометив этот элемент удаленным. Но тогда все функции, которые проходятся по списку, должны такие помеченные элементы действительно удалять во время прохода.

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

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

Безопасно.

Еще комментарии. Это же С++, а не С?

Вместо набора функций, которые возвращают и принимают IntList1D, стоит завести класс, который содержит в себе указатель на начало списка. У этого класса должны быть методы initalize, is_initialized, pushBack, и т.д. Это сократит код немного и сделает его гораздо более логичным.

Тип элемента списка вы объявляете как приватный класс-член в классе списка, и он не будет засорять пространство имен пользователей вашей библиотеки. Им о нем вообще знать не надо, они хотят в ваш список класть int и получать назад int.

Далее, вы пишите контейнер, в идеале его стоит сделать по образу и подобию стандартных контейнеров. С итераторами и т.д. Чтобы с ними было можно работать точно также. Но, если не потянете, то хоть обзовите методы также, как у стандартных (push_back(), empty(), см std::vector, например).

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

Потом, часть функций называется частично большими буквами, частично строчными. Это вообще зачем? APPEND_FRONT_Link? Соблюдайте единый стиль хотябы в одном названии. Если они отличаются от appendFront тем, что они не предназначены для пользователей библиотек, ну так это как раз аргумент в пользу использования классов. Делаете эту функцию приватным методом. И такие обычно называются с суффиксом Impl (от implementation) - appendFrontImpl.

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

Выражение под суммой, отмеченное красным на картинке - это сумма арифметической прогрессии, вы же сами написали.

Первый член - 1 (при j=i+1), последний - n-i (при j=n). Всего их n-i. Ну а дальше - стандартная формула: среднее крайних членов, помноженное на их количество.

Как из этого получается O(n^3). По уму, надо раскрыть скобки и разложить на сумму трёх рядов, в зависимости от степени i в слагаемом. Дальше сумма i даст также O(n^2). Сумма по i^2 даст O(n^3). Тут уже нельзя арифметическую прогрессию применять, но это известная формула - сумма n квадратов даст n(n+1)(2n+1)/6. Ее можно вывести, если взять ряд f(x)=1+x+x^2+...+x^n = (1-x^{n+1})/(1-x) и найти (x*f'(x))'. Потом туда можно подставить x=1. Или есть визуальные доказательства. Каждый квадрат - это квадрат из кубиков. Их все можно сложить в пирамиду. 6 таких пирамид можно сложить в параллелепипед.