C/Visual C - Retornar referencias a datos miembros

Class A
{
private;
char *dato1;
Objeto ob;
public:
char *getDato()
{
return dato1
}

Objeto & getOb()
{
return ob;
}

¿El metodo que retorna *char es correcto? Me han dicho que mejor devuelva una referencia constante, pero no sé como se hace. Aunque también pienso que quizá devolver el puntero a char puede dar problemas si desde fuera se hace una saignación y luego un delete ¿no?
En el segundo caso,¿Hay algún tipo de problema en retornar una referencia a la varible miembro. Es para no llamar al constructor copia de ese objeto.

No he usado C++, pero estoy confundido en cuanto a lo que quieres lograr, puesto que el miembro es un puntero a char cuyo dato sólo podrá ser una dirección (o quizá estás implementando una cadena de caracteres), ¿no podrías usar la clase string?

Saludos,
José Jorge (Geo).

Quiero retornar el dato miembro de la clase que es un *char (Cadena de caracteres, en C++ estandar no existe la clase string) y me han comentado que pordía hacerlo así, pero no sé si es lo correcto o puede dar algun problema (Retornar una referencia constante para que no se pueda modificar fuera)
const char* getDato()
{
return dato1;
}

Otra duda que tengo es retornar un dato miembro de la clase que es un objeto y no quiero que se llame al constructor copia al devolver el objeto miembro, creo que sería algo así (Devolver la referencia) pero no sé si es correcto:

Objeto & getOb()
{
return ob; //ob es un dato miembro de la clase, que es un objeto
}

Espero haberme explicado, y agredezco cualquier ayuda

Hola!!

Lo primero es lo primero:
El metodo GetDato(), esta perfecto. La idea basica de usar un metodo Get() es para obtener un dato ya sea privado o protegido, entonces te aseguras que nadie pueda modificar tu variable miembro, porque lo que haces es devolver una copia de la misma. Si usas un Set() es para cambiarla a la variable miembro. Asi mismo, al anteponer la palabra reservada "const" te terminas de asegurar que nadie pero nadie pueda mofificar tu variable miembro.
Ahora, si vos pasas un objeto por referencia no necesitas un constructor de copia. El pasaje de objetos por referencia sirve por ejemplo cuando tenes un objeto que representa una matriz de 10000 filas por 50000 columnas y si hicieras una copia del mismo, quizas en cierto caso no tendrias suficiente memoria, entonces este el caso en el que te das cuenta de la importancia que es el pasaje de objetos por referencia. Ademas si quisieras que ese objeto solo sirva como fuente de datos para el metodo de deestino y nadie te pueda pisar esa matriz, le antepones la palabra const y nadie te lo toca

Espero que te hay servido

Salu2!!!!

Me olvide de poner algo

C++ tiene definida la clase CString para almacenar obviamente strings

Si queres la podes usar tranquilamente

Salu2!!!!!!!

P.D.: en esta clase oviamente funcionan todas las funciones relacionadas con cadenas de caracteres como son strcpy( ), strcat(), gcvt( ), atoi() , atof ( ) , etc

Chau

Hola!

Cuando tienes una clase con un atributo que es un entero, puedes tener un metodo para poder desde fuera averiguar su valor, por ejemplo:
int getSize() {return _size;}

Una buena práctica de programación en este caso es hacer esta función constante; eso le indica al compilador que la función no va a cambiar el estado interno del objeto (es decir los valores de sus atributos), por lo que puedes poner:

int getSize() const {return _size;}

Por otro lado, cuando devuelves un entero, se hace una copia del valor, y es lo que se devuelve. Como tú bien dices, si en vez de un entero fuera otro objeto (clase Objeto en tu ejemplo), se haría una copia, que es justo lo que no quieres.
Para eso, hay dos soluciones: devolver un puntero al objeto, y devolver la referencia. En ambos casos, se tiene el problema de que _desde fuera_ se puede cambiar el valor del atributo:

Objeto &getObj() {return &_obj;}

// y desde fuera

(a.getObj())->atributo_de_Objeto = 3;

Cosa nada recomendable, en la mayoría de las ocasiones, porque le estás cambiando un atributo de un objeto (de la clase A en tu ejemplo), sin "informarle".

La solución es devolver _ese puntero o referencia_ constante. De esta forma, el compilador no dejará que se cambie nada de ese objeto devuelto desde fuera:

const Objeto &getObj() const {return &_obj;}

// y desde fuera

(a.getObj()).atributo_de_Objeto = 3; // NO COMPILA!

La última línea no compilará, porque a.getObj() es