Funciones que devuelven objetos
 

En un proyecto que estoy haciendo se me ocurrió una función que me devolviera un objeto pero me encuentro en una interrogante: Si devuelve un objeto...¿Quien lo crea? la función o quien llama a la función?

Código Delphi [-]
Function GetTabla(nombre:String):TDataset;
var aTabla: TDataset
Begin
    aTabla := Tdataset.create(nil);
    GetTabla := aTabla;  // devolver la tabla recien creada
                                 // pero entonces...quien la destruye?¡???
                                // no se pierde al salir de la función??
end;
 
Procedure HazAlgo;
var unaTabla: TDataset;
Begin
   unaTabla := GetTabla("datos");   ///<--- Se puede hacer esto???
                                               // Pero si unaTabla no se ha construido?     
end;

Mi Teoría:

Se supone que todas las instancias de un objeto son simples punteros partimos de que en la funcion HazAlgo efectivamente unaTabla, al no crearse no reserva memoria para el objeto TDataset, esto lo hace la funcion GetTabla dentro de su codigo y devuelve el puntero a la memoria recientemente reservada (la funcion no la libera destruyendo el objeto que creo). Entonces asumo que unaTabla apunta al Objeto que cre{o la función, por lo que entonces, tendré que destruir directamente unaTabla para liberarla.

Quedando así:

Código Delphi [-]
Procedure HazAlgo;
var unaTabla: TDataset;
Begin
   unaTabla := GetTabla("datos");   //equivaldría a Tdataset.create(nil)
  Try
    { uso una tabla
     .
     .
     .
     }
  finally
    unaTabla.free; // Libero la memoria
  end;
 end;

Segun mi teoria este último código debe ser completamente válido...pero no lo sé hasta probarlo..

Alguna sugerencia? A lo mejor no estoy descubriendo nada nuevo...

Está bien lo que haces. La función es la que crea el objeto y quien lo recibe se encarga de destruirlo.

// Saludos

Gracias Roman. Ya lo probe y si era asi como tu bien me confirmas.

Que feo es cuando deja uno algo y luego lo retoma...se te barren muchas cosas ;)

Para estos temas soy muy quisquilloso, cambiaría el nombre de la función a "CreateTable", "CreateDataset", "AllocDataset", es decir, un nombre que al verlo en la función HazAlgo, identifique que AllocDataset crea internamente un Dataset y por tanto en HazAlgo tengo que destruirlo con free.

"GetDataset" a mí personalmente, no me indica si realmente se crea algo, o es un apuntador a un dataset existente. El hecho es que siempre se me olvida que tengo que destruirlo y acabo revisando el código fuente de "GetDataset" (perdiendo más tiempo). Con un nombre más apropiado, el código se hace más entendible.

saludos

¡Y qué bueno que lo seas! Estoy totalmente de acuerdo contigo. Semánticamente debe quedar claro que la función es una creadora o fábrica de objetos. Me alegra que hayas hecho la observación.

// Saludos

Hola,

Pues yo, puñeteramente, pregunto, porque dudo: el identificador puede dejar claro que se creará un objeto, estamos de acuerdo, pero, ¿queda claro que dicho objeto habremos de liberarnos nosotros? ¿Habría alguna forma de dejar esto claro también -a lo mejor ya lo está y a mí no me lo parece- o acaso es algo que hay que dar por sabido? ¿Eh? ¿Eh? ¿Eh? ;)

Claro, podrías poner:

Código Delphi [-]
Persona := CrearPersonaPeroNoOlvidesLiberarla();

pero lo veo innecesario porque en principio uno sabe como funciona el lenguaje: todo lo que se crea debe destruirse. Si te queda claro que después de

Código Delphi [-]
Persona := TPersona.Create;

debes en algún momento destruir el objeto Persona, no veo por qué no había de ser igualmente claro en el otro caso.

;)

// Saludos

Seguramente voy a decir una de mis acostumbradas burradas, pero en fin, después que me regañen voy a leer un poco más al respecto.

A no ser que uses interfaces, pues estas lo hacen por si sola, esto es cierto verdad???

pero lo que tengo es que leer más acerca de estas cosas mágicas que se dan cuenta cuando ya uno no las necesita más, y paff, se suicidan :)

Saludos

No exactamente. Cada vez que se agrega una referencia a una interfaz (cualquier variable a la que le asignes una interfaz), el compilador agrega una llamada al método _AddRef, y cada vez que se pierde una referencia (por ejemplo, cuando una variable que tenía asignada una interfaz sale de alcance o cuando le asignas otra cosa) el compilador agrega una llamada a _Release.

Aunque semánticamente _AddRef y _Release parecen agregar una referencia y quitarla, lo cierto es que no hacen nada por sí solas, porque, de hecho no existen.

Como sabrás, una interfaz no implementa nada por si sola, sino que se limita a a definir un conjunto de métodos. Una clase puede implementar una o más interfaces, y será esa clase entonces quien realmente haga la implementación de los métodos.

La interfaz base, IInterface, declara tres métodos: QueryInterface, _AddRef y _Release.

Cuando se trabaja con interfaces, se suele derivar la clase que las implemente de TInterfacedObject, que es un objeto que implementa los métodos de IInterface, de manera que nosotros no tengamos que preocuparnos por hacerlo.

TInterfacedObject es quien realmente implementa el manejo automático de la destrucción. Para ello lleva un campo interno FRefCount, que incremente en 1 cada vez que se llama a _AddRef y lo decrementa en 1 cada vez que se llama a _Release. Cuando el método _Release deeca que _RefCount llega a cero, entonces se "suicida".

Sin embargo, puedes usar otros objetos base o implementar tú mismo _AddRef y _Release, de manera que no destrutan el objeto.

// Saludos

Tienen razon en la observación. De hecho Puse Get por decir cualquier otra cosa ya que como sabemos Get indica que estamos accediendo a una propiedad de un objeto. Yo creo que basta con Agregar "Create" al nombre del método y con eso será suficiente para que casi por costumbre le agreguemos el consabido try..finally que se acostumbra y liberemos la instancia.

Hola,

Sí; ahora se me ocurre "otra forma" de verlo. Resulta que si se deja claro, por medio de su identificador, que se creará un objeto en la función "X", lo cierto es que lo creas para algo, y luego de la llamada a la función "X" tú haces uso del objeto... ya esto debería dejar claro que alguien tendrá que liberar el objeto... y ese alguien será uno mismo... o una función "Y", vamos... ;) ¡Patente, patente, aquí hay patente! Soy un genio,... ¡si es que soy un genio! Muack, muack, muack (yo, besándome a mí mismo conmigo mismo). :D :D