---- JAVA -----
Items Time Durchschnitt
100000 31 15.34
200000 78 7.19
300000 110 4.67
400000 141 3.75
500000 187 2.95
600000 235 3.01
700000 250 2.12
800000 297 1.41
900000 343 1.35
1000000 390 1.85

---- C++ -------
Anzahl Zeit
100000 31 (12)
200000 78 (7)
300000 125 (4)
400000 172 (3)
500000 219 (3)
600000 265 (2)
700000 297 (1)
800000 359 (1)
900000 407 (1)
1000000 484 (1)

Ich hab selbstverständlicherweise keinerlei Statusmeldungen dazwischen und auch sonst nichts im Quicksortcode was irgendwie alles verlangsamen würde überzeugt euch selbst...

void CInfoQuickBubbleDlg::OnStarten() 
{
	long zeit_vor,zeit_nach;

	m_b_cancel.EnableWindow(false);
	m_b_ok.EnableWindow(false);

	m_Text = "Anzahl\tZeit";
	long i=100000;
	long* Array;
	while(i<=1000000){
	//while(i<100){
		Array = new long[i];
		Inf_Fuellen(Array,i);
		zeit_vor = GetTickCount();
		Inf_QuickSort(Array,0,i);
		zeit_nach = GetTickCount();
		m_Text += CString(13)+CString(10)+ConvertToCString(i) + "\t" + ConvertToCString(zeit_nach - zeit_vor) + "\t ("+Inf_DurchschnittFirst100(Array) + ")";
		UpdateData(false);
		//MessageBox("","",0);
		i = i + 100000;

	}

	m_b_cancel.EnableWindow(true);
	m_b_ok.EnableWindow(true);
}
void CInfoQuickBubbleDlg::Inf_Fuellen(long* buffer,long number)
{
	srand((unsigned)(time(NULL))); 
	for(long i=0;i<=number;i++)
	{
		long zufall =  rand(); 
		buffer[i]=zufall;
		//m_Text += ConvertToCString(buffer[i])+CString(13)+CString(10);
	}
}
CInfoQuickBubbleDlg::Inf_QuickSort(long* buffer,long unten,long number)
{
	if(number>unten){
      long li = unten, re = number;
      long VElement = buffer[(unten + number) / 2];  // Vergleichselement bestimmen
	  while (li <= re) {
        // Erstes Element suchen, das größer oder gleich dem
        // Vergleichselement ist, beginnend vom linken Index
        while (li < number && buffer[li] < VElement) //
          ++li;

        // Element suchen, das kleiner oder gleich dem
        // Vergleichselement ist, beginnend vom rechten Index
        while (re > unten && buffer[re] > VElement)  //
          --re;

        // Wenn Indizes nicht gekreuzt und nicht gleich --> Inhalte vertauschen
        if (li < re)
            Inf_Austausch(buffer, li, re);
        // Wenn Indizes nicht gekreuzt --> eine Position weitersetzen
        if (li <= re) {
          ++li;    --re;
        }
      }
	Inf_QuickSort(buffer,  unten, re);
	Inf_QuickSort(buffer, li, number);
	}
}
CInfoQuickBubbleDlg::Inf_Austausch(long* buffer,long first, long second)
{
	long buffered=0;
	buffered = buffer[first];
	buffer[first]=buffer[second];
	buffer[second] = buffered;
}

CString CInfoQuickBubbleDlg::ConvertToCString(long zahl)
{
    CString zahlCS; 
    zahlCS.Format("%i",zahl); 
    return zahlCS; 
}

CString CInfoQuickBubbleDlg::Inf_DurchschnittFirst100(long* buffer)
{
	double var=0;
	for(int i=0;i<100;i++)
		var=var+buffer[i];
	return ConvertToCString(var/100);
}

dummer-/seltsammerweise kann ich das ganze nicht in freier wildbahn also nicht ohne VC++ Entwicklungsumgebung starten(bzw nach 400000 gibts nen speicherzugriffsfehler), obwohl dort beide Versionen Release und Debug laufen.

wär schön wenn mir wer sagen könnte was ich beim code nicht effizient genug geschrieben hab oder warum java schneller is ...

interessant für mich so nebenbei wär auch noch warum der durchschnitt der ersten 100 zahlen so variiert obwohl der code der gleiche ist ....

import java.awt.event.*;
import java.io.*;
import re.*;
// packet vom lehrer das fenster und so vereinfacht....
import javax.swing.*;
import java.util.*;

public class Quicksort implements ActionListener
{
    int NumberInt;
     int [] x;
    Quicksort(){
        kaf.initText(1,this);
        kaf.setButton(1,"Start");

    }
  void vertausche (int[] array, int idx1, int idx2) {
    int tmp = array[idx1];
    array[idx1] = array[idx2];
    array[idx2] = tmp;
  }
  void QuickSortIt (int[] Feld, int unten, int oben) {
    if(oben>unten){
      int li = unten, re = oben;
      int VElement = Feld[(unten + oben) / 2];  // Vergleichselement bestimmen
      while (li <= re) {
        // Erstes Element suchen, das größer oder gleich dem
        // Vergleichselement ist, beginnend vom linken Index
        while (li < oben && Feld[li] < VElement) //
          ++li;

        // Element suchen, das kleiner oder gleich dem
        // Vergleichselement ist, beginnend vom rechten Index
        while (re > unten && Feld[re] > VElement)  //
          --re;

        // Wenn Indizes nicht gekreuzt und nicht gleich --> Inhalte vertauschen
        if (li < re)
            vertausche(Feld, li, re);
        // Wenn Indizes nicht gekreuzt --> eine Position weitersetzen
        if (li <= re) {
          ++li;    --re;
        }
      }
      QuickSortIt (Feld,  unten, re);
      QuickSortIt( Feld, li, oben);
    }// if(oben>unten)
  }// 
    public int Zufall(){
      int r=0;
      r= (int)Math.round(Math.random()*30000);
      //kaf.writeLn(" |"+r +"|");
      return r;
     }
    public void fuellen(int Anzahl){
     for(int counter=0;counter<Anzahl;counter++){
        x[counter]=Zufall();
        }
     }
    public void Ausgeben(int[] Feld){
    for(int counter=0;counter<NumberInt;counter++)
        kaf.writeLn(x[counter]+"");
    }
    public void actionPerformed(ActionEvent ae)
    {
      int i = 0;

      long t1=0,t2=0,ergeb=0;
        if(ae.getActionCommand()=="Start"){
            kaf.clear();
            //NumberInt = Integer.parseInt(kaf.getText());
            NumberInt = 1000000;
            kaf.writeLn("Starting with " + NumberInt + " rounds... ");
            kaf.writeLn("Time\tItems\tTime");
            for(i=100000;i<=NumberInt;i+=100000)
            {
                x=new int[i];
                fuellen(i);

                t1=System.currentTimeMillis();
                QuickSortIt(x,0,i-1);
                t2=System.currentTimeMillis();
                ergeb = t2-t1;
                kaf.writeLn(i + "\t" + i + "\t" + ergeb + "\t" + GetDurchschnitt(x));

             }
            kaf.writeLn("Fertisch");
            //Ausgeben(x);
         }
    }
   double GetDurchschnitt (int[] Feld) {   
        double var=0;
        for(int i=0;i<100;i++)
            var=var+Feld[i];
        var = var / 100;
        return var;
    }
 }

while(i<=1000000){
Array = new long[i];

C++ ist nunmal nicht generell um Größenordnungen schneller als Java. Da hat Java in den letzten Jahren ne Menge aufgeholt. Während man zu Java 1.0-Zeiten noch von einem Performanceunterschied in der Größenordnung von Faktor 20-40 ausgehen konnte, ist dieser jetzt auf etwas Faktor 2-4 zurückgegangen. Zudem gibt es tatsächlich Bereiche, wo man mit Java ohne Probleme ein sehr schnelles Programm kriegt, während man sich mit C++ in diesen Bereichen schon Gedanken machen muss und vielleicht garnicht an die Performance von Java herankommt. Der Performanceunterschied zwischen Java und C++ ist inzwischen zumindest so gering, dass es in erster Linie vom Programmierer abhängt, in welcher Sprache ein implementierter Algorithmus schneller läuft.

Ich habe bei dir das Gefühl, dass du vor allem C++ noch nicht so gut verstehst, dass du schon an Performance denken solltest. Ich vermute, dass du da momentan in einer Phase steckst, in der du zwar weißt, wo du etwas einfügen mußt, um etwas bestimmtes zu erreichen, in der du aber noch nicht zu 100% weißt, was du da eigentlich machst. Zumindest war ich mal in so einer Phase und da habe ich IMHO so ähnlichen Code produziert wie du jetzt. Wenn das bei dir der Fall ist, dann empfehle ich dir, den VC++ wegzuwerfen, dir den g++ runterzuladen und mit einem einfachen Editor und einem guten C++-Buch (also kein VC++-Buch) die Sprache "neu" zu lernen. Der von dir produzierte Fehler und die Tatsache, dass du ihn nicht gefunden hast, deuten übrigens auch darauf hin, dass du dein Wissensstand auf dem von mir beschriebenen Niveau ist.

Das sehe ich halt nicht so. Wenn man in so einem Stadium eine IDE wie das VS nutzt, dann lernt man vor allem, sich eine GUI zusammenzuklicken und die Stellen im Code zu finden, wo man irgendetwas "einfügen" kann. Programmieren lernt man dabei IMHO nicht. Man lernt ja nichtmal, was eigentlich C++ ist und was VC++-spezifisch ist.

Stimmt, nur wird man auf deine vorgeschlagene Weise keine großen Fortschritte machen. Deshalb tendiere ich zu Sovoks Meinung.

Grüße Rapha

Naja, stimmt schon: Es ist immer schön, wenn man was sehen kann. Noch schöner ist es allerdings, wenn man etwas versteht. Das Verstehen kommt aber nicht dadurch, dass man sich ne GUI zusammenklickt. Dafür ist meine Methode deutlich besser geeignet.

ich muß auch Sovok und Rapha beipflichten.
Zeit ist Geld, und zudem leben wir im dritten Jahrtausend.

Wer frickelt sich denn noch HTML-Seiten per Texteditor zusammen ?
Jemand der zuviel Zeit hat.

Da Du nach und nach, umso größer Dein Projekt wird sowieso recht schnell an die "Einfügen"-Grenzen im Studio kommst, holst Du Dir die Infos, die Du benötigst sowieso aus dem Net oder per Fachliteratur, so daß Du successiv dazulernst. Nur das Du vorher nicht die Lust verlierst, weil Du einfach net vorankommst.

Aber ich fand den Vergleichsabschnitt spannend, den Du in Deinem ersten Posting hattest.

Grüße

BOA

Sicher kann man mit WYSIWYG Zeugs schnell Sachen machen, die man
sonst erst nach Jahren machen könnte. Aber das engt einen auch ein,
denn dann kann man immer nur auf den Augetrampelten Pfaden anderer laufen,
und nix selber erproben. Ich denke es ist wichtig verstehen zu können,
was man macht, und warum. Und eine Unabhängige Sicht, ohne Entwicklungsumgebungssspezifische
Konstrukte, wie es sie im VC und der MFC gibt, ist sicher von Vorteil.

Devil

Mir ging es aber so, dass ich erst Resultate sehen wollte und dadurch erst Lust am Programmieren bekommen habe.
"Kompliziertere Elemente" (aus der Sicht eines Anfängers, wie z.B. Subclassing oder GDI) habe ich zuerst immer mit Copy und Paste in meinen Code eingefügt. Nach und nach versteht man dann aber auch, was man eingendlich geschrieben hat.
Dies halte ich für die effektivste Lernmethode (sofern man eine ungefähre Ahnung von Klassen und Vererbung hat).

Grüße Rapha

Ab einem gewissen Level wird man Automatisch anfangen zu klicken. Man wird aber, mit der gewonnenen Einstellung, sich Themen die einen lange beschäftigen tief erforschen wollen.

Auch wird bei der "Zeitaufwendigen" Methode das Verstädnnis für die "Click an Play" geschichte besser geschult und man findet fehler oder ideen schneller

(Ich muss z.Z. ein Konfigdialog für ODBC Datenbankquellen machen, da ists mir erst mal wurscht wie es geht und nutze auch alles was vorgefertigt rumliegt...
Ich stand aber mit GUIs schon immer auf Kriegsfuss

Ich will hier zwar nicht auf die ganzen "bahnbrechenden" Sachen eingehen mit denen ich die Welt schon bereichert und zugemüllt habe, allerdings muss ich sagen, dass ich im Zweifel mehr von dem Verstehe als du glaubst(nicht viel mehr).

Als ich mit c++ anfing wurde ich als erstes erstmal von allen möglichen neuen Sachen erschlagen, da ich vorher VB geprogt hab ... Als ich mich dann einigermaßen in Consolenprogrammierung reingefuchst hatte, stellte ich fest, das für den täglichen Gebrauch praktisch keinerlei Konsolenanwendungen gibt. Dann kaufte ich mir ein Buch über Windowsprogrammierung mit den MFC...
Und ich wurde wieder erschlagen...
Allerdings hab ich festgestellt, wie einfach manche Sachen (Dialoge laden, auslesen , beenden, ....) gehen ohne das ich wirklich weiß wie sie funktionieren.
Doch durch anfängliche Erfolge wurden meine Probleme immer komplexer und ich hab immer wieder was dazugelernt, weil ich immer nur bestimmt sachen nachgucken/hier nachfragen musste. Ich würd sogar sagen, dass meine C++Kenntnisse ohne MVC++ flöten gegangen wären. Natürlich ist sowas vielleicht nicht so doll von der WYSIWYG-ideologie her. Allerdings sind Erfolgserlebnisse und Motivation enorm wichtig (besonders wenn man in seiner freizeit programmiert) und ich denke, dass ich auch über die VC++ MFC-Schiene irgendwann auf den Pfad der Tugend zurückkomme...

Um jetzt mal wieder ein paar n4pfragen loszulassen....
Was ist ein Speicherleck (definition, das ich eins im Code hab, weiß ich ja jetzt :D) und wie kann ich das schließen ?
Gibts irgendwo Seiten/Tutorials zur Codeoptimierung ?

m_Text += CString(13)+CString(10)+ConvertToCString(i) + "\t" + ConvertToCString(zeit_nach - zeit_vor) + "\t ("+Inf_DurchschnittFirst100(Array) + ")";
		UpdateData(false);
		//MessageBox("","",0);
		i = i + 100000;
		delete Array;

	}// while

delete [] Array;

Devil

@BOA:

Zeit ist Geld, und zudem leben wir im dritten Jahrtausend.

Exakt, und deshalb kann es sich eine Firma nicht leisten jemanden zu beschäftigen der die Sprache nicht verstanden hat, sondern nur eine GUI klicken kann.

Wer frickelt sich denn noch HTML-Seiten per Texteditor zusammen ?

Wir. (Webdesign Firma)
Warum? Weil du WYSIWYG Editoren nur zum prototypen verwendest - da ist aber manchmal Photoshop sogar besser
Und bei dynamischen Seiten funktionieren die sowieso nicht mehr.

Da Du nach und nach, umso größer Dein Projekt wird sowieso recht schnell an die "Einfügen"-Grenzen im Studio kommst, holst Du Dir die Infos, die Du benötigst sowieso aus dem Net oder per Fachliteratur, so daß Du successiv dazulernst. Nur das Du vorher nicht die Lust verlierst, weil Du einfach net vorankommst.

Einige, aber nicht die meisten.
Du kannst fast alles per Copy&Paste machen - ohne auch nur annähernd zu verstehen was da abgeht.

Unterhalte dich mal mit Lehreren: die werden dir sagen dass erstmal die Grundlagen können musst bevor du komplexe Sachen machst. Die umgekehrte Methode geht zwar auch, aber nur mit sehr viel Willenskraft.

Exakt, und deshalb kann es sich eine Firma nicht leisten jemanden zu beschäftigen der die Sprache nicht verstanden hat, sondern nur eine GUI klicken kann.

seit wann hat gui zusammenklicken was mit einer richtigen software zu tun?
dazu gehört viel mehr
auf der anderen seite gibts aber auch einige firmen die gar keinen bedarf für grosse entwicklungen haben
die kaufen sich dann ne softwarelizenz mit gui-quellcode und klicken sich die gui dann in vb zurecht wie sie es brauchen

Du kannst fast alles per Copy&Paste machen - ohne auch nur annähernd zu verstehen was da abgeht.

sobald man was macht was nicht mehr 100%tig dem mainstream entspricht und nich schon 1000 mal gemacht wurde hat man mit copy&paste eh keine chance mehr
auf der anderen seite. wenns nix besonderes is und nix besonderes kann interessierts eh keine sau

Wenn ich in MFC programmiere, dann male ich mir meinen Dialog auch zusammen, weils einfach nervig is das erst mit Pixelangaben im Code zu plazieren.
Aber dann muss ich dem Dialog ja auch noch beibringen was er tun soll wenn bestimmte Buttons gedrückt werden.
Und da fängts an das ich von dem Scheiß auch was verstehen muss.
Und daher ist das mit dem Copy und Paste sehr leicht dahergeplabbelt.

Irgendwie hab ich so das Gefühl das es generell immer negative Leute gibt.
Wenn man es einfach macht und Code "zusammenklickt" dann heisst es man würde ja eh nix von dem Verstehen was man da macht.

Und wenn man dann WIRKLICH mal was selbst macht, dann heisst es, "das wird eh nix", "das gibts schon", "warum das Rad zweimal erfinden?".

Warum muß man sich denn immer so negativ über andere beklagen?
Kann man denn nicht einfach nur ne Hilfestellung geben und fertig?
Nein da müssen dann noch die eigenen sturren Meinungen durchgeboxt werden.
Das bringt keinem was und verschwendet speicherplatz auf dem Server

Aus meiner Erfahrung in der C++ sowie in der JAVA-Programmierung kann ich sagen, dass C++ einfach schneller ist, da in C++ Maschinencode erzeugt wird, was ja bei JAVA bekanntich nur immer Sinne des JIT (Just-in-Time) der Fall ist. Dadurch gibt es schon Unterschiede...Bei JAVA ist die ganze Zeit die VM (Virtual Machine) am Werkeln und das kostet Performance. Da gibt es C++ einfach nicht zu toppen. Es geht ja bei JAVA schon los, wenn ich ein einfaches Fenster erzeuge, dass ziemlich viele Steuerelemente beinhaltet. Das dauert dann manchmal schon satte 3 bis 4 Sekunden und bei C++ "Klick" und da ist das Fenster (auf dem gleichen Rechner).

Was C++ ausbremst, ist die Vererbungsstruktur der MFC....da ist JAVA wieder im Vorteil. Die MFC ist einfach zu komplex, weswegen C++ da auch ausgebremst wird.

Wegen der Konsolenprogrammierung: Als kleiner Tipp...man kommt besser, wenn man die Basics auf der Konsole lernt. Weil dann hat man keine Probleme mit der Windowsprogrammierung. Wenn man auf der Konsole die OOP (Objektorientierte Programmierung) und prozedurale Programmierung drauf hat (inklusive Zeiger und dynamischer Speichernutzung) kann man sich an die MFC und Windowsprogrammierung wagen. Eher hat das keinen Sinn. Weil man dann nicht verstehen kann, was man überhaupt macht.

Und die Sache mit den Webseiten und dem Texteditor: Ich kenne viele Firmen, die professionelle Webseiten (wie oben schon gesagt vor allem dynamische Webseiten) mit konventionellen Editoren schreiben.

Die Firmen, die ich kenne, bauen auf Leute, die wissen was sie tun. Und wenn wir uns mal die Ausbildungen ansehen, dann bauen die Ausbildungsstätten darauf auf, den Leuten die Programmierung in C++ (Grundlagen) auf der Konsole beizubringen, denn umso leichter fällt der Umstieg. Ich kenne das aus eigener Erfahrung...

Aber ansonsten sind beides richtig gute Sprachen, sowie JAVA als auch C++. Das wollte ich von meiner Meinung her noch sagen...