SDL_Surface *i1 = IMG_Load("1.png");
// ...
SDL_Surface *i42 = IMG_Load("42.png");

Ich will ein int wert haben um mit den Bildern einfache vergleiche machen zu können (if(p1 > p3). Außerdem hab ich da ein mouseover mit den Bildern.
Ein Wert kann ich ja nicht einfach in einer schleife erhöhen und wieder abfragen.
Ich müsste immer:

if(hover(i1)) { }

schreiben. Und das 42 mal.

Von daher will ich es so lösen:

std::map<int zahl, SDL_Surface *fs > card;
int i=1;

// alle bilder laden.
while(i <= 42) {
card[wert[i]] = IMG_Load((wert[i] + ".png").c_str());
i++;
}

// dann brauch ich nurnoch:
while(i <= 42) {
if(hover(card[i]) {  // hover() erwartet als parameter die SDL_Surface
  // bild hoch
  break;
}
}

und alles wäre gut.
Ist das eurer Meinung nach erstmal überhaupt die richtige Lösung?

vector<SDL_Surface *fs> card(int zahl)      
    {
// ...
    }

std::vector<SDL_Surface*> cards;

for (unsigned i = 0; i < 42; ++i)
    cards.push_back(IMG_Load((wert[i] + ".png").c_str()))

for (unsigned i = 0; i < 42; ++i)
{
    if (hover(cards[i]))
        foo();
}

void loadimg() {
    int i = 1;
    SDL_Surface *scr[i];
    // alle bilder laden.
    while(i <= 1) {

        scr[i] = IMG_Load(strcat(i, ".png"));
     // scr[i] = IMG_Load(((char)i + ".png").c_str());
        i++;
    }
}

Warum scheitern beide methoden?
Wie mach ich das richtig?

error: invalid conversion from `int' to `char*'|

bzw.

error: request for member `c_str' in `((+((unsigned int)((char)i))) + ((const char*)".png"))', which is of non-class type `const char*'|

#include <iostream>
#include <sstream>

int main()
{
	for(int i(0); i != 10; ++i) {
		std::stringstream convert; // EDIT: Hier würde auch schon ein std::ostringstream reichen
		convert << i;
		std::cout << convert.str().append(".png").c_str() << "\n"; // .c_str() wäre in diesem konkretem Beispiel natürlich unnötig ;)
	}

	return 0;
}

EDIT die Zweite: Noch ein kleines Fehlerschen ausgemerzt. Es ist einfach noch zu früh

Aber statt deines Arrays wäre es wohl einfacher mit vector zu arbeiten wie schon vorgeschlagen.

EDIT:
Da war wohl einer schneller

stream << i << ".png";

Ja, das wäre natürlich noch eine Verbesserung des oben geposteten Codes.

hmm. Das ist doof.
Wie macht man das denn richtig?

Indem du bei den Grundlagen beginnst! Im FAQ dieses Forums gibt es genug Hinweise, wie man mit C++ beginnt.

Die Stringoperationen in C++ sind zwar alle super durchdacht und großteils auch toll umgesetzt, aber für solche Kleinigkeiten wirds dann schnell mal unübersichtlich.

In C++ würde ich es mit einem Stringstream machen:

std::stringstream ss;
  ss << i << ".png";
  scr[i] = IMG_Load(ss.str().c_str())

(denn ss.str() liefert einen std::string retour und .c_str() liefert einen C-String vom std::string)

Aber warum eigentlich nicht mit den bewährten C-Funktionen:

char buffer[128];
  sprintf(buffer, "%d%s", i, ".png");
  scr[i] = IMG_Load(buffer);

unter Visual C++ (also mit dem Microsoft Compiler) sollte die zweite Zeile sicherer lauten:

sprintf_s(buffer, sizeof(buffer), "%d%s", i, ".png");

Dadurch wird verhindert daß das Ergebnis größer werden kann als der buffer.

In C++ gäbs auch noch eine Quick&Dirty Methode:

scr[i] = IMG_Load( (std::string(itoa(i)) + ".png").c_str() );

Ich denke ich würde mich für die zweite Methode entscheiden da die erste zu aufwendig und die letzte ganz übel gefährlich ist. Aber ich will ja nichts vorenthalten

mfg
Elerian

Ich denke ich würde mich für die zweite Methode entscheiden da die erste zu aufwendig und die letzte ganz übel gefährlich ist. Aber ich will ja nichts vorenthalten

Also 3 Zeilen ordentliches C++ ist aufwendiger als 3 Zeilen C? Das Argument verstehe ich nicht.

Also ich finde die c++ variante sieht zum einen besser aus und ist nach meiner Einschätzung auch intuitiver zu nutzen.

Aber das ist wohl auch eine Frage der Gewöhnung. Soll jeder wie er/sie will.

Also ich finde die c++ variante sieht zum einen besser aus und ist nach meiner Einschätzung auch intuitiver zu nutzen.

Das finde ich auch. std::stringstream erstellen, die Zeichenkette über den Eingabeoperator des std::stringstreams zusammenbasteln und das ganze ruck zuck der Funktion übergeben.

Elerian schrieb:

Ich denke ich würde mich für die zweite Methode entscheiden da die erste zu aufwendig und die letzte ganz übel gefährlich ist.

Ich sehe darin ehrlich gesagt keinen großen Aufwand

// format:
scr[i] = IMG_Load(str(format("%d.png") % i).c_str()); 

// lexical cast:
string filename = lexical_cast<string>(i) + ".png";
scr[i] = IMG_Load(filename.c_str());

Ist wesentlich kuerzer und weniger verbose als die stringstream-loesung, aber dabei typsafe (im gegensatz zu sprintf).

EDIT:
Was aber nicht heisst, dass ich das als keine schöne Lösung empfinde.

Also das verbose ist ja kein Grund. Dafür kann man sich ja eine einfache Funktion schreiben. Und wegen Geschwindigkeit: Wenn ich mich nicht irre arbeitet lexical_cast intern ja auch mit streams..

EDIT:
Was aber nicht heisst, dass ich das als keine schöne Lösung empfinde.

Klar ist verbose ein Grund. Laengerer Code ist schwerer zu verstehen Und die Funktion musst du eben nicht selbst schreiben, denn genau das hat boost gemacht (und ja, lexical_cast verwendet stringstreams).
Von Geschwindigkeit hab ich nie geredet, der Code vom OP ist ja nicht Performancekritisch (die boost-Loesungen sind sicher nicht effizienter als stringstreams, wobei die vermutlich nichtmal selbst Geschwindigkeitsbiester sind)