Folgende Warnungen sind aufgetreten:
Warning [2] unserialize(): Error at offset 2711 of 2829 bytes - Line: 2627 - File: inc/functions.php PHP 8.3.4 (Linux)
File Line Function
/inc/class_error.php 153 errorHandler->error
[PHP] errorHandler->error_callback
/inc/functions.php 2627 unserialize
/inc/class_datacache.php 138 native_unserialize
/inc/init.php 182 datacache->cache
/global.php 20 require_once
/showthread.php 28 require_once
Warning [2] unserialize(): Error at offset 1195 of 1968 bytes - Line: 2627 - File: inc/functions.php PHP 8.3.4 (Linux)
File Line Function
/inc/class_error.php 153 errorHandler->error
[PHP] errorHandler->error_callback
/inc/functions.php 2627 unserialize
/inc/class_datacache.php 138 native_unserialize
/inc/init.php 182 datacache->cache
/global.php 20 require_once
/showthread.php 28 require_once




Themabewertung:
  • 0 Bewertung(en) - 0 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Programmieren
#11
C++ ist ein erweitertes C, also einige neue Operatoren (new, delete z.b.), neue Klassenbibliotheken und eben Objektorientierung, wobei die auch schon mit C zu Teilen möglich war.

C++ ist genauso High oder Lowlevel wie C, weil C++ alle Befehle von C enthält, auch von der Geschwindigkeit nehmen sich beide nichts.
C wurde entworfen, um Effizient zu sein. Zum Nachteil davon tendiert die Fehlererkennung des Compilers gegen Null. Die meisten Fehler kriegt man deshalb nicht mit.

Es ist ohne Probleme möglich,in einen Speicherbereich zu schreiben, den man nicht reserviert hat, genauso wie man einen auslesen kann, der per delete vorher schon gelöscht wurde.



Java und Consorten sind eben interpretierte Sprachen, damit einfacher an verschiedene Plattformen anpassbar. Dafür ist man auf diesen sehr eingeschränkt, man hat z.b. keinen direkten Zugriff auf das System.

Zitat:Also um mit C++ unabhängig und ohne ein Betriebssystem zu programmieren, funktioniert das nur, wenn man mit C eine Art Basis legt?

Den Unterschied machen interpretierte und compilerte Sprachen.
Java und C# werden zuerst in eine Art Zwischencode übersetzt.
Dieser wird dann mit der VM(virtuelle Maschine) in Maschinensprache übersetzt.
Man brauch also einfach nur eine VM für jedes Betriebssystem bzw. Rechnerarchitektur und ist erstmal ausm Schneider.

(Assembler -und Maschinensprache kann man synonym verwenden, Assemblercode ist nur lesbar gemachter Maschinensprache, da sich reine Folgen von 0 und 1 von Menschen nicht wirklich gut lesen lassen).

Compilierte Sprache dagegen übersetzen direkt in eine Maschinensprache, ohne den Zwischenweg über eine VM. Das ist natürlich schneller, weil eine VM Software ist, und damit langsamer als Hardware.
Derselbe C(++)-Quellcode, den man für Windows compiliert hat, ist theoretisch auch auf Linux lauffähig.
Was einem den Strich durch die Rechnung macht ist das Betriebsystem.

Die Positionen, wo und wie das OS Daten ablegt, z.b. die Uhrzeit, oder eine Schnittstelle auf das Window-System oder für die Datenstreams unterscheiden sich.

Sowas kann man umgehen, indem man Plattformübergreifende Frameworks benutzt, z.b. QT.

Anpassungen muss man dann allerdings immernoch vornehmen, z.b. bei der Arbeit mit Dateien, oder wenn man tiefer ins System will, z.b. auf Netzwerkfunktionen zugreift.

Das das geht zeigen ja z.b. GIMP, Firefox und consorten.


Edit:
Eventuell sollte man ja hieraus ein Allgemeines Programmieren Thema machen, oder nicht?
Glaube keiner Studie, die du nicht selbst finanziert hast!
Zitieren
#12
Zitat:Wenn du mit Java anfängst, bleib bei Java, wenn du mit C# anfängst, bleib da bei.
Ich hatte nicht vor, zu wechseln. Ich habe angefangen Java zu lernen und ich werde bevor ich eine neue lerne, erstmal Java weitestgehend "meistern".

zu openbook: Ich hatte bei den Beispielen Probleme, weil ich ja von String zu einem primitiven Datentypen transferien wollte, aber in die Beispiele, nur die Objekte der primitiven Datentypen gezeigt haben und ich nicht wusste ob man es auch auf den String übertragen kann.
Jetzt ist es aber geklärt.
Hinauf, hinauf zum Schloss!
Zitieren
#13
Dann mach es aber auch so: Lerne die Sprache von dir aus und bringe das Wissen im Unterricht ein und nicht umgekehrt. Also nicht den Unterricht nutzen um von da aus weiter zu lernen.
So hab ich es mal versucht, ist schief gelaufen.

Dann hab ich mir C# gesucht und da hatte ich keine andere Wahl, also alleine aus zu kommen und das ist auch gut so, denn anders lernt niemand eine Programmiersprache.

Die Bücher bieten nur das Grundwissen und alles Sprach-Spezifische, sowie ein paar besonders wichtige Beispiele.

Beim Net-Framework von C# und dem Buch ist das genau so. Im Buch steht alles, nur nicht die Klassen. Natürlich stehen auch davon ein paar im Buch, wie die Auflistungen und verschiedene Varianten, weil die einfach extrem wichtig sind, aber das Wissen über das Net-Framework, mit dem ich am Ende arbeite, das muss ich mir selber und mit Google erarbeiten.


Was ich sagen will:
Was im Buch steht, wird dir nicht überall helfen. Nimm das Wissen aus dem Buch, verstehe es, nutze es und schließe auf Neues. Wenn du das Prinzip verstanden hast, wirst du auch wissen, wonach du suchen musst. Du wirst so nicht alles finden, aber dafür gibts ja Foren^^

@era:

Cool, danke Lachen

Ja, wär super, so ein Programmier-Thread.
Hab ich vor einer Weile, vor meiner langen Innaktiv-Zeit, mal versucht, ist nur nie was draus geworden.

Aber was Programmierung und Computer-Technik angeht, bin ich ein Fass ohne Boden, will alles wissen Lachen
Pessimisten sind realistisch.
Optimisten sind glücklich.

Programmieren ist einfach, jeder kann es lernen.
Doch gut programmieren, das ist die Kunst.
Zitieren
#14
Zu dem selbst erarbeiten ...
da ich wegen Bundesjugendspielen der Grundschulen bei uns oft im Unterricht gefehlt hab, musste ich das alles selbst nachholen. Von Methoden/Methodenaufrufen bis zu Arrays/mehrdimensionalen Arrays und der Ãœbergabe von Arrays.
Dabei hab ich festgestellt, dass es viel mehr, als nur den Unterricht braucht um fortschreiten zu können. Deswegen habe ich mit einem anderen aus der Klasse angefangen uns viele Sachen selbst zu erarbeiten.
(als wir bei den Wrapper-Klassen beide zu doof waren, hab ich hier nachgefragt. Ist doch jetzt ein schöner Thread rund ums programmieren geworden :p)

Falls wieder mal Probleme bei meinem "Studium" auftreten, probiere ich die Lösung wieder selbst zu finden und frage erst wieder nach wenn ich verzweifelt bin Zwinker

Zudem habe ich über Java speziell noch eine Seite mit vielen kleinen Details und Zusatzinfos gefunden, habe aber den Link nicht parat, weil ich die Seite nicht wieder finde -.-
Hinauf, hinauf zum Schloss!
Zitieren
#15
Ja, Programmieren geht halt nicht so einfach^^

Die Wrapper-Klassen sind eigentlich ganz einfach, man muss aber verstanden haben, wie das absolute Grundprinzip der objektorientierten Programmierung funktioniert.

Weiß nicht, wann das im Buch kommt, aber wenn es erst später kommt, lest doch beide erst mal bis dahin und das dann durch und blättert danach zurück. Ich hatte den Vorteil, dass ich das so schon kannte und irgendwie sogar bei Batch von alleine versucht hab, im Grundprinzip der OOP zu programmieren^^ Ich grandios schief gelaufen, aber ich hatte zumindest keine Verständnisprobleme und das ist wirklich das schwerste. Alles danach lässt sich immer irgendwie zusammen frickeln.



Und jaa, cooler Thread Lachen
Aber ich denke, wenn ich ne Frage hab, verzieh ich mich lieber auf professionelle C#-Foren.
Oder kann mir hier einer sagen, wie ich aus dem simplen Namen einer Klasse auf den Typ schließen kann?
Hab die passenden Methoden, wie ich den, im Code eingegebenen, Namen von Objekten und Methoden heraus finden kann, aber ich schaffe es nicht umgekehrt. Könnte so die Methoden speichern, die ich der Delegaten-Eigenschaft eines Objektes übergeben habe.
(Zur Info: Delegaten sind Datentypen, die eine Methode enthalten können. Ich kann also eine komplette Methode in eine Variable speichern und von dort aus auch nutzen. Wenn der Nutzer also eine Methode auswählt und die in einer Klasse immer bei einer bestimmten Aktion ausgeführt werden soll, geht das nur, solange er das Programm nicht beendet. Ich könnte das dann speichern, indem ich Klasse und Methoden als Text schreibe und anschließend aus dem Text wieder auf die Klasse und die Methode schließe.)
Ist ein kompliziertes Thema, das ich aus reinem Spaß an der Sache angeschnitten habe, aber jetzt weiß ich, dass, wenn es funktioniert, ich damit absolut alle Türen der Daten-Speicherung offen habe. ^^
Pessimisten sind realistisch.
Optimisten sind glücklich.

Programmieren ist einfach, jeder kann es lernen.
Doch gut programmieren, das ist die Kunst.
Zitieren
#16
Das mit den Delegaten hört sich interessant an Zwinker
Methoden als Variablen speichern, ermöglicht viel bessere Methoden der Nutzung (z.b. einfaches Einbinden in einen Algorithmus, wenn ich das soweit richtig verstanden hab)
aber wie werden dann bei dem Methodenaufruf die Parameter übergeben ? Kannste mal ein Beispiel geben, wie so eine Methode als Variable aussieht ?

Ich werd mal schauen, wie es bei Java aussieht :

bei Java gibt es keine Delegate, sondern sogenannte interfaces ...
ein kleines Beispiel aus dem Java-forum :

Zitat://statt "delegate" einfach "interface" davorschreiben
public interface Delegate {
int call(int x);
}

//test
public class _{
public static void main(String[] args){
Delegate f=new Delegate(){ public int call(int x){ return x*x; } };
Delegate g=new Delegate(){ public int call(int x){ return 7*x+x*x*x; } };

Delegate[] delegates={f,g};
for(Delegate x:delegates){
System.out.println(x.call(5));
}
}
}
Hinauf, hinauf zum Schloss!
Zitieren
#17
Ein Interface ist in C# was ganz anderes. Da ist das eine, ich sag mal extrem abgespeckte Klasse.
Sie enthält keinen Programm-Code, nur die Methoden, Konstruktoren, Eigenschaften und Attribut und stellt damit sicher, dass eine Klasse, die von diesem Interface erbt, auch ganz sicher diese Elemente enthält.

das hängt jetzt wieder mit der Polimorphie zusammen, deshalb erkläre ich das jetzt nicht ausführlich.



Also Delegaten-Beispiel:

Code:
namespace Namensraum
{
    public delegate double CalculateHandler(double FirstNumber, double SecondNumber);

    static class Rechnen
    {
        static void Main()
        {
            CalculateHandler calculate = new CalculateHandler(Plus);

            double Ergebnis = calculate(5, 7);

            Console.WriteLine(Ergebnis);
            Console.Read();
        }


        static double Plus(double Summand1, double Summand2)
        {
            return Summand1 + Summand2;
        }
    }
}

Es muss zu erst ein MethodenHandler als Typ definiert werden. Da sind auch alle nötigen Infos drin, nämlich Rückgabewert und die Parameter.
Dann kannst du ganz normal eine Variable vom Typ des Delegaten machen und diese Variable dann wie eine Methode aufrufen.

Damit werden meistens Events gelöst, das heißt, es wird in einer Klasse ein Event (Ereignis) ausgelöst. Die Variable des entsprechenden Delegaten wird also auf gerufen. Wenn der Nutzer eine Methode darin gekapselt hat, wird die ausgeführt. Wenn nicht, passiert gar nichts. Das gibt dem Nutzer die Möglichkeit, auf bestimmte Dinge direkt reagieren zu können und die Forms-Programmierung (Windows-Fenster) wäre ohne Events gar nicht möglich, da jeder Mucks mit einem Event bearbeitet werden kann, oder einfach nur ein Button-Click.



Hab aber noch was interessanteres:
Man kann ja Methoden überladen. Einfach zwei Methoden mit dem selben Namen, aber unterschiedlichen Parametern. Sie wird dann nur einmal aufgeführt, akzeptiert aber verschiedene Kombinationen von Parametern.
Das geht auch mit Operatoren.
Der Operator == gibt ja zurück, ob zwei Werte/Referenzen gleich sind, oder nicht.
Man kann diesen Operator auch überschreiben und dann z.B. genau sagen, wie die beiden Werte/Referenzen gleich sind.
Bei Werten wäre das sinnlos, aber da zwei verschiedene Referenzen niemals gleich sind, aber gleiche Eigenschaften haben können, könnte man spezielle Eigenschaften von dem ==-Operator vergleichen lassen und bekommt das richtige Ergebnis.
Zur Erklärung des Beispiels oben:

Das Programm beginnt immer bei Main.
Und "Console" ist die Klasse, die die einfache Windows-Konsole darstellt. WriteLine schreibt ne Zeile und Read liest ein Zeichen, allerdings nutze ich es hier nur zum Warten.


Hier mal ein Beispiel, wie ich den Operator + überlade:

Code:
public class Werte
    {
        public double Wert { get; set; }

        public Werte(double Wert)
        {
            this.Wert = Wert;
        }

        public static double operator +(Werte Wert1, Werte Wert2)
        {
            return Wert1.Wert + Wert2.Wert;
        }
    }

    public class Rechnen
    {
        static void Main()
        {
            Werte w1 = new Werte(5);
            Werte w2 = new Werte(7);

            Console.WriteLine(w1 + w2);

            Console.Read();
        }
    }

Wenn ich in der Klasse Werte die Operator-Überladung weg gelassen hätte, würde ich einen Fehler in der Main-Methode bekommen, da man zwei Referenzen nicht addieren kann.

Das Thema ist recht besucht, kein Grund also, nach 4 Stunden einen Doppelpost zu machen Zwinker // Acuros
Pessimisten sind realistisch.
Optimisten sind glücklich.

Programmieren ist einfach, jeder kann es lernen.
Doch gut programmieren, das ist die Kunst.
Zitieren


Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste