Tengo una cuestión (sobre C++) que necesita respuesta, auque creo que no pueda hacerse.
Tengo una clase:
class puta
{
puta(char *nombre); // constructor
};
Ahora, quiero crear un array de putas. Peror esulta que el constructor tiene un parámetro obligatorio, por lo que para hacer el array no puedo hacer:
puta *arrayputas=new puta[50];
La única manera de poder tener ese array de putas sería con un array de punteros a puta:
puta **arrayputas=new puta*[50]
for (int i=0; i<50; i++)
arrayputas[i]=new puta("Juliana");
De esta manera sí que se puede hacer, pero ya no tengo un array de putas, que es lo que quería, sino un array de punteros a putas. Debería haber alguna manera de hacer:
puta *arrayputas=new puta("Juliana")[50]
Pero eso no te lo permite C++. :(
¿Sabeis de algún emcanismo de C++ que me permita crear un array de ese tipo?
PD: Si la respuesta es ke no se puede de esa forma, contestadme un no se puee y adelantamos.
Gracias.
Creo que eso no se puede hacer... ¿por qué no te echas una novia y dejas las putas? (ses)
:D :D :D :D
No se puede, en un array->Constructor por defecto. (Y demás TADs cuando no los inicializas elementoa elemento)
Usa un método de inicialización y lo llamas para cada elemento del array, AFAIK es la única opción (aparte de crear daca elemento dinámicamente como ya sabes hacer)
PD: Pobre Juliana.... ;)
Claro que puedes. Crea un constructor vacio. Si necesitas pasarle una variable diferente cada vez, puedes utilizar llamadas desde ese propio constructor. No es muy elegante, pero funciona!
No te comprendo
Haddd, no sé si pillo por donde vas...a ver si es algo como esto:
Mediante un método de clase estático se le podría pasar a la clase el parámetro deseado(y se guarda), y despues en el constructor por defecto se consulta el miembro estático.
class Puta
{
...
string m_strNombre;
static string s_strNombre;
static void NombreDePutas(const char* szPuta) { s_strNombre = szPuta; }
...
}
Puta::Puta()
{
m_strNombre = s_strNombre;
}
Luego harias
Puta::NombreDePutas("LaMarsi");
Puta* arrayPutas = new Puta[50];
Creo que eso deberia funcionar :huh:
<_<
Supongo que se refiere a esa cosa tan bonita ^_^, aunque eso no es un constructor vacío, supongo que querría decir sin argumentos.
Cita de: "Mars Attacks"<_<
;) :-*
(ole)
Poooos claro xDD Usa un constructor vacio y luego llama a una funcion Inicializar o sino llamala directamente desde el constructor por defecto. Algo asi:
#include "puta.h"
Puta::Puta()
{
//Una variante seria añadir aqui una llamada a Inicializar(), aunq no te lo recomiendo
}
bool Puta::Inicializar()
{
m_strNombre = "Letizia";
return true;
}
void main()
{
Puta *array = new Puta[50];
for(int i=0; i<50; i++) //Si pones la llamada a inicializar() en el constructor ya no hace falta este for
array[i].Inicializar();
}
yo lo que haria es crear variables estaticas con los parametros de inicialización de la clase, así a la hora de crear el array antes pones los valores a usar, por ejemplo:
class foo
{
public:
foo();
foo( int value );
static int setParam( int a) { param = a; }
private:
static int param;
};
int foo::param = 0;
foo::foo()
{
//.... inicializas usando el valor de param
}
main()
{
foo::setParam( 10 );
foo myarray[50];
}