Прост въпрос за ефективност C++ (разпределяне на памет)..и може би малко помощ за откриване на сблъсък?

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

Можете, разбира се, да проучите и пулове памет, където предварително разпределяте много такива компоненти и поставяте в пул, така че да можете да разпределяте нов компонент в постоянно време.

Като обща (и извинения, ако е твърде очевидно) точка, когато правите този вид откриване на сблъсък: повдигнете разстоянията на квадрат, вместо да изчислявате квадратни корени. :)

Ако вашият 2D вектор е просто:

 class Vector2D { double x, y; };

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

  Vector2D function( ... );

Или преминете по препратка:

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

Избягвайте на всяка цена:

 vector<double> function(...);

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

Копирането на ваш собствен Vector2D клас е много евтино от изчислителна гледна точка. За разлика от Vector‹›, вашият собствен Vector2D клас може да включва всякакви методи, които искате.

Използвал съм тази функция в миналото, за да включа методи като distanceToOtherPointSquared(), scanfFromCommandLineArguments(), printfNicelyFormatted() и operator[](int).

или трябва да дам на този съставен обект допълнителна частна 2d-векторна променлива, да редактирам частната променлива при извикване на функцията и да върна указател към този обект?

Внимавайте за множество извиквания на функции, които обезсилват предишни данни. Това е рецепта за катастрофа!

1. Можете да започнете, като просто върнете вектор и го сравните. Кой знае, може да е достатъчно бързо. С профайлър можете дори да видите каква част отнема времето за изпълнение.
2. Можете да използвате пул памет, за да използвате повторно вектори и да намалите копирането
3. Можете да опитате моделът Flyweight за координатите, за да намалите копирането и разпределянето, ако се повтарят през двигател.
4. Запазването на данните в компонента е добър начин за намаляване на разпределенията, но въвежда някои проблеми във вашия дизайн, като това, че който и да използва вектора, зависи от жизнения цикъл на компонента. Пулът памет вероятно е по-добър.

Не използвайте 2D вектор. По-скоро използвайте vector от points. По същия начин за вашето откриване на сблъсък. Използването на 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.

Има голяма разлика между разпределянето на памет в купчината и в стека. Разпределянето на купчината, например използване на new/delete или malloc/free, е много бавно. Разпределянето в стека е наистина доста бързо. При стека обикновено бавната част е копирането на вашия обект. Така че внимавайте за вектор и подобни, но връщането на прости структури вероятно е ОК.