Obviamente todos los almacenes de información a lo largo de un algoritmo implican un mayor consumo de recursos... en C, C++, C#, Java, Perl, PHP, ADA, Pascal, javascript y cualquier otro.

Sin embargo la cosa cambia cuando te encuentras con algo tal que:

#include <limits.h>
#include <iostream>
 
int main( )
{
  for ( unsigned int i=0; i<UINT_MAX; i++ )
  {
    for ( unsigned int j = 0; j < UINT_MAX; j++ )
    {
      string variable = "ALGO" + std::to_string( i ) + std::to_string( j );
      std::cout << variable << std::endl;
    }
  }
}

public class Program
{
  public static void Main()
  {
    for ( uint i=0; i<uint.MaxValue; i++ ) 
    {
      for ( uint j = 0; j < uint.MaxValue; j++ )
      {
        string variable = "ALGO" + i.ToString( ) + j.ToString( );
        System.Console.WriteLine( variable );
      }
    }
  }
}

Ya te garantizo yo que el consumo total de memoria del segundo programa en C# es bastante superior. Y cuando digo "bastante superior" me refiero descontando el consumo adicional de memoria que por defecto tiene C# con respecto a C++.

eferion: me debo estar perdiendo algo otra vez, ya que no se hace uso intensivo de la memoria dinamica (son unas cadenas de tamaño infimo) en tu ejemplo y se podria solventar facilmente usando una variable definida fuera del bucle en C# (acudo a la logica simplemente, no trabajo en .NET pero como el framework este medio bien hecho - tambien queda la JVM - al asignarle un nuevo puntero a variable deberia liberar la memoria anterior sin necesidad de recolectar basura posteriormente).

amchacon: por eso, si los punteros son el pasado ...

Se hace uso intensivo de memoria porque cada vez que creas un string, en la versión de C# (igual pasaría con Java) se está creando bajo la figura de un puntero... cuando se sale del ámbito, la instancia de string se marca para ser reciclada por el recolector de basura. Dado que el proceso está ocupado con la ejecución del bucle, el recolector de basura no entra en juego... y eso sucede a lo largo de toda la vida del código que he puesto.

Resultado: 4 * 4,294,967,295^2 instancias de string esperando a ser liberadas... y ocupando espacio en memoria.

el 4 viene porque:

string variable = "ALGO" + i.ToString( ) + j.ToString( );

Esta línea implica la creación de 4 strings:

* primer string: "ALGO"
* segundo string: i.ToString( )
* tercer string: j.ToString( )
* cuarto string: variable = todo_lo_demas

Bueno, realmente creo que sería más correcto decir que en cada iteración se crean 5 strings... ya que los operadores de suma se resuelven uno a uno.


Totalmente de acuerdo.

Además, usando referencias evitas la tentación de hacer delete donde no corresponde

Después de realizar algunas comprobaciones debo reconocer que .NET ha mejorado enormemente los problemas que comento.

Me apunto probar con strings más grandes... ya que el "tamaño" que ocupa uno de estos es francamente pequeño... y no se puede hacer un subclass de "string" porque es una clase "sealed".

Aún así me ha sorprendido la mejora de rendimiento al respecto.