C/Visual C - devolver referencias a datos miembros

He leido que no es correcto devolver referencias a datos miembros, puesto que entonces los puedes modificar fuera de la clase [ char * getDato()].
Por esto me he creado una variable local al metodo, he copiado el dato y devuelvo la variable local. ¿Se soluciona así? ¿Es correcto devolver var locales? ¿Se destruyen las variables locales al salir del metodo y entonces no las puedo devolver?

Efectivamente, la variable local se destruye al salir del método y la referencia que has devuelto deja de ser válida.

Tienes que crear un puntero local, hacerle el new y devolverlo. El puntero local se destruira, pero la memoria creada no. El que llama al metodo tendrá que liberarla luego. Por ejemplo
class A
{
public :
char *getDato()
{
char *Aux;
Aux = new char[ Numero_Caracteres ];
// Aqui copio mi dato miembro en Aux
return Aux;
}
}

Y el que llama debe
char *cadena;
cadena = A.getDato();
// aqui uso cadena como me apetezca
delete [] cadena;

Espero que te sirva de ayuda.

Se bueno

¿Dónde has leido que no es correcto devolver referencias a datos miembro? Eso depende de lo que quieras hacer...
Si no quieres que desde fuera lo cambien, siempre puedes devolver una referencia constante.
Devolver como referencia una variable local no se puede. Y crear uno nuevo es un poco engorro, porque el que llama al método debe luego acordarse de liberarlo.
Yo creo que la mejor opción es devolver una referencia constante.
Por cierto, no confundas referencias (int &) con puntero (int *).

Un saludo.

Yo me refería a un devolver punteros, por ejemplo cuando de vuelves una cadena de caracteres [char *]. ¿No es muy correcto no? ¿Se puede poner eso cómo constante [char *] o solo la referencia [int &].
¿Cómo se hace pare devolver una referencia constante?. Ponme un ejemplo por favor.

Tienes una clase con un nombre guardado en un char*, que se le pasa en el constructor, y no quieres que te lo cambien, pero quieres que se pueda acceder a el con un método, digamos "getName()". Lo que haces es devolver el char * pero constante, de la forma:

class MiClase {
public:
MiClase(char *nombre) : name(nombre) {}
const char *getName() {return name;}
private:
char *name;
}

El método getName devuelve la misma variable, pero constante. De esta forma el que llama a la variable no lo puede cambiar. De hecho, el valor devuelto NO puede asignarse a una variable char * normal, sino a una constante:

char *cad = obj.getName(); // NO COMPILA
const char *cad2 = obj.getName(); // COMPILA

Y lo bueno de esto es que:
cad2[0] = 'b';

no compilara, porque cad2 está declarada como constante.

Espero haberme explicado...

Como bien dices es correcto o no según lo que quieras hacer.
De todas formas, en general es incorrecto desde el punto de vista de ocultamiento de la información. Si alguien "ve" tu estructura interna de datos, depende de la implementación de tu clase.

Imaginate que tienes en tu clase un char* que devuelves como referencia constante y hay mucha gente utilizándolo. De repente, un dia, decides que te has hecho una clase String muy chula y que quieres cambiar el char * por el String. Si has devuelto una referencia al char * ya la has liado. Si devolvias una copia de char * que el llamante debía liberar, puedes rehacer tu método getCadena() para que siga devolviendo la copia en formato char * y nadie tiene que tocar su código.

Se bueno.