C/Visual C - Ayuda com memoria!!!!!!!!!!!!!!

Soy principiante en esto de c++ y no se como c++ maneja la memoria.

Me gustaría saber si una clase como la siguiente "llena" o no "llena" la memoria al estar declarando tantos char buffer[100]. Si es asi les pido una solución la cual no "llene" la memoria. Salu2:

class Leer
{
public:
static int datoInt()
{
char buffer[100];
gets(buffer);
return atoi(buffer);
}

static double datoDouble()
{
char buffer[100];
gets(buffer);
return atof(buffer);
}

static void datoChar(char v[])
{
char buffer[100];
gets(buffer);
strcpy(v,buffer);
}
};

Pues por supuesto que llena la memoria. Nada es gratis, ¿recuerdas? :P

Pues mira, que en tu caso me parece que no hay mucho que puedas hacer. En todo caso, pedir un char* de parámetro para que sólo crees una variable y la pases por referencia. Otra es que si sabes la longitud actual de la cadena, pues crees dinámicamente la cadena con el operador new:

// nLen es la longitud de la cadena
char* pBuffer = new char[nLen];
memset(pBuffer, 0, sizeof(pBuffer));
// haces lo que quieras con pBuffer
delete [] pBuffer; // liberas pBuffer de memoria.

El método anterior también te serviría para distribuir la carga de memoria dentro de una función larga. Pero creo que no es tu caso.

Ahora bien, finalmente, recordemos que los ints y doubles tienen rangos. Es decir, no tiene caso que crees un búffer de 100 caracteres cuando un int, en su versión sin signo (unsigned), contendría un número no mayor a los cinco dígitos. En este caso, un búffer de seis o siete caracteres es suficiente. Lo mismo aplica para el double (aunque ahorita no recuerdo exactamente el rango, chécalo para ver hasta cuántos dígitos tendrías).

Ahora sí, ya por último, te comento que la clase std::string maneja todos esos detalles de forma interna, quizás te convenga emplearla. Si trabajas con MFC, CString hace una función similar que te facilitaría el trabajo.

Saludos.

Que tal si hago esto:

class Leer
{
static int datoInt()
{
char* buffer=new char[7];
gets(buffer);
int a=atoi(buffer);
delete[] buffer;
return a;
}

static double datoDouble()
{
char* buffer=new char[25];
gets(buffer);
double d=atof(buffer);
delete[] buffer;
return d;
}

static void datoChar(char v[])
{
char* buffer=new char[100];
gets(buffer);
strcpy(v,buffer);
}
};

Pues puedes hacerlo, pero de antemano dá igual que hagas un

char* buffer = new char[7];

a que hagas un

char szBuffer[7];

lo que te comento es bueno cuando el tamaño de tu array varía (por ejemplo, cuando vas a serializar archivos). Es decir, lo puedes hacer, pero te daría el mismo resultado. Lo que sí, que diferencia entre un szBuffer[7] que szBuffer[100], ahí sí te ahorras unos bytes.

Finalmente, en datoChar, sería mejor algo así:

static void datoChar(char* pBuffer)
{
gets(pBuffer);
}

y cuando mandes llamar datoChar, sería de forma normal:

char miChar[100];
memset(miChar, 0, 100);
Leer::datoChar(miChar);

y listo. Acuérdate que un string en C++ es un vector de caracteres, por lo que también funcionan como punteros (en este caso, char*). Así, te evitas crear la variable tanto fuera de datoChar como dentro y te ahorras otros cien bytes.

Saludos.

Gracias Fernando por tu ayuda, me ha servido de gran utilidad