Habe heute mein kleines Programm fertig gestellt welches ein Koordinaten System nach Maßgabe anfertig, die zwei beliebigen Punkte einzeichnet - und dessen Entfernung berechnet.

Was ich gerne von euch hätte

1. Eine Bewertung des Codes - Aber die Nette Art wie z.b. Verbesserungsvorschläge - keine Anprangerungen, bin Anfänger.
2. Potenzial des Programmes (Habe so an simple Grafikprogrammierung im Rahmen von DOS gedacht, was könnte ich mit der Graphensystematik vll. zeichnen lassen? Vll. Sogar eine kleine Grafikengine für ein DOS Game?

Hier der Code (Visual Studio 2010 Express Nutzung!)

/*########################################################
Graph TryOut
########################################################*/

#include "stdafx.h"
#include "math.h"

using namespace System;

void draw_Graph(Int32 x, Int32 y);

int main(array<System::String ^> ^args)
{
	Int32 x = 10;
	Int32 y = 10;

	// Get input coordinate system draw
	Console::Write("Bitte Geben Sie eine Zahl für Achse x ein: ");
	x = Convert::ToInt32(Console::ReadLine());
	Console::Write("Bitte Geben Sie eine Zahl für Achse y ein: ");
	y = Convert::ToInt32(Console::ReadLine());
	Console::Write("\n");

	draw_Graph(x,y);

	Console::ReadKey();

	return 0;
}

void draw_Graph(Int32 x_length, Int32 y_length)
{
	// set draw multiplier (for better visual result)
	x_length *= 3;
	y_length *= 2;

	// declare P1, P2
	Single P1_x, P1_y, P2_x, P2_y;

	// Get input for P1
	do {
		Console::Write("Bitte geben Sie für P1 die Koordinate x ein: ");
		P1_x = Convert::ToInt32(Console::ReadLine());
		Console::Write("Bitte geben Sie für P1 die Koordinate y ein: ");
		P1_y = Convert::ToInt32(Console::ReadLine());
		Console::Write("\n");
		if(P1_x > x_length/3 || P1_y > y_length/2)
			Console::Write("Die Koordinaten dürfen nicht größer als die Systemlimits sein!\n");
	}while(P1_x > x_length/3 || P1_y > y_length/2);

	// Get input for P2
	do {
		Console::Write("Bitte geben Sie für P2 die Koordinate x ein: ");
		P2_x = Convert::ToInt32(Console::ReadLine());
		Console::Write("Bitte geben Sie für P2 die Koordinate y ein: ");
		P2_y = Convert::ToInt32(Console::ReadLine());
		Console::Write("\n");
		if(P2_x > x_length/3 || P2_y > y_length/2)
			Console::Write("Die Koordinaten dürfen nicht größer als die Systemlimits sein!\n");
	}while(P2_x > x_length/3 || P2_y > y_length/2);

	// Output P1 & P2
	Console::Write("\tP1 ({0}|{1})   P2 ({2}|{3})", P1_x, P1_y, P2_x, P2_y);
	Console::Write("\n");

	// set UNICODE symbols
	wchar_t x_achse_draw = L'\u2500';
	wchar_t x_achse_punkt = L'\u252C';
	wchar_t y_achse_punkt = L'\u2524';
	wchar_t y_achse_draw = L'\u2502';
	wchar_t y_corner_draw = L'\u2514';

	// Y-Axis Draw
	for(Int32 count_y = y_length; count_y >= 0; count_y--)
	{
		if(count_y == 0)
			Console::Write("{0}",y_corner_draw);
		else if(count_y % 2 == 0)
			Console::Write("{0}",y_achse_punkt);
		else if(count_y > 0)
			Console::Write("{0}",y_achse_draw);

		// Draw P1 & P2 into system

		Single z = count_y; // Übergangslösung !! count_y sollte von Anfang an floating-point value sein !
		Boolean flag_line = false;	// flag damit er die von der x-Achse benutzte Iteration von der neuen abzieht ->
									// Problem wäre ansonsten die Vermehrung der Abstände !

		// Draw P1
		if(z/2.0f == P1_y)
		{
			for(Int32 i = 0; i <= P1_x*3;i++)
				if(i == P1_x*3)
					Console::Write("x");
				else
					Console::Write(" ");
			flag_line = true;
		}

		// Draw P2
		if(!((P1_x == P2_x) && (P1_y == P2_y))) // Falls die Punkte gleich sind - zeichne P2 nicht, da ein Punkt ja ausreicht ;)
		{
			if(z/2.0f == P2_y)
			{
				Int32 i = 0;	
				if(flag_line)
					i = P1_x*3;	// Addiere die schon geschehene Iteration von P1_x damit die 
								// Iteration bei P2_x nicht neu beginnt sonder bei P1_x anschließt

				for(; i <= P2_x*3;i++)
					if(i == P2_x*3)
						Console::Write("x");
					else
						Console::Write(" ");
			}
		}

		if(count_y > 0)
			Console::Write("\n");
	}

	// X-Axis Draw
	for(Int32 count_x = 0; count_x <= x_length; count_x++)
	{
		if(count_x == 0)
			Console::Write("{0}",x_achse_draw);
		else if(count_x % 3 == 0)
			Console::Write("{0}",x_achse_punkt);
		else if(count_x < x_length)
			Console::Write("{0}",x_achse_draw);
	}

	// Calculate distance between P1 and P2

	Single a = 0;
	Single b = 0;
	Single c = 0;

	// Being sure the number is positive - because I don't want to calculate with minus numbers :P
	a = (P1_y - P2_y);
	if(a < 0)
		a *= -1;
	b = (P1_x - P2_x);
	if(b < 0)
		b *= -1;

	c = (pow(a,2)) + (pow(b,2));

	c = sqrt(c);

	Console::Write("\n\nDer Abstand zwischen P1 and P2 beträgt: {0:G2}",c);
}

Entschuldigt den Wechsel zwischen Deutsch und Englisch - Ich vergessen manchmal auf welcher Basis ich kommentiere

gruß Charlie und danke für die Hilfe !

1. Eine Bewertung des Codes - Aber die Nette Art wie z.b. Verbesserungsvorschläge - keine Anprangerungen, bin Anfänger.

Unwissenheit schützt vor Strafe nicht Das ist kein C++. Das ist eine übliche Mischung aus C++/CLI und C++. Macht so überhaupt keinen Sinn. Allein schon C++/CLI an sich macht keinen Sinn und ist nur als Bridge Code zwischen Native und .NET gedacht. Wenn du .NET machen willst, mach C#, wenn du C++ machen willst, mach C++. Hol dir dazu aber ein gutes Buch und fang nicht einfach drauf los an.

Falke88 schrieb:

2. Potenzial des Programmes (Habe so an simple Grafikprogrammierung im Rahmen von DOS gedacht, was könnte ich mit der Graphensystematik vll. zeichnen lassen? Vll. Sogar eine kleine Grafikengine für ein DOS Game?

Finde ich jetzt uninteressant. Die Möglichkeiten wären sehr eingeschränkt und wen interessiert Konsolengrafik noch? Wenn du C# machst, kannst du ziemlich problemlos richtige GUI Programme schreiben. Mit C++ und Qt eigentlich auch, aber Anfängern würde ich davon abraten, weil sie sich zu sehr auf GUI konzentrieren und schlechtes/falsches C++ lernen. Auf jeden Fall könntest du das dann evtl. so ein bisschen Richtung gnuplot ausbauen, wenn dich das interessiert.

// Calculate distance between P1 and P2

	Single a = 0;
	Single b = 0;
	Single c = 0;

	// Being sure the number is positive - because I don't want to calculate with minus numbers :P
	a = (P1_y - P2_y);
	if(a < 0)
		a *= -1;
	b = (P1_x - P2_x);
	if(b < 0)
		b *= -1;

	c = (pow(a,2)) + (pow(b,2));

	c = sqrt(c);

    Console::Write("\n\nDer Abstand zwischen P1 and P2 beträgt: {0:G2}",c);
}

// Calculate distance between P1 and P2
//Kommentar ist hier nur deshalb nötig, weil die Berechnung nicht in eine Funktion 
//mit sprechendem Namen ausgelagert wurde. 
	Single a = 0;//=0 ist unsinnig. Und zwar passiert das, weil a zu früh 
//definiert wurde. 
	Single b = 0;//dito
	Single c = 0;//dito
//Normalerweise auf double rechnen, außer es gibt gute Gründe dagegen. 

	// Being sure the number is positive - because I don't want to calculate with minus numbers :P
//mathematisch nicht notwendig, es wird danach eh quadriert. 
	a = (P1_y - P2_y);//ungewöhnliche klammer
	if(a < 0)
		a *= -1;//unäres minus wäre üblicher, a=-a;
//oder den ganzen Code ersetzen durch a=abs(P1_y-P2_y);
//oder besser negative Vorzeichen zulassen
	b = (P1_x - P2_x);
	if(b < 0)
		b *= -1;
//c hat
	c = (pow(a,2)) + (pow(b,2));
//2 unterschiedliche Bedeutungen!!!
//gleich schreiben c=sqrt(a*a+b*b)
	c = sqrt(c);

    Console::Write("\n\nDer Abstand zwischen P1 and P2 beträgt: {0:G2}",c);
}

Oder eine passende Funktion selber schreiben, recht üblich wäre

double berechneHypothenuse(double a,double b){
   return sqrt(a*a+b*b);
}
...
// Calculate distance between P1 and P2
    double c = berechneHypothenuse(P1_x-P2_x,P1_y-P2_y);
    Console::Write("\n\nDer Abstand zwischen P1 and P2 beträgt: {0:G2}",c);

Manche Sprachen haben auch sowas wie eine Funktion hypoth, _hypoth, hypoth2 oder so.

Ja richtig, dass hätte ich in eine Funktion batzen können, war ich mir aber dann doch zu Schade zu, da der Code für mich eh zuende wäre. Bei Erweiterungen hätte ich das vll. noch in Betracht gezogen.

Unäres - !!

Top Tip, Habe ganz vergessen das es relativ simpel ist das Vorzeichen auf diese Weise zu ändern. War zu sehr im Mathe Fokus.

Ja auch bei c hab ich ein wenig dumm gedacht

@Mechanics

Inwiefern lerne ich denn bei .NET C++ Schwachsinn? Bis jetzt viel mir lediglich auf das Console::Write und ::Read und einige andere einfache Klassen sind die ähnlich sind die cout...ok vll. nicht so flexibel, aber dann kann ich auch sagen cout ist nicht so flexibel wie printf und gehe komplett zu C zurück?
Int32 sind variable Namen für Long bzw. vll. noch int, ich hab die Wertebereiche nicht im Kopf gerade.

Am Grundaufbau ändert sich hier doch nix? Spätestens wenn ich Objektorientiert mit Klassen arbeite ist es doch nicht großartig wichtig ob es C++ mit oder ohne .NET ist oder verändert sich die Syntax da so maßgeblich das ich garnicht mehr mit purem C++ zurechtkäme?

Hier mal eine Auflistung der Themen die ich durchnehmen werde:

Programmaufbau, Variablen, Konstanten, Datentypen und Operatoren
Logische Operatoren und Vergleichsoperatoren
Lokale und globale Variablen
Dynamische Speicherverwaltung
Einführung in die objektorientierte Programmierung
Fortgeschrittene Techniken bei der objektorientierten Programmierung
Erste Schritte mit Windows Forms
Ein Bildbetrachter
Ein Webbrowser
Ein Memory-Spiel
Fehlersuche und Ausnahmebehandlung
Grundlagen der Grafikprogrammierung
Pong - Ein Computerspiel
Arbeiten mit der Registrierung und XML-Dateien
Arbeiten mit Dateien
Datenbankprogrammierung
Generics und Listenstrukturen, Delegaten
Referenz

Bist leider nicht der Erste und auch nicht der Letzte, der auf diesen Unsinn reinfällt. Ist das der IDS-Abzockerkurs für ein kleines Vermögen? Tja...

Inwiefern lerne ich denn bei .NET C++ Schwachsinn? Bis jetzt viel mir lediglich auf das Console::Write und ::Read und einige andere einfache Klassen sind die ähnlich sind die cout...ok vll. nicht so flexibel, aber dann kann ich auch sagen cout ist nicht so flexibel wie printf und gehe komplett zu C zurück?

Gute Einstellung. Wenn der Kurs Dir das Programmieren beibringt, ist alles in Butter.