Надлежащее векторное управление памятью

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

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

Это не прямой ответ на вопрос, но в моей компании мы используем IncrediBuild для распределенной компиляции. Это действительно ускоряет процесс компиляции. http://incredibuild.com/visual_studio.htm

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

Во-вторых, какова реальная проблема - что после удаления 10 000 предметов память не освобождается? Речь идет о свободной памяти, сообщаемой операционной системой, или о свободном пространстве в куче? Возможно (и весьма вероятно), что какой-то другой объект был выделен после положения данных вектора, поэтому просто освободить эту память операционной системе не представляется возможным; но его можно повторно использовать для других вновь созданных объектов.

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

Вот как обычно ведет себя модель распределения памяти вектора, чтобы обеспечить операцию амортизированного постоянного времени push_back . В основном она пытается угадать, что вы можете захотеть заполнить стертую часть новым элементом, чтобы она не освободить память. Таким образом можно избежать постоянного выделения и освобождения. Чтобы обойти это, вы можете использовать трюк подкачки, чтобы освободить неиспользуемую векторную память. Вы должны заменить пустой вектор временным безымянным вектором, чтобы, когда временный вектор выходит за пределы области видимости, он освобождает память в его деструкторе, что-то вроде: vector (c) .swap (c)

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

Примечание:
Если вы относительно часто стираете из середины контейнера, то вектор может быть неправильным контейнером. Это потому, что если вы удалите элемент n, тогда все элементы из [n + 1, end) должны быть перемещены на одну позицию вниз в памяти.

Когда пуля закончена, я выполняю bullets.erase (bullets.begin () + i);

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

#include <algorithm>
#include <functional>
#include <vector>

class Bullet
{
    // ...
public:
    bool is_finished() const;
};

int main()
{
    std::vector<Bullet> bullets;
    // ...
    bullets.erase(
        std::remove_if(
            bullets.begin(),
            bullets.end(),
            std::mem_fun_ref(&Bullet::is_finished)
        ),
        bullets.end()
    );
}

При таком подходе каждая активная пуля перемещается не более одного раза.