Простой вопрос эффективности C++ (распределение памяти) .. и, может быть, помощь в обнаружении столкновений?

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

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

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

1. Вы можете начать, просто вернув вектор и протестировав его. Кто знает, может быть, достаточно быстро. С помощью профилировщика вы даже можете увидеть, какая часть занимает время выполнения.
2. Вы можете использовать Пул памяти для повторного использования векторов и уменьшения копирования
3. Вы можете попробовать Схема наилегчайшего веса для координат, чтобы уменьшить копирование и распределение, если они повторяются во всем движке.
4. Хранение данных в компоненте - хороший способ уменьшить выделение, но вносит некоторые подводные камни в ваш дизайн, например, тот, кто использует вектор, зависит от жизненного цикла компонента. Пул памяти, наверное, лучше.

Не используйте 2D-вектор. Скорее используйте vector из point. То же самое и для обнаружения столкновений. Использование 2D-вектора здесь - неправильная структура данных.

В зависимости от содержимого функции компилятор сможет выполнить NRVO (то есть оптимизация именованного возвращаемого значения), что означает, что в оптимальном случае возврат вектора имеет накладные расходы нет, т.е. он никогда не копируется. Однако это происходит только тогда, когда вы используете возвращаемое значение вашей функции для инициализации нового экземпляра, и когда компилятор может отслеживать пути выполнения внутри функции и видеть, что для каждого пути возврата возвращается один и тот же объект. Рассмотрим следующие два:

vector<int> f(int baz) {
    vector<int> ret;
    if (baz == 42)
        ret.push_back(42);
    return ret;
}

vector<int> g(int baz) {
    if (baz == 42)
        return vector<int>(1, 42);
    else
        return vector<int>();
}

Компилятор может выполнять NRVO для вызовов f, но не для g.

Если ваш 2D-вектор просто:

 class Vector2D { double x, y; };

Тогда непременно верните его! Например:

  Vector2D function( ... );

Или пройдите по ссылке:

  void function( Vector2D * theReturnedVector2D, ... );

Избегайте любой ценой:

 vector<double> function(...);

Постоянное выделение / освобождение кучи, присущее классу Vector, является ошибкой!

Копирование собственного класса Vector2D очень дешево с вычислительной точки зрения. В отличие от Vector <>, ваш собственный класс Vector2D может включать любые методы, которые вам нравятся.

Я использовал эту функцию в прошлом для включения таких методов, как distanceToOtherPointSquared (), scanfFromCommandLineArguments (), printfNicelyFormatted () и operator [] (int).

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

Остерегайтесь многократных вызовов функций, делающих недействительными предыдущие данные. Это рецепт катастрофы!

Есть большая разница между распределением памяти в куче и в стеке. Выделение в куче, например, использование new / delete или malloc / free очень медленное. Размещение в стеке действительно довольно быстрое. Со стеком обычно медленная часть копирует ваш объект. Так что следите за вектором и т. д., Но возвращение простых структур, вероятно, нормально.