Also, ich bin da an einer Sache dran. Ich programmiere an einem kleinen Spiel, in der Konsole, in welchem ein kleines UBoot durch eine Höhle taucht.
Die Karten für die Höhle scrollen von rechts nach links am UBoot vorbei - sollen sie zumindest.
Ich habe bisher meine Karte, Feld für Feld in einem zweidimensionalen Array gespeichert. Das Array ist allerdings knapp 200 x 17 groß (x & y).

Jetzt ist mir klar, ich kann beim scrollen nicht jede Frame das ganze Array komplett neu berechnen (indem ich Wert für Wert ein Feld nach links trage).
Also vllt. kann ich das schon machen, aber ich dachte an etwas, mit dem der CPU nicht ganz soviel arbeit hat.

Meine Idee war also bisher folgende:
100x17 werden auf dem Bildschirm durch meine Renderfunktion tatsächlich dagestellt. Jedesmal wenn gescrollt wird, zähle ich die Zeiger, die auf die X-Arrays zeigen, um eines hoch. Definierte also einen neuen 0 Punkt.

Das Problem, dass sich hierbei ergibt ist, dass ich nach Links hin an Array verliere (das ich obendrein nicht einfach so löschen kann), und Rechts nicht dazukommt.

Ich benutze Vector nicht, weil ich eigentlich Zeit sparen will.

Also dachte ich, mache ich ein zweites Array, in dass ich - während gescrollt wird - einmal die Anfangs nicht sichtbaren Felder der Karte lade, und dahinter eben eine neue Karte aus einer Datei. Ist das erste Array "durchgescrollt", ersetze ich es durch das neue (indem ich die Zeiger entsprechend ausrichte) und gebe den Speicher entsprechend zurück.

Diese Ladevorgänge sollen dann Stückweise, Frame für Frame ablaufen, sodass jede Frame möglichst wenig rechnerisch passiert.

Ist das ganze den Aufwand überhaupt Wert? Ist Vector wirklich so langsam im vergleich zu Arrays? Ich möchte einfach nur nicht, dass ein so simples Konsolenspiel dem Prozessor soviel abverlangt.

Mit freundlichen Grüßen und Danke im voraus,

Thez

P.S.: Sorry für die Überschrift, wusste auch nicht wie ich das auf den Punkt bringe sollte.

Ansonsten kannst du die ganze Karte komplett laden und du zeigst dann einfach nur das an, was gerade relevant ist. Du berechnest also nicht das ganze Array neu, sondern fängst mit der Ausgabe einfach ein Stück weiter hinten an.

#include <iostream>
#include <vector>
#include <string>
#include <map>
#include <ctime>
#include <Windows.h>

const int DISPLAY_X = 75;
const int MAP_X = 1500;

void SetCursorXY(int x, int y) 
{ 
    COORD pos = {x, y};

    SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}

void SetupMap(std::vector<std::string>& map)
{
	std::srand(static_cast<unsigned int>(std::time(NULL)));

	std::string border(MAP_X, '#');

	map.push_back(border);
	map.push_back(border);

	for (std::size_t i = 0; i < 6; ++i)
	{
		std::string line(MAP_X, ' ');

		for (std::size_t j = 0; j < MAP_X; ++j)
		{
			if (std::rand() % 5 == 0)
				line[j] = '*';
		}

		map.push_back(line);
	}

	map.push_back(border);
	map.push_back(border);
}

void Render(std::vector<std::string>& map, int renderPos)
{
	for (std::size_t i = 0; i < map.size(); ++i)
	{
		std::cout << map[i].substr(renderPos, DISPLAY_X) << "\n";
	}
}

int main()
{
	std::vector<std::string> map;

	int scrollPos = 0;

	SetupMap(map);

	while (true)
	{
		SetCursorXY(0, 0);

		Render(map, scrollPos);

		++scrollPos;

		// Für alle Fälle
		if (scrollPos >= MAP_X - DISPLAY_X + 1)
			scrollPos = 0;

		Sleep(10);
	}
}

Das Vorgehen ist sicherlich nicht ideal, aber es soll auch nur ein Beispiel sein.

ist der STL Vector wirklich soviel langsamer in der Handhabung als ein Array?

Nein. Vor allem im Release Build sollte überhaupt kein Unterschied übrig bleiben.