Memory Spiel

schue04

Hallo,

in habe hier ein Memory Spiel und muss jetzt eine Funktion zum Aufdecken(Schummeln) einbauen. Bin da jetzt schon seit Wochen immer wieder bei
bekomme aber keine Lösung hin. Vielleicht kann mir ja mit Tipps ein bisschen helfen. Habe also einen Button zum Aufdecken, dieser startet bezw. beendet die
Timer. Timer1 ist klar. Aber wie muss Timer2 genau aussehen? hier muss ich die noch nicht Aufgedeckten Karten aufdecken und nach ca.2 Sekunden wieder Umdrehen.
Ich habe auch ein Array(Nspielfeld) für das Zwischenspeichern des aktuelles Spielfeldes erstellt.

#pragma once

namespace Memory {

using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;

/// <summary>
/// Zusammenfassung für Form1
///
/// Warnung: Wenn Sie den Namen dieser Klasse ändern, müssen Sie auch
/// die Ressourcendateiname-Eigenschaft für das Tool zur Kompilierung verwalteter Ressourcen ändern,
/// das allen RESX-Dateien zugewiesen ist, von denen diese Klasse abhängt.
/// Anderenfalls können die Designer nicht korrekt mit den lokalisierten Ressourcen
/// arbeiten, die diesem Formular zugewiesen sind.
/// </summary>

public ref class Form1 : public System::Windows::Forms::Form
{

//die eigenen Attribute
private:

//die Anzahl der bereits umgedrehten Karten

Int32 offeneKarten;

//der aktuelle Spieler

Int32 spieler;

//ein Array vom Typ Point für die Position der offenen Karten

array <Point> ^offeneKartenPos;

//ein Array für die Paare

array <Int32> ^paare;

//ein zweidimensionales Array für die Indizes der Bilder

array <Int32,2> ^initSpielfeld;

//ein zweidimensionales Array für das Spielfeld

array <Int32,2> ^spielfeld;

//ein zweidimensionales Array für das zwischenspeichern von Spielfeld

array <Int32,2> ^Nspielfeld;

private: System::Windows::Forms::Button^ buttonAufdecken;
private: System::Windows::Forms::Timer^ timer2;

//ein zweidimensionales Array vom Typ Point für die bereits umgedrehten Karten

array <Point,2> ^aufgedeckt;

public:
Form1(void)
{
InitializeComponent();
//
//TODO: Konstruktorcode hier hinzufügen.
//
//einige Hilfsvariablen

Int32 bild = 0;

array <Int32> ^feld = gcnew array <Int32>(42);

//für das Mischen des Arrays Feld über den Zufallgenerator

Random ^zufallszahl;

//das anlegen der Arrays

offeneKartenPos = gcnew array <Point>(2);

paare = gcnew array <Int32>(2);

initSpielfeld = gcnew array <Int32,2>(7,6);

spielfeld = gcnew array <Int32,2>(7,6);

aufgedeckt = gcnew array <Point,2>(21,2);

Nspielfeld = gcnew array <Int32,2>(7,6);

//Initialisieren

//Der Spieler ist der Mensch, beide Spieler haben kein Paar

spieler = 0;

paare[0] = 0;

//aufgedeckt wird mit -1 belegt

for (Int32 schleife1 = 0; schleife1 < 21; schleife1++)

for (Int32 schleife2 = 0; schleife2 < 2; schleife2++){

aufgedeckt[schleife1, schleife2] = Point(-1,-1);
}

for (Int32 schleife = 0; schleife < 42; schleife++){

feld[schleife] = bild;

if (((schleife +1) % 2 == 0))

bild++;
}

//und jetzt wird gemischt

//eine neue Instanz für Random erzeugen

zufallszahl = gcnew Random();

for (Int32 schleife = 0; schleife < 42; schleife++){

Int32 temp1, temp2;

//eine zufällige Zahl im Bereich 0 bis 41 erzeugen

temp1 = zufallszahl->Next(42);

//den alten wert in Sicherheit bringen

temp2 = feld[temp1];

//die Werte tauschen

feld[temp1] = feld[schleife];

feld[schleife] = temp2;
}

//Kopieren der Werte aus dem gemischten Array
//feld in initSpielfeld und Setzen der eigentliche Karte auf den Index 32

for (Int32 schleife1 = 0; schleife1 < 7; schleife1++)

for (Int32 schleife2 = 0; schleife2 < 6; schleife2++){

initSpielfeld[schleife1, schleife2] = feld[schleife2 * 7 + schleife1];

spielfeld[schleife1, schleife2] = 22;
}

}

protected:
/// <summary>
/// Verwendete Ressourcen bereinigen.
/// </summary>
~Form1()
{
if (components)
{
delete components;
}
}
private: System::Windows::Forms::TableLayoutPanel^ tableLayoutPanel1;
private: System::Windows::Forms::ImageList^ imageList1;
private: System::Windows::Forms::Timer^ timer1;
private: System::Windows::Forms::Label^ labelMensch;
private: System::Windows::Forms::Label^ labelComputer;
private: System::Windows::Forms::Label^ labelMenschPaar;
private: System::Windows::Forms::Label^ labelComputerPaar;

private: System::ComponentModel::IContainer^ components;
protected:

private:
/// <summary>
/// Erforderliche Designervariable.
/// </summary>

#pragma region Windows Form Designer generated code
/// <summary>
/// Erforderliche Methode für die Designerunterstützung.
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
/// </summary>
void InitializeComponent(void)
{
this->components = (gcnew System::ComponentModel::Container());
System::ComponentModel::ComponentResourceManager^ resources = (gcnew System::ComponentModel::ComponentResourceManager(Form1::typeid));
this->tableLayoutPanel1 = (gcnew System::Windows::Forms::TableLayoutPanel());
this->imageList1 = (gcnew System::Windows::Forms::ImageList(this->components));
this->timer1 = (gcnew System::Windows::Forms::Timer(this->components));
this->labelMensch = (gcnew System::Windows::Forms::Label());
this->labelComputer = (gcnew System::Windows::Forms::Label());
this->labelMenschPaar = (gcnew System::Windows::Forms::Label());
this->labelComputerPaar = (gcnew System::Windows::Forms::Label());
this->buttonAufdecken = (gcnew System::Windows::Forms::Button());
this->timer2 = (gcnew System::Windows::Forms::Timer(this->components));
this->SuspendLayout();
//
// tableLayoutPanel1
//
this->tableLayoutPanel1->ColumnCount = 7;
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->ColumnStyles->Add((gcnew System::Windows::Forms::ColumnStyle(System::Windows::Forms::SizeType::Absolute,
64)));
this->tableLayoutPanel1->Location = System::Drawing::Point(0, 0);
this->tableLayoutPanel1->Name = L"tableLayoutPanel1";
this->tableLayoutPanel1->RowCount = 6;
this->tableLayoutPanel1->RowStyles->Add((gcnew System::Windows::Forms::RowStyle(System::Windows::Forms::SizeType::Absolute, 64)));
this->tableLayoutPanel1->RowStyles->Add((gcnew System::Windows::Forms::RowStyle(System::Windows::Forms::SizeType::Absolute, 64)));
this->tableLayoutPanel1->RowStyles->Add((gcnew System::Windows::Forms::RowStyle(System::Windows::Forms::SizeType::Absolute, 64)));
this->tableLayoutPanel1->RowStyles->Add((gcnew System::Windows::Forms::RowStyle(System::Windows::Forms::SizeType::Absolute, 64)));
this->tableLayoutPanel1->RowStyles->Add((gcnew System::Windows::Forms::RowStyle(System::Windows::Forms::SizeType::Absolute, 64)));
this->tableLayoutPanel1->RowStyles->Add((gcnew System::Windows::Forms::RowStyle(System::Windows::Forms::SizeType::Absolute, 64)));
this->tableLayoutPanel1->Size = System::Drawing::Size(448, 384);
this->tableLayoutPanel1->TabIndex = 0;
this->tableLayoutPanel1->Paint += gcnew System::Windows::Forms::PaintEventHandler(this, &Form1::tableLayoutPanel1_Paint);
this->tableLayoutPanel1->CellPaint += gcnew System::Windows::Forms::TableLayoutCellPaintEventHandler(this, &Form1::tableLayoutPanel1_CellPaint);
this->tableLayoutPanel1->MouseClick += gcnew System::Windows::Forms::MouseEventHandler(this, &Form1::tableLayoutPanel1_MouseClick);
//
// imageList1
//
this->imageList1->ImageStream = (cli::safe_cast<System::Windows::Forms::ImageListStreamer^ >(resources->GetObject(L"imageList1.ImageStream")));
this->imageList1->TransparentColor = System::Drawing::Color::Transparent;
this->imageList1->Images->SetKeyName(0, L"apfel.bmp");
this->imageList1->Images->SetKeyName(1, L"birne.bmp");
this->imageList1->Images->SetKeyName(2, L"blume.bmp");
this->imageList1->Images->SetKeyName(3, L"blume2.bmp");
this->imageList1->Images->SetKeyName(4, L"ente.bmp");
this->imageList1->Images->SetKeyName(5, L"fisch.bmp");
this->imageList1->Images->SetKeyName(6, L"fuchs.bmp");
this->imageList1->Images->SetKeyName(7, L"igel.bmp");
this->imageList1->Images->SetKeyName(8, L"kaenguruh.bmp");
this->imageList1->Images->SetKeyName(9, L"katze.bmp");
this->imageList1->Images->SetKeyName(10, L"kuh.bmp");
this->imageList1->Images->SetKeyName(11, L"maus1.bmp");
this->imageList1->Images->SetKeyName(12, L"maus2.bmp");
this->imageList1->Images->SetKeyName(13, L"maus3.bmp");
this->imageList1->Images->SetKeyName(14, L"maus4.bmp");
this->imageList1->Images->SetKeyName(15, L"melone.bmp");
this->imageList1->Images->SetKeyName(16, L"pilz.bmp");
this->imageList1->Images->SetKeyName(17, L"ronny.bmp");
this->imageList1->Images->SetKeyName(18, L"schmetterling.bmp");
this->imageList1->Images->SetKeyName(19, L"sonne.bmp");
this->imageList1->Images->SetKeyName(20, L"wolke.bmp");
this->imageList1->Images->SetKeyName(21, L"aufgedeckt.bmp");
this->imageList1->Images->SetKeyName(22, L"verdeckt.bmp");
//
// timer1
//
this->timer1->Interval = 2000;
this->timer1->Tick += gcnew System::EventHandler(this, &Form1::timer1_Tick);
//
// labelMensch
//
this->labelMensch->AutoSize = true;
this->labelMensch->Location = System::Drawing::Point(13, 391);
this->labelMensch->Name = L"labelMensch";
this->labelMensch->Size = System::Drawing::Size(45, 13);
this->labelMensch->TabIndex = 1;
this->labelMensch->Text = L"Mensch";
//
// labelComputer
//
this->labelComputer->AutoSize = true;
this->labelComputer->Location = System::Drawing::Point(13, 415);
this->labelComputer->Name = L"labelComputer";
this->labelComputer->Size = System::Drawing::Size(52, 13);
this->labelComputer->TabIndex = 2;
this->labelComputer->Text = L"Computer";
//
// labelMenschPaar
//
this->labelMenschPaar->AutoSize = true;
this->labelMenschPaar->Location = System::Drawing::Point(71, 391);
this->labelMenschPaar->Name = L"labelMenschPaar";
this->labelMenschPaar->Size = System::Drawing::Size(13, 13);
this->labelMenschPaar->TabIndex = 3;
this->labelMenschPaar->Text = L"0";
//
// labelComputerPaar
//
this->labelComputerPaar->AutoSize = true;
this->labelComputerPaar->Location = System::Drawing::Point(71, 415);
this->labelComputerPaar->Name = L"labelComputerPaar";
this->labelComputerPaar->Size = System::Drawing::Size(13, 13);
this->labelComputerPaar->TabIndex = 4;
this->labelComputerPaar->Text = L"0";
//
// buttonAufdecken
//
this->buttonAufdecken->Location = System::Drawing::Point(342, 391);
this->buttonAufdecken->Name = L"buttonAufdecken";
this->buttonAufdecken->Size = System::Drawing::Size(75, 23);
this->buttonAufdecken->TabIndex = 6;
this->buttonAufdecken->Text = L"Aufdecken";
this->buttonAufdecken->UseVisualStyleBackColor = true;
//
// timer2
//
this->timer2->Interval = 2000;
this->timer2->Tick += gcnew System::EventHandler(this, &Form1::timer2_Tick);
//
// Form1
//
this->AutoScaleDimensions = System::Drawing::SizeF(6, 13);
this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::Font;
this->ClientSize = System::Drawing::Size(445, 440);
this->Controls->Add(this->buttonAufdecken);
this->Controls->Add(this->labelComputerPaar);
this->Controls->Add(this->labelMenschPaar);
this->Controls->Add(this->labelComputer);
this->Controls->Add(this->labelMensch);
this->Controls->Add(this->tableLayoutPanel1);
this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D;
this->MaximizeBox = false;
this->Name = L"Form1";
this->Text = L"Memory";
this->ResumeLayout(false);
this->PerformLayout();

}
#pragma endregion
void karteOeffnen (Int32 x, Int32 y){

//eine Hilfsvariable
Int32 aufTemp = 0;

//die Karte wird dem Spielfeld zugewiesen
spielfeld[x, y] = initSpielfeld[x, y];

//und in offeneKartenPos gespeichert
offeneKartenPos[offeneKarten] = Point(x, y);

//wurde das Bild bereits einmal gefunden?
if (aufgedeckt[spielfeld[x,y], 0] .X !=-1 && (aufgedeckt[spielfeld[x,y], 0] != Point(x,y)))
aufTemp = 1;

//die Position der Karte wird in aufgedeckt gepeichert
aufgedeckt [spielfeld[x,y], aufTemp] = Point(x,y);

//die Anzahl der geöffneten Karten wird erhöht
offeneKarten++;
}

void kartenSchliessen() {

//für die gefundenen Paare
Boolean treffer = false;

//wurde ein Paar gefunden?
if (initSpielfeld[offeneKartenPos[0] .X, offeneKartenPos[0] .Y] == initSpielfeld[offeneKartenPos[1] .X, offeneKartenPos[1] .Y]) {

//das Bild für eine aufgedeckte Karte setzen
spielfeld[offeneKartenPos[0] .X, offeneKartenPos[0] .Y] = 21;

spielfeld[offeneKartenPos[1] .X, offeneKartenPos[1] .Y] = 21;

//die Karten in aufgedeckt als aufgedeckt markieren
for (Int32 schleife=0; schleife<2; schleife++)

aufgedeckt[initSpielfeld[offeneKartenPos[schleife] .X, offeneKartenPos[schleife] .Y], schleife] .X=-1;

//ein Paar gut schreiben
paare[spieler]++;
treffer=true;
}

//sonst die Karten wieder zurückdrehen
else {

spielfeld[offeneKartenPos[0] .X, offeneKartenPos[0] .Y] = 22;
spielfeld[offeneKartenPos[1] .X, offeneKartenPos[1] .Y] = 22;
}

offeneKarten = 0;

//wenn das Spiel noch nicht vorbei ist, wird der Spieler neu ermittelt
if ((paare[0] + paare[1] != 21)) {

if ((spieler == 0 && treffer == false) || (spieler == 1 && treffer == true)) {

spieler = 1;

computerZug ();
}
}
}

void computerZug(){

//einige Hilfsvariabblen
Int32 x1, y1, x2, y2;

Boolean found = false;

//für einen zufällige Zahl
Random ^zufallszahl = gcnew Random();

//in aufgedeckt nachsehen, ob ein Paar gefunden wird
for (Int32 schleife=0; schleife<21; schleife++) {

if (aufgedeckt[schleife, 0] .X != -1 && aufgedeckt[schleife, 1] .X != -1) {

x1 = aufgedeckt[schleife, 0] .X;

y1 = aufgedeckt[schleife, 0] .Y;

x2 = aufgedeckt[schleife, 1] .X;

y2 = aufgedeckt[schleife, 1] .Y;

found = true;
}

}

//spielstärke des computer verringern

found = (found && zufallszahl->Next(2));

//wenn ein Paar gefunden wurde, die zweite Karte umdrehen

if (found == true)

karteOeffnen(x2,y2);

//sonst zufällige Koordinaten für eine neue Karten erzeugen

else {

do {

x1 = zufallszahl->Next(7);

y1 = zufallszahl->Next(6);
} while (spielfeld[x1,y1] != 22);

//nach dem Gegenstück der neuen Karte suchen
if (aufgedeckt[initSpielfeld[x1,y1], 0] .X != -1 && (aufgedeckt[initSpielfeld[x1, y1], 0] != Point(x1,y1)) && zufallszahl->Next(2))
karteOeffnen(aufgedeckt[initSpielfeld[x1, y1], 0] .X, aufgedeckt[initSpielfeld[x1,y1], 0] .Y);

//wenn es kein Gegenstück gibt, die zweite Karte zufällig ermitteln
else {

do {

x2 = zufallszahl->Next(7);

y2 = zufallszahl->Next(6);
} while (spielfeld[x2,y2] != 22 || (x1 == x2 && y1 == y2));

karteOeffnen(x2,y2);
}
}

//die erste Karte umdrehen
karteOeffnen(x1,y1);

//neu zeichnen und den timer starten
tableLayoutPanel1->Refresh();

timer1->Enabled=true;
}

private: System::Void tableLayoutPanel1_Paint(System::Object^ sender, System::Windows::Forms::PaintEventArgs^ e) {
}
private: System::Void tableLayoutPanel1_CellPaint(System::Object^ sender, System::Windows::Forms::TableLayoutCellPaintEventArgs^ e) {

//hier wird die Rückseite gezeichnet.
imageList1->Draw(e->Graphics, Point(e->Column*64, e->Row*64), spielfeld[e->Column, e->Row]);
}
private: System::Void tableLayoutPanel1_MouseClick(System::Object^ sender, System::Windows::Forms::MouseEventArgs^ e) {

//die Spalte ermitteln
Int32 x= e->X / 64;

//und die Zeile
Int32 y= e->Y / 64;

//wenn der Computer seinen Zug beendet hat ist der Mensch an die Rheie
if (offeneKarten == 0 && spieler == 1)

spieler = 0;

//wenn der Mensch zieht und keine Karte umgedreht ist
if (offeneKarten == 0 && spieler == 0){

// ist die Karte noch verdeckt? dann umdrehen
if (spielfeld[x, y] == 22)

karteOeffnen(x,y);
}

//wenn bereits 1 karte vom Mensch umgedreht wurde
else

if (offeneKarten == 1 && spieler == 0) {

//ist die Karte noch verdeckt? dann umdrehen un den Timer starten
if (spielfeld[x,y] == 22) {

karteOeffnen(x,y);
timer1->Enabled=true;
}
}

//die Anzeige aktualisieren
tableLayoutPanel1->Refresh();

}
private: System::Void timer1_Tick(System::Object^ sender, System::EventArgs^ e) {

//den Timer abschalten
timer1->Enabled = false;

//die Karten schließen
kartenSchliessen();

//die Treffer setzen
labelMenschPaar->Text=Convert::ToString(paare[0]);

labelComputerPaar->Text=Convert::ToString(paare[1]);

//neu zeichnen
tableLayoutPanel1->Refresh();
}

private: System::Void timer2_Tick(System::Object^ sender, System::EventArgs^ e) {

Timer2->Enabled = false;

AllesUmdrehen();

tableLayoutPanel1->Refresh();

AllesAufdecken();
???

}
};
}

ILS oder HAF?
Schulaufgaben machen wir hier nicht.
Denk mal ein wenig nach, der Dozent wird es Dir Danken.

schue04

ich denke hier ist ein Forum wo man Hilfe bekommen kann.
Wenn man schon alles alleine wüsste brauchte man keine Kurs zu machen.
Mann soll auch nicht meine Arbeit machen sondern mich nur auf den richtigen Weg bringen.
Die Dozenten helfen auch bei nachfrage eigentlich gar nicht. Ich bin mit dem Kurz bis auf dieser
Aufgabe fertig (und mal gar nicht so schlecht) trotzdem komme ich bei dieser Aufgabe nicht weiter.
Dieses Forum hat mir schon oft weiter geholfen (nicht für mich gelöst sondern geholfen!!).
Darauf hoffe ich auch jetzt.

SG1

Hilfe, ja. Das heisst aber nicht, dass hier auf Fragen ala "Hier habt ihr 'nen Batzen Code, macht mal!" geantwortet wird.

http://www.c-plusplus.net/forum/viewtopic-var-t-is-136013.html

denjo303

Bei ->ILS<- soll man aber nicht schummeln

schue04

[quote="SG1"]Hilfe, ja. Das heisst aber nicht, dass hier auf Fragen ala "Hier habt ihr 'nen Batzen Code, macht mal!" geantwortet wird.

Das ist richtig und so war das auch nicht gemeint.
Ich dachte nur das man den Code grob kennen sollte um meine Probleme zu erkennen.
Es wird sonst fast immer nach dem Code gefragt.

schue04

denjo303 schrieb:

Bei ->ILS<- soll man aber nicht schummeln

Hier geht es nicht um Schummeln sonder um Lernen.
Wenn man sowas nebenbei macht und wirklich nicht weiter kommt
ist es meiner Meinung nach nicht schlimm wenn man sich Hilfe sucht.
Von den Dozenten bekommt man leider keine.

theta

Für was ist der 2. Timer denn genau?
Soll er als Hilfe dienen? (Damit der Spieler ein Blick auf die Karten werfen kann?)

Ansonsten, siehe Kommentare im Code- Snippet.

private: System::Void timer2_Tick(System::Object^ sender, System::EventArgs^ e) { 

   timer2->Enabled = false; // Timer2 gibts nicht, nur timer2

   // AllesUmdrehen(); // Methode muss noch impl. werden

   tableLayoutPanel1->Refresh(); 

   // AllesAufdecken(); // Methode muss noch impl. werden
   // ??? 
}

Simon

Edit: Bitte auch die CPP Tags verwenden, wenn Du Code postest.

denjo303

Ich hab für die aufgabe ne glatte 1 bekommen. Heisst dein Dozent Siebeck??

Jo, meiner heißt Siebeck.
Der ist doch ober Hammer der Mann.
Haben wir überhaupt eine Chance so als nachgemachte Programmierer?

Gruß, JoJo

schue04

Ich hab für die aufgabe ne glatte 1 bekommen. Heisst dein Dozent Siebeck??

Nein, so heisst er nicht.

schue04

JoJo Lima schrieb:

Jo, meiner heißt Siebeck.
Der ist doch ober Hammer der Mann.
Haben wir überhaupt eine Chance so als nachgemachte Programmierer?

Gruß, JoJo

Hallo JoJo,

was meinst Du mit eine Chance?
In meiner Weiterbildung ist C++/CLI nur eines von viele Themen (SQL,Netzwerk usw.)
Ich würde mich niemals als Programmierer sehen wenn ich mit dem Thema fertig bin.
Und dennoch hat mir das viel gebracht, weil ich jetzt ein Grundverständnis für diese
Sache habe. Ich habe vor ca.10 Wochen ein neuen Job angefangen, denn ich wohl ohne die
Weiterbildung nicht bekommen hätte.

denjo303

Jo, meiner heißt Siebeck.
Der ist doch ober Hammer der Mann.
Haben wir überhaupt eine Chance so als nachgemachte Programmierer?

Gruß, JoJo

Herr Siebeck hat eigentlich für fast alle meine Fragen eine Antwort gehabt, und wenn nicht dann immer einen kleinen tritt in den A... der mich auf die antwort gebracht hat...

Ist das eine Job als Programmierer?
Ich verspreche mir aber durch diesen Lehrgang einen Job als Programmierer.
Meinst Du den bekommt man dadurch nicht, reicht diese Schulung nicht dafür?

Gruß, Jochen

denjo303

normalerweise nicht, um erfolgreich als programmierer zu werden solltest du noch den Informatik lehrgang und den Aufbaukurs von c++/cli belegen

schue04

JoJo Lima schrieb:

Ist das eine Job als Programmierer?
Ich verspreche mir aber durch diesen Lehrgang einen Job als Programmierer.
Meinst Du den bekommt man dadurch nicht, reicht diese Schulung nicht dafür?

Gruß, Jochen

Hallo JoJo,
nein das ist kein Job als Programmierer.
Ich muss denjo303 recht geben, wenn man das Ziel verfolgt sollte man weitere
Kurse belegen.

Außerdem möchte ich mich bei allen für die tolle Hilfe bedanken.

hallo ! hast du eventuell den richtigen Code für mich ? die erste Aufgabe mit der Ausgabe, wer gewonnen hat, war ja einfach, aber die zweite.......

habs auch so geschafft !

LauneBaer123

Ich komm mit der Schummelfunktion nicht klar, kann mir hier jemand weiterhelfen?

Theoretisch ist es ja ganz einfach aber die Methoden etc. bekomme ich nicht hin...

Danke!