Paso y retorno c++

Paso y retorno de direcciones

Si pasa o retorna una dirección (ya sea un puntero o una referencia), el programador cliente puede recoger y modificar el valor al que apunta. Si hace que el puntero o referencia sea constante, impedirá que esto suceda, lo que puede ahorrarle problemas. De hecho, cada vez que se pasa una dirección como parámetro a una función, debería hacerla constante siempre quesea posible. Si no lo hace, está excluyendo la posibilidad de usar la función con constantes.
La opción de devolver un puntero o referencia constante depende de lo que quiera permitir hacer al programador cliente. Aquí se muestra un ejemplo que demuestra el uso de punteros constantes como argumentos de funciones y valores de retorno.
//: C08:ConstPointer.cpp
// Constant pointer arg/returnvoid t(int*) {}

void u(const int* cip) {
//! *cip = 2; // Illegal -- modifies value
int i = *cip; // OK -- copies value
//! int* ip2 = cip; // Illegal: non-const
}

const char* v() {
// Returns address of static character array:
return "result of function v()";
}

const int* const w() {
static int i;
return &i;
}

int main() {
int x = 0;
int* ip = &x;const int* cip = &x;
t(ip); // OK
//! t(cip); // Not OK
u(ip); // OK
u(cip); // Also OK
//! char* cp = v(); // Not OK
const char* ccp = v(); // OK
//! int* ip2 = w(); // Not OK
const int* const ccip = w(); // OK
const int* cip2 = w(); // OK
//! *w() = 1; // Not OK
} ///:~
Listado 8.7. C08/ConstPointer.cpp

La función t() toma un puntero no-constanteordinario como argumento, y u() toma un puntero constante. En el cuerpo de u() puede ver un intento de modificar el valor de un puntero constante, algo incorrecto, pero puede copiar su valor en una variable no constante. El compilador también impide crear un puntero no constante y almacenar en él la dirección contenida en un puntero constante.
Las funciones v() y w() prueban las semánticas de retorno devalores. v() devuelve un const char* que se crea a partir de un literal de cadena. Esta sentencia en realidad genera la dirección del literal una vez que el compilador lo crea y almacena en área de almacenamiento estática. Como se ha dicho antes, técnicamente este vector de caracteres es una constante, como bien indica el tipo de retorno de v().
El valor de retorno de w() requiere que tanto elpuntero como lo que apunta sean constantes. Como en v(), el valor devuelto por w() es valido una vez terminada la función solo porque es estático. Nunca debe devolver un puntero a una variable local pues se almacenan en la pila y al terminar la función los datos de la pila desaparecen. Lo que si puede hacer es devolver punteros que apuntan a datos almacenados en el montón (heap), pues siguensiendo validos después de terminar la función.
En main() se prueban las funciones con varios argumentos. Puede ver que t() aceptará como argumento un puntero ordinario, pero si intenta pasarle un puntero a una constante, no hay garantía de que no vaya a modificarse el valor de la variable apuntada; por ello el compilador lo indica con un mensaje de error. u() toma un puntero a constante, así quepuede aceptar los dos tipos de argumentos. Por eso una función que acepta un puntero a constante es más general que una que acepta un puntero ordinario.
Como es lógico, el valor de retorno de v() sólo se puede asignar a un puntero a constante. También era de esperar que el compilador rehuse asignar el valor devuelto por w() a un puntero ordinario, y que sí acepte un const int* const, pero podríasorprender un poco que también acepta un const int*, que no es exactamente el tipo de retorno declarado en la función. De nuevo, como el valor (que es la dirección contenida en el puntero) se copia, el requisito de que la variable original permanezca inalterable se cumple automáticamente. Por eso, el segundo const en la declaración const int* const sólo se aplica cuando lo use como recipiente, en...