Schlitzauge

Ja, wie gesagt, ditt is nur ne sehr frühe Alpha-Version von 2009. An pow() hab ich auch schon gedacht. Das Problem sind aber häufig die CPU´s. Während die eine CPU den logisch gedacht richtigen Wert in seinen Registern hat, kann das bei ner anderen CPU wieder ganz anders ausschauen. Die ersten Dezimalstellen hinterm Komma, schaffen alle gleich gut. Sobald wir aber weiter nach rechts rücken, kommt es von CPU zu CPU zu teils gravierenden Ungenauigkeiten. D.h. man muss deshalb jegliche Situationen abfangen, wenn unter jedem System und jeder CPU korrekt gerechnet werden soll. Ich sage ja nicht, dass der Code perfekt ist. ALPHA-Version sagt, denke ich schon ne ganze Menge aus. Der Code ist mitlerweile komplett umgeschrieben und wesentlich komplexer. CPU´s und Std-Libs, können schon ärgerlich sein. Jeder kocht sein eigenes Süppchen. Da ist es nicht gerade leicht, ein einheitlich und übergreifendes Framework / Lib zu schreiben, welche(s) auch überall gleich funktioniert. Grundsätzlich neige mitlerweile dazu, alles mit ganzen Zahlen umzusetzen. Rechnet sich eh schneller und eleganter. Nur bei der Konvertierung und Ausgabe, muss man dann noch aufpassen, ist aber halb so wild. Damals war ich noch nicht so weit, long double-Überläufe abzufangen, drum hab ichs so gemacht. Verzeiht mir bitte! Der obige Code funktioniert trotzdem. Lässt sich auch übersetzen. Er soll aber nicht als produktiv betrachtet werden, sondern vielmehr zeigen, in welche Richtung es gehen sollte. Ich zwinge ja auch keinen dazu, diese Grütze durchn Kompiler zu jagen. Wer es trotzdem machen möchte, muss aber noch ein bissl Hand anlegen, ist nämlich an einigen Stellen, Borland-spezifisch, z.B. vcl.h oder String. Alles andere ist sonst in jeder guten Std-Lib vertreten und ANSI-C. Aus Interesse, kannste das mal weiter erläutern? Steh gerade irgendwie aufn Schlauch. Grüße Schlitzauge :) :)

Hallo COM, ist es möglich unter Windows XP, einen VPN-IPSec-Zugang einzurichten? Eine IPSec-Verbindung herzustellen, ist nicht das Problem. Ein PC muss aber als VPN-IPSec-Server dienen. Ziel soll es sein, zwischen zwei Windows XP-Rechnern, eine sichere VPN-Verbindung über IPSec herzustellen. Ich weiß, es gibt Dritthersteller-Tools, wie den von Cisco, auch OpenSource-Tools, z.B. OpenVPN. Meine Frage bezieht sich allerdings auf Windows-eigene Bordmittel. Bitte auch keine Windows-Server als Lösung benennen. Es soll wirklich nur zwischen zwei Windows XP-Rechnern, eine VPN-IPSec-Verbindung mit Windows-eigenen Bordmitteln hergestellt werden. Ist das möglich? Wenn ja wie? THX und Grüße Schlitzauge :):)

ROFL, es ist doch wirklich ne einfache Aufgabe. Natürlich wird immer vom kleinst möglichen Netz ausgegangen, sonst bräuchte man ja kein Subnetz. Subnetze sind schließlich dazu da, mit den mitlerweile raren IPv4-Adressen sparsam umzugehen. Nunja, ich versuch einfach mal mein Gluck : Als erstes mal ein wenig Theorie: Netz: Steht immer fürs Netz. Immer direkt miteinander verbundene Hosts, gehören stets in ein Netz (Ausnahme Routing, RIPv4 und virtuelle Adapter). Hosts: Im Allgemeinen sind das die Hosts. Korrekterweise spricht man hier jedoch von den IP-Adressen, sprich also Netzwerk-Adaptern, denn auch ein Rechner / Router, kann mehrere Hosts, nämlich Netzwerkadapter haben. Man sollte also stets nicht die PC´s betrachten, sondern die zum Einsatz kommenden Netzwerkadapter (Hosts). Subnetzmaske: Trennt Netzanteil und Hostanteil voneinander bzw. kennzeichnet diese: N und n = Netzanteil H und h ) Hostanteil Netzadresse: - kennzeichnet das Subnetz - alle Hosts im Subnetz haben die gleiche Netzadresse - Bitstellen des Hostanteils = 0 Broadcastadressse - für alle Hosts im Netzwerk - Bitstellen des Hostanteils = 1 Klasse-Netze: ------------------------- KLASSE A: *Höherwertige Bits: 0 => Adressbereich des 1.Oktets (binär): 00000000-01111111 => Adressbereich des 1.Oktets (dezimal): 0-127* *Anzahl der Bits in der Netzadresse: 8 => Subnetzmaske (binär): 11111111.00000000.00000000.00000000 => Subnetzmaske (dezimal): 255 . 0 . 0 . 0 => Subnetzmaske (allgemein): NNNNNNNN.HHHHHHHH.HHHHHHHH.HHHHHHHH => Anzahl der Netze: 126 (*127 ist die Loopback-Adresse) => Anzahl der nutzbaren Hostadressen pro Netz: (2^24)-2 = 16777214 => Charakteristik der Netze: sehr große Netze *Privater Adressbereich: 10.0.0.0-10.255.255.255 KLASSE B: *Höherwertige Bits: 10 => Adressbereich des 1.Oktets (binär): 10000000-10111111 => Adressbereich des 1.Oktets (dezimal): 128-191 *Anzahl der Bits in der Netzadresse: 16 => Subnetzmaske (binär): 11111111.11111111.00000000.00000000 => Subnetzmaske (dezimal): 255 . 255 . 0 . 0 => Subnetzmaske (allgemein): NNNNNNNN.NNNNNNNN.HHHHHHHH.HHHHHHHH => Anzahl der Netze: 2^(16-2) = 2^14 = 16384 => Anzahl der nutzbaren Hostadressen pro Netz: (2^16)-2 = 65534 => Charakteristik der Netze: mittlere bis sehr große Netze *Privater Adressbereich: 172.16.0.0-172.31.255.255 KLASSE C: *Höherwertige Bits: 110 => Adressbereich des 1.Oktets (binär): 11000000-11011111 => Adressbereich des 1.Oktets (dezimal): 192-223 *Anzahl der Bits in der Netzadresse: 24 => Subnetzmaske (binär): 11111111.11111111.11111111.00000000 => Subnetzmaske (dezimal): 255 . 255 . 255 . 0 => Subnetzmaske (allgemein): NNNNNNNN.NNNNNNNN.NNNNNNNN.HHHHHHHH => Anzahl der Netze: 2^(24-3) = 2^21 = 2097152 => Anzahl der nutzbaren Hostadressen pro Netz: (2^8)-2 = 254 => Charakteristik der Netze: kleine Netze *Privater Adressbereich: 192.168.0.0-192.168.255.255 ------------------------------------------------------------------------------------- Wie man merkt, sind die typischen Klasse-Netze, für manche Situationen, viel zu viel. In einem Teilnetz von vlt. 2 oder 8 Rechnern, benötigen wir nicht diese Netze, da sonst zu viel Verschwendung von IP-Adressen. Deshalb verwendet man Subnetze, um sparsam mit IP-Adressen umzugehen. Zurück zu Aufgabe: --------------------------- Zunächst machen wir uns eine Hilfstabelle mit den 2er-Potenzen. Sie stehen stellvertretend für die Bits "2^n" und die daraus resultierende Anzahl an IP-Adressen, also Hosts: 2^0 = 1 2^1 = 2 2^2 = 4 2^3 = 8 2^4 = 16 2^5 = 32 2^6 = 64 2^7 = 128 2^8 = 256 2^9 = 512 usw. Jetzt haben wir zwei geg. IP-Adressen aus einem GLEICHEN Subnetz: Diese sollte man zur besseren Verdeutlichung, mal in die Binär-Notation auflösen: 192 . 168 . 16 . 173 -> Dezimal 11000000.10101000.00010000.10101101 -> Binär 192 . 168 . 16 . 186 -> Dezimal 11000000.10101000.00010000.10111010 -> Binär Wie man sieht, sind die ersten drei Oktets gleich, ebenso die ersten drei Bits im letzten Oktet. Wir erinnern und zurück, dass alle Hosts im Subnetz, die gleiche Netzadresse haben. D.h. für uns, dass der Teil, der Deckungsgleich ist, der Netzanteil und der Rest der Hostanteil ist: NNNNNNNN.NNNNNNNN.NNNNNNNN.nnnhhhhh Daraus folgt die Subnetzmaske: 11111111.11111111.11111111.11100000 -> Binär 255 . 255 . 255 . 224 -> Dezimal daraus folgt wiederum, dass 5 Bit für den Host-Anteil sind, also: 2^5 = 31 Host-Adressen zwei davon muss man abziehen, weil diese für die Netzadresse und die Broadcast-Adresse reserviert sind. Macht also 29 nutzbare Hosts. Wir schauen oben in die Hilfstabelle und sehen, dass für 29 Hosts, 5 Bits mehr als ausreichend sind. Eine IP-Adresse, hat stets 32-Bit, aufgeteilt in 4 Oktets. 32 Bit - 5 Bit = 27 Bit Also: die ersten 27 Bit fürs Netz und die restlichen 5 Bit für die Hosts. Aber das haben wir schon herausgefunden. Wir haben also ein 27er-Subnetz: /27 für unsere beiden vorgegebenen IP-Adressen: 192.168.16.173 /27 192.168.16.186 /27 Subnetz: 192.168.16. /27 Ob man erst das Subnetz ermittelt und dann die Subnetzmaske ist wurscht. Das eine ergibt sich aus dem anderen. Fakt ist, dass man vorher herausfinden sollte, wie viele Hosts man benötigt, wenn man selber Subnetze bilden möchte. In diesem Falle waren zwei IP-Adressen vorgegeben und lediglich ein binärer Vergleich dieser beiden hat ausgereicht, um herauszufinden, was Netz- und was Host-Anteil ist. ============================================================ Zum ermitteln der Netz-Adresse und der Broadcast-Adresse, gibt es jetzt zwei verschiedene Herangehensweisen. Da muss jeder selber wissen, wie es ihm / ihr lieber ist. 1.) Wir haben ein Subnetz: 192.168.16. /27 Da die ersten drei Oktests stets gleich sind, betrachten wir nur das letzte, da dort die Unterschiede liegen: 11000000.10101000.00010000.101xxxxx .101xxxxx .nnnhhhhh Wir wissen, dass der Hostanteil in der Netz-Adresse durch 0 gekennzeichnet ist. Die Netz-Adresse wird also wie folgt gebildet: .10100000 -> Binär .160 -> Dezimal Die Netz-Adresse ist also: 11000000.10101000.00010000.10100000 -> Binär 192 . 168 . 16 . 160 -> Dezimal Ähnlich ermittelt man nun die Broadcast-Adresse. Wir wissen auch hier, dass der Hostanteil durch 1 gekennzeichnet ist. Die Broadcast-Adresse wird also wie folgt gebildet: .10111111 -> Binär .191 -> Dezimal Die Broadcast-Adresse ist also: 11000000.10101000.00010000.10111111 -> Binär 192 . 168 . 16 . 191 -> Dezimal 2.) Diese Variante greift auf die Computer-Algebra / bool´sche Algebra zurück. Netz-Adresse: Wir nehmen uns eine der IP-Adressen und die zuvor ermittelte Subnetzmaske, stellen beide in binärer Notation dar und verknüpfen beide logisch UND (AND) miteinander: Bsp.: mit der 192.168.16.173 192 . 168 . 16 . 173 -> IP-Adresse dezimal 11000000.10101000.00010000.10101101 -> IP-Adresse binär AND 11111111.11111111.11111111.11100000 -> Subnetzmaske binär 255 . 255 . 255 . 224 -> Subnetzmaske dezimal ============================= 11000000.10101000.00010000.10100000 -> Netz-Adresse binär 192 . 168 . 16 . 160 -> Netz-Adresse dezimal Broadcast-Adresse: Hier nehmen wir uns wieder eine der geg. IP-Adressen, sowie die Subnetzmaske und stellen beide wieder in der Binär-Notation dar. Diesesmal aber, negieren (NOT) wir die Subnetzmaske (0->1;1->0) und verknüpfen anschließend die IP-Adresse mit der negierten Subnetzmaske, logisch ODER (OR) miteinander: 11111111.11111111.11111111.11100000 -> Subnetzmaske binär NOT 00000000.00000000.00000000.00011111 -> negierte Subnetzmaske binär Bsp.: mit der 192.168.16.173 192 . 168 . 16 . 173 -> IP-Adresse dezimal 11000000.10101000.00010000.10101101 -> IP-Adresse binär OR 00000000.00000000.00000000.00011111 -> negierte Subnetzmaske binär ============================= 11000000.10101000.00010000.10111111 -> Broadcast-Adresse binär 192 . 168 . 16 . 191 -> Broadcast-Adresse dezimal ============================================================ War zwar nicht gefragt, ist aber häufig bei solchen Aufgaben: Ermitteln Sie den ersten nutzbaren Host und den letzten nutzbaren Host im (Sub-)Netz! Erster nutzbarer Host: Netz-Adresse + 1 Binär 11000000.10101000.00010000.10100000 -> Netz-Adresse binär 192 . 168 . 16 . 160 -> Netz-Adresse dezimal + 00000000.00000000.00000000.00000001 ============================= 11000000.10101000.00010000.10100001 -> Erster nutzbarer Host binär 192 . 168 . 16 . 161 -> Erster nutzbarer Host dezimal Letzter nutzbarer Host: Broadcast-Adresse - 1 Binär 11000000.10101000.00010000.10111111 -> Broadcast-Adresse binär 192 . 168 . 16 . 191 -> Broadcast-Adresse dezimal - 00000000.00000000.00000000.00000001 ============================= 11000000.10101000.00010000.10111110 -> Letzter nutzbarer Host binär 192 . 168 . 16 . 190 -> Letzter nutzbarer Host dezimal Macht also einen IP-Bereich von: 192.168.16.161-192.168.16.190 190-161 = 29 Hosts ============================================================ Zusammenfassung: ================== Subnetz: 192.168.16. /27 Subnetzmaske: 255.255.255.224 Netz-Adresse: 192.168.16.160 Broadcast-Adresse: 192.168.16.191 Nutzbare Hosts: 29 IP-Bereich: 192.168.16.161-192.168.16.190 ============================================================ So, ditt wars dann auch schon. Grüße Schlitzauge :bimei:bimei:bimei:bimei

Definiere bitte "crank"? Und konstruktiv ist das auch nicht! Klischeepunk hat mir sehr weitergeholfen, also was das andere Problem in diesem Thread anbelangt. Anscheind lässt sich die eine Idee so aber nicht realisieren. Ich lass es trotzdem mal im Raum stehen. Vlt. findet sich ja jemand, der die Idee dennoch umsetzen kann. Was aber soll daran soooo crank sein, ein sinnloses Objekt, also sinnlos verbrauchten Speicher, wieder freizugeben. Ein Bruch mit Nenner 0, macht schließlich keinen Sinn. Die Möglichkeit, dass jemand einen solchen aber mal initialisieren möchte, und sei es ausversehen, oder Aufgrund einer Rechenoperation, besteht dennoch. Logische und beste Folge wäre da, dass Objekt wieder zu terminieren oder nicht? Das ganze manuell abzufangen, ginge, wiederspricht meiner Meinung nach aber den Prinzipien der Automatisierung. Man schreibt für sich und andere schließlich Bibliotheken und Frameworks, um einiges an Tipp-Arbeit zu ersparen. Ein sich selbst zerstörendes Objekt, wäre also garnicht mal CRANK. Ich bin natürlich für weitere Lösungsansätze offen. Grüße Schlitzauge :) :)

Hm, wieder was gelernt. Macht das aber einen Sinn? Etwa um Speicher zu sparen? Gibts da noch andere Anhängsel, außer "f"? Würde mich mal brennend interessieren. Grüße Schlitzauge

Ditt is ja der Witz an der Ganzen Sache. Das Objekt solle sich ja selbst zerstören, wenn man es z.B. so initialisiert CBruch(4,0); D.h. es soll dann erst garnicht weiter existieren. Einer string-Variablen, kann ich schließlich auch keinen numerischen Wert zuweisen. Das Problem hier ist nunmal aber nicht der Unterschied der Datentypen, sondern innerhalb einer Datentyps-Art, nämlich int, den Wert 0 für den Nenner zu verbieten. Das Objekt mit Nenner 0, sollte dann allerdings nicht weiter existieren, sondern terminiert werden. Ich möchte aber nicht den Programmierer die Arbeit aufzwingen, den Fehler durch eigene Ausnahmebehandlung, abzufangen. Er solle nur das Objekt anlegen und im Falle von Nenner = 0, darauf aufmerksam gemacht werden, dass dies eine ungültige Initialisierung ist und das Objekt zerstört wird. Sprich Zerstörung mit anschließender Fehlermeldung. Da scheinen Asserts wohl doch die bessere Variante zu sein. Hätt ja sein können, dass es doch sich selbst zerstörende Objekte gibt. Falls es möglich sein sollte, wäre es super, wenn mir jemand sagen könnte wie. Grüße Schlitzauge :):)

Hm, hab schon Kompiler gehabt, Borland C++Builder und VS2010 (ich weiß, sind IDE´s), da ist es schon so. Insb. bei Vergleichen scheint ein aktueller Kompiler eine 10 und 10.0 zu differenzieren. Ich kenne zumindest die obige Notationsform, wie 10.551779f nicht, sondern nur 10.551779, weil aufgrund dessen, was ich gelernt habe. Deshalb frage ich ja nochmal nach, ob das jetzt die neue Notationsempfehl ist bzw. schon immer war oder das "f" gänzlich überflüssig ist. Aber eigentlich muss ein Kompiler das schon wissen, oder wie will er sonst den Wert 10.551779 als solches übersetzen, wenn er es sonst nicht wüsste. Grüße Schlitzauge :-)

Betrifft dies nur IDE´s oder auch auf reinen Kompilerumgebungen bezogen? Ganz banal gefragt, mit obiger Lösung, würde der Kompiler bei Vorhandensein des einen Falls, z.B. WIN32, automatisch die anderen Codeschnipsel, z.B. des _MS_DOS_, überspringen, als wären es Kommentarzeilen? Kann man so Linux-optimierte UND Windows-optimierte Codes in eine Datei bringen oder ist das ganze doch nicht so einfach, wie es sich anhört? Grüße Schlitzauge :-)

zu 1 und 2.) Wie gesagt, Exceptions auszulösen, ist nicht das Problem. Gut, im Catch-Zweig den Destruktor auszulösen wäre eine Variante, vlt. auch die einzige, wie mir mittlerweile erscheint. Da werd ich wohl um asserts nicht drumherum kommen. Mich stört es halt, dass man die Ausnahmebehandlung und Zerstörung außerhalb vornehmen muss. Gibt es keine Möglichkeit, dass ein Objekt sich selber zerstören kann? zu 4.) (was es nicht gibt ): Ich weiß. Sollte nur verdeutlichen, welche Übergabeparameter ein zu erzeugendes Objekt der Klasse CBruch haben muss. Daraus herzuleiten, wie die Klasse ausschaut und aufgebaut ist, denke ich, sieht damit wohl jeder. zu 5.) (was es ebenfalls nicht gibt ): Situationsbedingt. Natürlich wird jeglicher Speicher bei Austritt aus seinem Block / Funktionsbereich, automatisiert freigegeben. Das Trifft aber nunmal nicht immer zu. Außerdem wären da ja noch dynamische Objekte, delete hin oder her. Ich möchte halt gerne eine komfortablere Möglichkeit realisieren, sprich dem Programmierer die Arbeit abnehmen, fehlerhaft erzeugte Objekte, sofort wieder zu zerstören, etc. Grüße Schlitzauge

zu 1.) Eine Exception auszulösen, ist mir schon klar. Mir geht es aber darum, dass das erzeugte Objekt, dann auch wieder restlos zerstört wird. Denn auch bei ausgelöster Exception, besteht es ja noch weiterhin. zu 2.) Kannst Du oder auch wer anders, mir ein paar gute Quellen zu asserts geben. Insb. bin ich an Asserts zur Laufzeit, als auch zur Kompilierzeit interessiert. 3.) Kann mich auch mal jemand zu Verifiy() und Assert_Valid() aufklären? Ist ja Microsoft-spezifisch. Gibts sowas auch für Nicht-Microsoft-Kompiler- bzw. OS´s? Grüße Schlitzauge :-)

Hallo COM, ich habe mal eine Frage zum Thema plattformübergreifender Programmierung. Vorweg, JA, ich weiß, was Cross-Compiler sind, aber darum geht es nicht. Bsp. ich habe zwei gleichlautende Funktionen a(); sie unterscheiden sich lediglich ein wenig in Ihrer Ausführung, machen aber dasselbe. Während die eine Funktion für Windows-Systeme gemacht ist, ist die andere für Linux-Systeme gemacht. Nun würde ich gerne, beides unter einem Hut bingen, sprich, in die gleiche Header-/Quellcode/-Lib-Datei. Wie wir wissen, kann ein Kompiler, nicht ohne Weiteres, JEDEN Linux-optimierten Code, auch unter Windows kompilieren, auch nicht umgekehrt. Z.B. gerade dann, wenn am Bsp. die Windows-a()-Funktion intern auch noch auf WinAPI-Funktionen zurückgreift. Unter Linux, kann diese dann nämlich nicht kompiliert werden (von Wine-Ersatz mal abgesehen). Ich möchte aber auch nicht zwei extra Bibliotheken schreiben, eine für Windows, eine für Linux. Gibt es die Möglichkeit / Direktiven, Code zu kapseln, zu umschließen, ähnlich wie #ifndef, etc., der dafür sorgt, dass der Kompiler in Abhängigkeit des gerade verwendeten Systems, die richtige Funktion mit kompiliert und die andere einfach überspringt? Bsp. so hier: #if_System_Win a(); #ifend #if_System_Linux a(); #ifend Ich weiß, kein funktionierender Code nach allen derzeitigen Syntaxen. Soll ja nur verdeutlichen, was ich meine. Um es nochmal kurz zu fassen, schmeiß ich einfach mal die Frage im konkreten Detail in den Raum: Kann man einem Kompiler dazu verleiten, bei bestimmten Situationen, gewisse Codeschnipsel, einfach nicht mit zu kompilieren? Quasi wie Kommentar-Zeilen zu behandeln? Wenn nicht, was gibt es für Möglichkeiten, ähnliches zu realsiieren? THX im Voraus!!! Grüße Schlitzauge :)

Hallo COM, ich habe mal eine Frage zu Klassen-Objekten. Wenn ich mir eine string-Variable anlege und ihr einen numerischen Wert zuweise, etwa so: string test = 40.5; , würde entweder a.) schon der Kompiler herummeckern oder b.) es würde eine Exception während der Laufzeit ausgeführt werden. 1.) Jetzt habe ich eine selbstgeschriebene Klasse "CBruch(int Z,int N), welche es ermöglicht, mit Brüchen zu rechnen. Wie wir aber alle wissen, gibt es keine Brüche, wie "4/0", da Division durch 0. Ich möchte etwas Derartiges realisieren, dass, wenn ich ein Klassenobjekt mit einem Nenner-Initialisierungswert 0 erzeuge, dass das Objekt sich von selbst wieder zerstört (sprich Speicher frei gibt) und ggfl. sogar eine eigene Exception auslöst. Meine Frage dazu, wie realisiert man das? Ich weiß, dass der Destruktor dazu verwendet wird, den Speicher eines Objektes bei dessen Zerstörung wieder freizugeben. Kann man denn den Desktruktor bereits im Konstruktor auslösen, sodass das Objekt erst garnicht erzeugt wird, wenn man diesem als Nenner-Variable den Wert 0 zuweisen möchte? Eine Exception auszulösen, stellt für mich jetzt nicht DAS Problem dar, sondern, wie ich dafür sorge, dass der Speicher des fehlerhaft initialisierten Wertes, automatisch wieder freigegeben wird, halt ein sich selbst zerstörendes Objekt. 2.) Gibt es auch eine Möglichkeit, den Kompiler bei einem solchen Fall, bereits daran zu hindern, zu kompilieren, am besten mit eigener Fehlermeldung für und an den Kompiler, sodass es zu einem solchen Initialisierungsfehler erst garnicht kommen kann? Ich meine das so, wie beim obigen Beispiel mit string und numerischer Wertzuweisung. Da bricht i.d.R. der Kompiler ja auch den Kompiliervorgang mit entsprechender Fehlermeldung ab. Kann man dem Kompiler denn mitteilen, dass er nicht mehr weiter kompilieren soll, wenn man ein Klassenobjekt von CBruch mit Nenner = 0, initialisieren möchte, sprich, dass dieser dann mit entsprechender Fehlermeldung abbricht. 3.) Was gibt es noch alles für Möglichkeiten, codeseitig einem Kompiler am kompilieren zu hindern? (Außer Syntax-Fehler zu provozieren!) THX schonmal im Voraus!!! Grüße Schlitzauge :)

Hi Leutz, warum alles so kompliziert? Es ist doch unnötiger Speicherverbrauch, extra für die Umwandlung, Variablen anzulegen. Für Vergleiche ginge doch auch Typecasting. Grundsätzlich ist es sowieso nicht ratsam, bei Cent-Beträgen, also Nachkommastellen, weiterhin mit dem ungenauen und von System zu System, sowie CPU zu CPU, mit FLOAT, DOUBLE, LONG DOUBLE zu rechnen, zumal dadurch nur unnötig die FPU der CPU angeworfen wird. Mit Ganzzahligen Datentypen lässt sich meines Wissens her, wesentlich einfacher und genauer rechnen. Nunja, is ja jetzt auch wurscht. Hatte selber mal diese Problematik. Ich habs dann einfach damit gelöst, dass ich mir selber eine Routine zur korrekten Rundung geschrieben hab. Funktioniert mitlerweile mit fast jeder CPU und jedem OS. Hier mal ne frühe Version meiner geschriebenen Routine: // (c) 2009 - Copyright by Kevin Erler //--------------------------------------------------------------------------- #include <vcl.h> #include <stdlib> #include <iostream> #include <stdio> #include <math> #include <float> #include <limits> #include <iomanip> #include <String> #include <sstream> using namespace std; #pragma hdrstop //--------------------------------------------------------------------------- long double LDBL_ROUNDUP(long double ld_RoundValue,int i_DecimalPlaces = 2) { int i_IF_ROUNDVALUE_NULL = 0, i_ROUNDVALUE_IS_NEGATIVE = 0; if(ld_RoundValue < 0.000000000000000000) { i_ROUNDVALUE_IS_NEGATIVE = 1; ld_RoundValue*=(-1); } if(ld_RoundValue > LDBL_MAX) { ld_RoundValue = LDBL_MAX; } else { if(ld_RoundValue < LDBL_MIN) { ld_RoundValue = LDBL_MIN; } else // ld_RoundValue >= LDBL_MIN || ld_RoundValue <= LDBL_MAX { if((ld_RoundValue == 0.0) || (ld_RoundValue == 0.00) || (ld_RoundValue == 0.000) || (ld_RoundValue == 0.0000) || (ld_RoundValue == 0.00000) || (ld_RoundValue == 0.000000) || (ld_RoundValue == 0.0000000) || (ld_RoundValue == 0.00000000) || (ld_RoundValue == 0.000000000) || (ld_RoundValue == 0.0000000000) || (ld_RoundValue == 0.00000000000) || (ld_RoundValue == 0.000000000000) || (ld_RoundValue == 0.0000000000000) || (ld_RoundValue == 0.00000000000000) || (ld_RoundValue == 0.000000000000000) || (ld_RoundValue == 0.0000000000000000) || (ld_RoundValue == 0.00000000000000000) || (ld_RoundValue == 0.000000000000000000) ) { i_IF_ROUNDVALUE_NULL = 1; } } } if(i_DecimalPlaces > LDBL_DIG) { i_DecimalPlaces = LDBL_DIG; } else { } if(i_IF_ROUNDVALUE_NULL == 0) { String s_ACCURACYNUMBER= "0."; for(int i = 0;i < LDBL_DIG;i++) { s_ACCURACYNUMBER+="5"; } // s_ACCURACYNUMBER (String) in ld_ACCURACYNUMBER (long double) konvertieren (C++-spezifisch) stringstream sstr; long double ld_ACCURACYNUMBER = 0; sstr<<s_ACCURACYNUMBER.c_str(); sstr>>ld_ACCURACYNUMBER; /*// s_ACCURACYNUMBER (String) in ld_ACCURACYNUMBER (long double) konvertieren (C-spezifisch) //char *endptr; //ld_ACCURACYNUMBER = _strtold(s_ACCURACYNUMBER.c_str(),&endptr); cout.precision(LDBL_DIG); cout << ld_ACCURACYNUMBER << endl; */ long double ld_MULTIPLIKATOR_DIVISOR = 0.000000000000000000; switch(i_DecimalPlaces) { case 0: ld_MULTIPLIKATOR_DIVISOR = 1.000000000000000000; break; case 1: ld_MULTIPLIKATOR_DIVISOR = 10.0; break; case 2: ld_MULTIPLIKATOR_DIVISOR = 100.0; break; case 3: ld_MULTIPLIKATOR_DIVISOR = 1000.0; break; case 4: ld_MULTIPLIKATOR_DIVISOR = 10000.0; break; case 5: ld_MULTIPLIKATOR_DIVISOR = 100000.0; break; case 6: ld_MULTIPLIKATOR_DIVISOR = 1000000.0; break; case 7: ld_MULTIPLIKATOR_DIVISOR = 10000000.0; break; case 8: ld_MULTIPLIKATOR_DIVISOR = 100000000.0; break; case 9: ld_MULTIPLIKATOR_DIVISOR = 1000000000.0; break; case 10: ld_MULTIPLIKATOR_DIVISOR = 10000000000.0; break; case 11: ld_MULTIPLIKATOR_DIVISOR = 100000000000.0; break; case 12: ld_MULTIPLIKATOR_DIVISOR = 1000000000000.0; break; case 13: ld_MULTIPLIKATOR_DIVISOR = 10000000000000.0; break; case 14: ld_MULTIPLIKATOR_DIVISOR = 100000000000000.0; break; case 15: ld_MULTIPLIKATOR_DIVISOR = 1000000000000000.0; break; case 16: ld_MULTIPLIKATOR_DIVISOR = 10000000000000000.0; break; case 17: ld_MULTIPLIKATOR_DIVISOR = 100000000000000000.0; break; case 18: ld_MULTIPLIKATOR_DIVISOR = 1000000000000000000.0; break; } if(i_ROUNDVALUE_IS_NEGATIVE == 1) { ld_RoundValue = (long int)((ld_RoundValue*ld_MULTIPLIKATOR_DIVISOR)+ld_ACCURACYNUMBER)/(-ld_MULTIPLIKATOR_DIVISOR); } else { ld_RoundValue = (long int)((ld_RoundValue*ld_MULTIPLIKATOR_DIVISOR)+ld_ACCURACYNUMBER)/ld_MULTIPLIKATOR_DIVISOR; } } else { if(i_IF_ROUNDVALUE_NULL == 1) { String s_RoundValue = "0"; // s_RoundValue (String) in ld_RoundValue (long double) konvertieren (C++-spezifisch) stringstream sstr; sstr<<s_RoundValue.c_str(); sstr>>ld_RoundValue; } else { } } cout.precision(LDBL_DIG); return ld_RoundValue; } #pragma argsused int main(int argc, char* argv[]) { cout << LDBL_ROUNDUP((-8.546),2) << "\n\n"; //cout.precision(LDBL_DIG); cout << "Genauigkeit in Dezimalziffern (long double): " << LDBL_DIG << "\n\n"; cout << "maximaler Gleitpunktwert (long double): " << LDBL_MAX << "\n\n"; cout << "Minimaler normalisierter Gleitpunktwert (long double): " << LDBL_MIN << "\n\n"; getchar(); return 0; } //--------------------------------------------------------------------------- Bitte nicht lachen. Schmunzel selbst noch drüber. Aber für all jene die es wissen wollen bzw. noch nicht wissen. Das Problem der Rundungsfehler ist häufig der jeweiligen Std-Bibliothek zu verschulden. Es gibt bspw. festgelegte Grenzwerte, was die Genauigkeiten und Nachkommestellen, sowie Rundungsverhalten anbelangen. Von System zu System, also OS, können diese Dinge sich signifikant unterscheiden. Ebenso ist häufiger Störfaktor die CPU, da diese unabhängig von der Software, teilweise unterschiedliche Rundungsfehler und sogar Berechnungsfehler ab bestimmten Nachkommatstellen aufweisen. Zum Glück gibts in einigen Std-Bilbiotheken, Variablen, die die notwenigen Information enthalten. Will man da eine möglichst genaue Rundung realisieren, die auf jedem System funktioniert, muss man die erforderlichen Informationen auslesen und bei der weiteren Verarbeitung mit einbeziehen. So in etwa, funktioniert zumindest meine geschriebene Routine. Aber wie gesagt, an der geposteten gibts noch einiges zu verbessern. Ist schließlich noch eine sehr frühe ALPHA-Version gewesen. Für solche einfachen Dinge, wie Geld-Beträge, würde aber die Grundformel zur Rundung und die Anwendung von Typecasting bei Vergleichen, mehr als ausreichen. Wer gerne trotzdem mit gebrochenen Zahlen rechnen möchte, kann sich ja auch eine Klasse für Brüche mit Operatorüberladung schreiben. Eine Frage hab ich allerdings noch: Was ist das für eine Schreibweise? Kenn ich noch garnicht. Ich meine die Angabe mit dem Buchstaben, hier "f" am Ende der Zahl. Ich meine, um eine Binär, Oktal oder Hexadezimalzahl als solche zu kennzeichnen, seh ich ja noch ein, aber sollte ein Kompiler nicht von selbst erkennen, um was für eine Art Zahl es sich handelt? Allein durch Kommastellen, handelt es sich doch um eine Fließkommazahl. Das müsste eigentlich auch jeder wissen, drumm verwundert mich ja diese Schreibweise. Oder gehört das mitlerweile zum guten Ton in der Programmierung? Grüße Schlitzauge :-)

Im Prinzip schon, da ich nicht die wurzel, sondern die grobe Oberfläche be/-verarbeiten möchte, nichts tiefgreifendes Und genau das wollte ich vermeiden. Ich hatte und habe auch niemals vor den Firefox neu zu schreiben, geschweigedenn zu erfinden. Ich greife bzw. möchte deshalb auf die Gecko-Engine und den Firefox zurückgreifen, da ich, eine Solide Basis mit Funktionen des Firefox und die Darstellung von Webinhalten haben würde, die zudem stetig weiterentwickelt wird. Das weiß ich auch, ich brauche diese aber für die Interpretation und Darstellung von Webinhalten/-Standards. Da gebe ich Dir und allen anderen vollkommen Recht, nur würde es einem einen leichteren Einstieg geben, zumal ich eh nur die grobe Oberfläche umgestalten und ergänzen, sowie neue Funktionen schreiben möchte. Anscheinend wäre da ein Einstieg in die PlugIN-Architektur der bessere Weg. Ich gehe mal davon aus, hier wird insb. die PlugIn-Architektur gemeint. Egal ob die allgemeine oder die PlugIn-Architektur, ich bräuchte Links, Quellen (möglichst deutschsprachig, englisch geht notfalls auch) beider betreffend. Die offiziellen Mozilla-Developer-Seiten sind meist nur für Fortgeschrittene, da ich mich aber erstmal in die Materie einarbeiten möchte und mit simplen Beispielen, wie ein Hello-World-Programm/-PlugIn oder einem Taschenrechner-PlugIn beginnen möchte, sind mir die offiziellen MozDev-Seiten zu komplex. Einsteiger-Tuts oder etwas ähnliches wären da hilfreicher, können notfalls auch englisch sein. Ich wende mich deshalb an dieses Forum, weil ich dachte, dass hier jemand schon darin Erfahrung hat und ggfl. nützliche Links, Tuts und Quellen hat, egal ob für den Einstieg oder auch für Komplexere Sachen, des Thema betreffend oder das mir jemand direkt bei der Herangehensweise helfen kann. In C/C++ habe ich mich auch in deutsche, ja auch teils englische Tut´s, Bücher und Links hineingearbeitet, doch da sind die Auswahlmöglichkeiten doch viel strukturierter und größer. Das ich früher oder später um bessere Englisch- und bessere C/C++-Kenntnisse herumkomme, ist mir schon bewusst, doch irgendwo muss es einen Anfang geben (mal abgesehen von der (Nicht-Programmier-)-Sprache. Es wäre super, wenn mir dabei jemand helfen würde, und zwar mit Fakten und wirklichen Hilfen und nicht mit Kommentaren a´la "Lern Englisch und C/C++". Google ist dabei auch nicht die Welt und Dein Freund. Vielen Dank im Voraus! Gruß Schlitzauge :)

Hallo COM, ich programmiere seit einiger Zeit ein wenig mit C/C++ und JavaScript. Jetzt würde ich mir gerne ein Programm, ähnlich einem Browser, a´la Firefox schreiben, jedoch nicht alles Aufgrund neu, z.B. die Funktionen der Browser oder die (Render)-Engines. Ich bin der Meinung, dass da andere Menschen tagtäglich für solche Sachen herumwerkeln. Ich dachte mir, dass ich als starker OpenSource-Anhänger gleich auf der / den Mozilla-Engines und dem Mozilla Firefox aufbaue und nur die Dinge dazuprogrammiere, die dann letztendlich mein Programm darstellen. Was unter der Haube steckt, sollte egal sein. Und ist es nicht so, dass man mit dem Firefox und der Gecko-Engine mehr als gut bedient ist, vor allem, wenn man ein Browser-ähnliches Programm bzw. ein Programm mit Browser-Funktionen programmieren / kreieren möchte? Das Problem ist nun, wie geht man an so etwas heran? - Welche Programme werden benötigt (z.B. Compiler) - Welche Sprachen sind gefragt (C/C++, JavaScript) - wie kann man den Firefox komplett von jeglichen Menüs und grafischen Elementen, bis auf die übliche weiße Browser-Fläche entschlacken? - gibt es gute deutschsprachige Anleitungen, Tuts, Bücher, FAQ´s bzgl. des Firefox und der Mozilla (Gecko)-Engine? - bietet Mozilla auch eine API oder etwas ähnliches an? - was wird sonst noch benötigt. Ich würde zudem gerne auch auf grafische Entwicklungsumgebungen/-Compiler zurückgreifen, z.B. Borland, VisualC etc. etc.) oder zumindest wissen, wie man auch auf nicht-grafischer Ebene Buttons, Menüs und sonstige Komponenten für den Firefox programmieren kann. Ich weiß, dass es einige englische Seiten dazu gibt, z.B. die offiziellen der Mozilla-Foundation, nur bräuchte ich gerne deutschsprachige Quellen und Kontaktmöglichkeiten. Es heißt ja immer, dass jeder an OpenSource-Projekten mitarbeiten kann. Darum frage ich, ob irgendjemand darin schon Erfahrung hat und mir nützliche Anleitungen, Einführungen und Links / Quellen geben kann (möglichst deutschsprachige. Ich habe mir das so vorgestellt, dass ich direkt auf dem Firefox aufbaue. Zu Beginn möchte ich den Firefox von all seinen Menüs, Buttons und sonstiges grafischen Elementen entschlacken (also sichtbar), sodass ich am Ende nur die Weiße Fläche habe, wo üblicherweise Webinhalte dargestellt werden. Dann möchte ich jegliche grafische Elemente neu kreieren (und ggfl. mit den Funktionen der üblichen Verknüpfen) und platzieren, also ein eigenes Design (nicht nur Theme betreffend) erzeugen (dazu wäre eine Auflistung an Funktion(saufrufen) sehr hilfreich) und letztendlich möchte ich noch die dahinterliegenden Funkionen (sofern diese Mozilla nicht schon mitbringt) programmieren und anwenden. Alles soll dann als eine Art oder genau als zusätzliches Firefox-Profil angeboten werden. Was wird nun alles benötigt und wie muss man weiter verfahren, denn wirkliche (deutschsprachige) Anleitungen, Beispiele und Einführungen konnte ich bisher vergebens finden. Wie schon gesagt, wenn wer Erfahrungen diesbzgl. hat, kann / soll sich doch bitte melden. Mit freundlichen Gruß Schlitzauge:):):)