Puntero vs variable en la clase

Question

Sé cuál es la diferencia y cómo funcionan ambos, pero esta pregunta es más sobre el estilo de codificación.

Cada vez que estoy codificando hago muchas clases, todas tienen variables y algunas de ellas son punteros y algunas son variables normales. Por lo general prefieren las variables a punteros si que los miembros dura tanto como lo hace la clase pero entonces mi código se convierte de esta manera:

engine->camera.somevar->x; 
// vs 
engine->camera->somevar->x; 

no me gusta el punto en el medio. O con variables privadas:

foo_.getName(); 
// vs 
foo_->gatName(); 

Creo que el punto "desaparece" en un código largo. Encuentro que -> es más fácil de leer en algunos casos.

Mi pregunta sería si utiliza punteros incluso si la variable se creará en el constructor y se eliminará en el destructor. ¿Hay algún consejo de estilo en este caso?

P.S. Creo que el punto se ve mejor en algunos casos.

Answer 1

En primer lugar, es una mala forma de exponer las variables miembro.

En segundo lugar, su clase probablemente nunca debería tener punteros de contenedor. Ligera corolario: las clases que contienen lógica comercial nunca deben tener punteros (ya que esto significa que también contienen código de administración de puntero y el código de administración del puntero debe dejarse a las clases que no tienen lógica comercial pero están diseñadas específicamente para administrar punteros (punteros inteligentes y contenedores)

Las clases de administración de punteros (punteros inteligentes/contenedores) se deben diseñar para gestionar un único puntero. Gestionar más de uno es mucho más difícil de lo esperado y todavía no he encontrado una situación donde complejidad adicional valió la pena.

Finalmente, los miembros del público no deben exponer la implementación subyacente (usted sho uld no proporciona acceso a los miembros incluso a través de getters/setters). Esto vincula la interfaz a la implementación. En su lugar, su interfaz pública debe proporcionar un conjunto de acciones que se pueden realizar en el objeto. es decir, los métodos son verbs.

En C++ es raro ver punteros.
Generalmente están ocultos dentro de otras clases. Pero deberías acostumbrarte a usar una mezcla de -> y . ya que todo depende del contexto y de lo que intentas transmitir. Siempre que el código esté limpio y legible, no importa demasiado.

Una adición personales:

me gusta la continuación _ al final de su identificador hace que el. disapear foo_.getName() creo que se vería mucho mejor como foo.getName()

Answer 2

Si la estructura "incrustada" tiene exactamente la misma duración que la estructura "principal" y no se hace referencia en ningún otro lugar, prefiero tenerla como miembro, en lugar de usar un puntero. El código producido es ligeramente más eficiente, ya que guarda una cantidad de llamadas al asignador de memoria y evita una serie de desreferencias del puntero.

También es más fácil de manejar, ya que se reduce la posibilidad de errores relacionados con el puntero.

Si, por otro lado, existe la más mínima posibilidad de que la estructura incrustada se pueda referenciar en otro lugar, prefiero usar una estructura y punteros separados. De esta forma, no tendré que refactorizar mi código si resulta que la estructura incrustada debe extraerse de su matriz.

EDIT:

supongo que eso significa que por lo general voy con la alternativa puntero :-)

EDIT 2:

Y sí, mi respuesta es suponiendo que realmente quiere (o tiene) para elegir entre los dos, es decir, que escriba código de estilo C. La forma adecuada de acceder a miembros de la clase orientada a objetos es a través de funciones get/set.

Mis comentarios sobre si incluir una instancia de clase real o un puntero/referencia a uno son probablemente todavía válidos, sin embargo.

Answer 3

Lo ideal es que no uses ninguno de estos métodos: debes usar los métodos getter/setter. El rendimiento alcanzado es mínimo (el compilador probablemente lo optimice, de todos modos).

La segunda consideración es que usar punteros es una idea generalmente peligrosa, porque en algún momento es probable que la arruine.

Si ninguno de estos te desconcierta, entonces diría que todo lo que queda es una cuestión de preferencia personal.

Answer 4

Usted no debe hacer su elección debido a encontrar '->' más fácil de leer :) usando una variable miembro es generalmente mejor ya que no puede cometer errores con usted puntero.

Dicho esto, el uso de una variable miembro te obliga a exponer tu implementación, por lo tanto, tienes que usar referencias. Pero luego debe inicializar en su constructor, que no siempre es posible ...

Una solución es usar std :: auto_ptr o boost :: scoped_ptr de un puntero inteligente similar. Allí obtendrá la ventaja de ambas soluciones, con muy pocos inconvenientes.

MY2C

EDIT:

Algunos enlaces útiles:
Article on std::auto_ptr
boost::scoped_ptr
Pimpl : private implementation