[sottovento]

Originariamente inviato da tomminno

La new del Java per lo meno richiama almeno anche la new di un Object.
Quindi il codice generato non può essere uguale.

Si, e' vero. Penso che ci sia un vantaggio a favore di Java.
Crea per esempio una pletora di piccoli oggetti, per esempio:

class MyTest
{
public:
  MyTest ()
  {
    a = 0;
    b = 0;
    buf = new char[1024];
    strcpy (buf, "");
  }

  MyTest (int a, int b)
  {
    this->a = a;
    this->b = b;
    buf = new char[1024];
    strcpy (buf, "");
  }

  MyTest (const MyTest &myTest)
  {
    printf ("Costruttore di copia chiamato\n");
    a = myTest.a;
    b = myTest.b;
    buf = new char[1024];
    strcpy (buf, myTest.buf);
  }

  void setA (int a)
  {
    this->a = a;
  }

  void setB (int b)
  {
    this->b = b;
  }

  void setText (char *text)
  {
    strcpy (buf, text);
  }

  const char *getText ()
  {
    return buf;
  }

private:
  int a;
  int b;
  char *buf;
};

Questa e' una classe con una dozzina di byte, implementabile sia in C++ sia in Java.
Dopo di che, scrivi nel main:

void allochiamo ()
{
  printf ("Alloco un po'...\n");
  time_t start = time (NULL);
  for (int i = 0; i < 1000000; i++)
  {
    MyTest *p = new MyTest;
    if (p)
      delete p;
  }
  time_t stop = time (NULL);
  printf ("Tempo di allocazione: %d\n", stop - start);
}

Scrivi lo stesso codice per Java, per esempio:

	static void allochiamo ()
	{
		long start = Calendar.getInstance().getTimeInMillis ();
		for (int i = 0; i < 100000000; i++)
		{
			MyTest mytest = new MyTest();
		}
		long stop = Calendar.getInstance().getTimeInMillis ();

		System.out.println ("Time: " + ((stop - start)));
	}

Ho compilato la versione di C++ con Microsoft Visual Studio .NET 2003 Professional, mentre la versione Java e' stata compilata con jdk 1.5
Sul mio sistema Win XP, Java e' circa 100 volte piu' veloce.
Infatti puoi vedere dalle mie prove che il numero di zeri nel ciclo Java e' piu' grande, anche perche' sul mio sistema C++, con lo stesso numero di zeri, non arriva a completamento in un tempo decente (ore).
Dove sbaglio?
Soprattutto, nel caso abbia commesso un errore, che tipo di errore e'? L'ho creato apposta per far "vincere"Java o si tratta di una normalissima prassi di programmazione?
Perche' Java vince? Non dovrebbe perdere SEMPRE?

Originariamente inviato da tomminno

Stavamo parlando di codice generato per quel ciclo for, il GC non fa parte del programma quindi il codice generato è ancora una volta differente.

Esatto. Java e' quindi piu' ottimizzato in senso GLOBALE.
LOCALMENTE non riesce a battere C++, ma quando hai applicazioni da milioni di linee, le cose cambiano. Tanto piu' che le piattaforme a management di memoria (non solo Java) stanno vincendo sul mercato: mem leaks piu' difficili da produrre (ci vuole piu' entusiasmo), codice piu' robusto e possibilita' di fare ottimizzazioni a livello globale.

Originariamente inviato da tomminno

Spiegami dove verrebbero generate tutte le copie inutili, quando ormai tutti i compilatori traducono con un passaggio per riferimento tutti i metodi/funzioni che restituiscono copie di oggetti.

Riprendi l'esempio di prima:

MyTest getTest ()
{
  MyTest t;
  t.setA(5);
  t.setB(8);

  return t;
}

Spiegami come evitare questa copia.

Oppure:

void doSome1 (MyTest myTest)

Questa la potresti evitare scrivendo:

void doSome1 (const MyTest &myTest)

Pero'... se per caso usi i metodi di set() per risparmiare memoria, il tuo compilatore non compilera' un bel niente.
Come evitare? Dovrai fare una copia locale, che potremmo chiamare "copia volontaria".

Originariamente inviato da tomminno

Java su 1KB di RAM
Speigami quale OS ci girava.
Qualche riga di codice C per sistemi embedded l'ho scritta (ARM7 32KB) su questi sistemi non hai l'MMU, quindi non ci gira neanche Linux, e l'allocazione dinamica della memoria è un sogno.
Sarei curioso di sapere su quale sistema con 1KB di RAM hai visto girare Java.

Sorry, hai ragione. Era notizia riservata. Perdonami