.. aus einem Array löschen

hallo

hier erstmals der Code, um den es heute geht *g*:

int x[10] = {0,1,2,3,4,5,6,7,8,9};
int y[10] = {0,1,2,3,4,5,6,7,8,9};

if(auswahl(x[4]))
{
x[4]_lösche_dich;
}

dabei sollte es dann nur noch alle anderen werte geben,außer "4":

int x[10] = {0,1,2,3,5,6,7,8,9};

Aber irgendwie schaffe ich es noch immer nicht

Ich will nähmlich gerade ein kleines Kartenspiel programmieren, wo es darum geht wie bei UNO,falls das jemand kennt nur ein bisschen andere Regeln

Ich lege eine Karte (-> --meine_karten)
Computer legt eine Karte (-> --gegner_karten)
Wenn die 4-te Karte == der vom Gegner ist, verschwinden beide.
Wenn aber die eine größer als die andere ist,entfällt die kleinere(wenn zbsp. 2 gegen 4 ... 4 ist größer; 99 gegen 98 ... 99 ist größer)Karte.
Dafür gibt es halt auch Punkte usw..

Mit freundlichen Grüßen
Daniel

hallo again

wie würde es eigentlich mit vectors funktionieren,wenn ich daweil sowas habe:

std::vector<int> ac_cardlenght_am(10);
	ac_cardlenght_am[0] = 0;
	ac_cardlenght_am[1] = 1;
	ac_cardlenght_am[2] = 2;
	ac_cardlenght_am[3] = 3;
	ac_cardlenght_am[4] = 4;
	ac_cardlenght_am[5] = 5;
	ac_cardlenght_am[6] = 6;
	ac_cardlenght_am[7] = 7;
	ac_cardlenght_am[8] = 8;
	ac_cardlenght_am[9] = 9;
	std::vector<int> ac_cardlenght_cp(10);
	ac_cardlenght_cp[0] = 0;
	ac_cardlenght_cp[1] = 1;
	ac_cardlenght_cp[2] = 2;
	ac_cardlenght_cp[3] = 3;
	ac_cardlenght_cp[4] = 4;
	ac_cardlenght_cp[5] = 5;
	ac_cardlenght_cp[6] = 6;
	ac_cardlenght_cp[7] = 7;
	ac_cardlenght_cp[8] = 8;
	ac_cardlenght_cp[9] = 9;

Mit freundlichen Grüßen
Daniel

*D*Evil

std::vector<unsigned short> vec_cards(10);
for (std::size_t item = 0; item < 10; ++item)
    vec_cards.push_back(item);

// Löschen der 2. Karte
vec_cards.erase(vec_cards.begin() + 2);

...

(D)Evil schrieb:

std::vector<unsigned short> vec_cards(10);
for (std::size_t item = 0; item < 10; ++item)
    vec_cards.push_back(item);

// Löschen der 2. Karte
vec_cards.erase(vec_cards.begin() + 2);

...

Vielen Dank

Wie würde es aber mit Arrays funktionieren oO?

Mit freundlichen Grüßen,
Daniel

Andrey

Wie würde es aber mit Arrays funktionieren oO?

na ganz einfach:
du liest dir alles mögliche über arrays, templates, zeiger, operatorüberladung, speicherverwaltung, container und iteratoren durch, und dann schreibst du dir einen container, der genauso aussieht wie <vector> aus der stl, nennst ihn <vector2> und füllst ihn dann mit deinen integer werten

ne, mal ganz ehrlich: es ist ziemlich schwer, etwas besseres, als <vector> hinzubekommen, also benutze gleich die fertige version, dafür ist die doch da

CStoll

Bei Arrays könntest du manuell alle dahinterliegenden Elemente einen Schritt nach vorne kopieren und dir irgendwo notieren, daß das letzte Element ungültig ist (so arbeitet auch vector::erase()). Wenn dir die Reihenfolge der Elemente nicht so wichtig ist, kannst du auch die gerade entstandene Lücke mit dem letzten Array-Element auffüllen.

Simon2

:Daniel: schrieb:

...

Wie würde es aber mit Arrays funktionieren oO?

Vorab: Bei Arrays kannst Du die Größe nicht mehr ändern !! (oder Du musst halt jedesmal händisch kopieren)
D.h. Du entfernst nicht wirklich, sondern lässt nur aufrücken ... aber dafür gibt's Standardfunktionen:

#include <algorithm>
int main() {
   int x[10] = {0,1,2,3,4,5,4,7,8,9}; // extra mal 2 4en drin
   int y[10] = {0,1,2,3,4,5,6,7,8,9};

   // "Entfernen" aller 4en
   std::remove(x, x+10, 4);
   // -> 0 1 2 3 5 7 8 9 8 9

   // "Entfernen" der 4en Position
   std::copy(y+5, y+10, y+4);
   // -> 0 1 2 3 5 6 7 8 9 9

Bei remove() wird Dir zurückgegeben, wo das neue Array "eigentlich aufhört" ... es geht also auch:

#include <algorithm>
int main() {
   int x[10] = {0,1,2,3,4,5,4,7,8,9}; // extra mal 2 4en drin
   int* xEnd = x+10;
   // Entfernen aller 4en
   xEnd = std::remove(x, xEnd, 4);

... und mit (xEnd - x) bekommt man auch die neue "Länge" raus (obwohl x im Speicher natürlich immer noch denselben Speicherplatz belegt).

Prinzipiell gilt: Wenn Du Elemente entfernen willst, muss Dein gesamtes Programm mit einer dynamischen Länge rechnen !! ("nirgends darf mehr eine 10 stehen")
... womit wieder ein Vorteil eines Arrays gegenüber std::vector entfallen wäre

Gruß,

Simon2.