c++ - que - punteros a cadenas

Aprobar referencias a punteros en C++ (10)

Por lo que puedo decir, no hay ninguna razón por la cual no se me permita pasar una referencia a un puntero en C ++. Sin embargo, mis intentos de hacerlo están fallando, y no tengo idea de por qué.

Esto es lo que estoy haciendo:

void myfunc(string*& val) { // Do stuff to the string pointer } // sometime later { // ... string s; myfunc(&s); // ... }

Y obtengo este error:

no se puede convertir el parámetro 1 de ''std :: string *'' a ''std :: string * &''

Acabo de utilizar una referencia a un puntero para hacer todos los punteros en un árbol binario eliminado, excepto la raíz segura. Para que el puntero sea seguro, solo tenemos que establecerlo en 0. No pude hacer que la función que elimina el árbol (manteniendo solo la raíz) acepte una referencia a un puntero ya que estoy usando la raíz (este puntero) como la primera entrada para cruzar a izquierda y derecha.

void BinTree::safe_tree(BinTree * &vertex ) { if ( vertex!=0 ) { // base case safe_tree(vertex->left); // left subtree. safe_tree(vertex->right); // right subtree. // delete vertex; // using this delete causes an error, since they were deleted on the fly using inorder_LVR. If inorder_LVR does not perform delete to the nodes, then, use delete vertex; vertex=0; // making a safe pointer } } // end in

En pocas palabras, una referencia a un puntero no es válida cuando el parámetro formal es el puntero (this).

Bienvenido a C ++ 11 y referencias rvalue:

#include <cassert> #include <string> using std::string; void myfunc(string*&& val) { assert(&val); assert(val); assert(val->c_str()); // Do stuff to the string pointer } // sometime later int main () { // ... string s; myfunc(&s); // ... }

Ahora tiene acceso al valor del puntero (al que se refiere val ), que es la dirección de la cadena.

Puedes modificar el puntero y a nadie le importará. Ese es un aspecto de lo que es un valor en primer lugar.

Tenga cuidado: el valor del puntero solo es válido hasta que devuelva myfunc() . Por fin, es un temporal.

Cambiarlo a:

std::string s; std::string* pS = &s; myfunc(pS);

EDITAR:

Esto se llama ref-to-pointer y no puede pasar una dirección temporal como referencia a la función. (a menos que sea const reference ).

Sin embargo, he mostrado std::string* pS = &s; (puntero a una variable local), su uso típico sería: cuando desee que el destinatario cambie el puntero, no el objeto al que apunta. Por ejemplo, una función que asigna memoria y asigna la dirección del bloque de memoria que asignó a su argumento debe tomar una referencia a un puntero, o un puntero al puntero:

void myfunc(string*& val) { //val is valid even after function call val = new std::string("Test"); }

EDITAR: Experimenté un poco, y descubrí que las cosas son un poco más sutiles de lo que pensaba. Esto es lo que ahora creo que es una respuesta precisa.

&s no es un valor l, por lo que no puede crear una referencia a menos que el tipo de referencia sea referencia a const . Entonces, por ejemplo, no puedes hacer

string * &r = &s;

pero puedes hacer

string * const &r = &s;

Si coloca una declaración similar en el encabezado de la función, funcionará.

void myfunc(string * const &a) { ... }

Hay otro problema, a saber, los temporales. La regla es que puede obtener una referencia a un temporal solo si es const . Entonces, en este caso uno podría argumentar que & s es temporal, y por lo tanto debe declararse const en el prototipo de la función. Desde un punto de vista práctico, no hay diferencia en este caso. (Es un valor rvalue o temporal. De cualquier manera, se aplica la misma regla). Sin embargo, estrictamente hablando, creo que no es un valor temporal sino un valor. Me pregunto si hay una manera de distinguir entre los dos. (Tal vez simplemente se define que todos los temporales son valores r, y todos los valores no-l son temporales. No soy un experto en el estándar).

Dicho esto, su problema probablemente esté en un nivel superior. ¿Por qué quieres una referencia a la dirección de s ? Si desea una referencia a un puntero a s , debe definir un puntero como en

string *p = &s; myfunc(p);

Si quieres una referencia a " s o un puntero a " s , haz lo sencillo.

El problema es que está intentando vincular un temporal a la referencia, lo que C ++ no permite a menos que la referencia sea const .

Entonces puede hacer una de las siguientes cosas:

void myfunc(string*& val) { // Do stuff to the string pointer } void myfunc2(string* const& val) { // Do stuff to the string pointer } int main() // sometime later { // ... string s; string* ps = &s; myfunc( ps); // OK because ps is not a temporary myfunc2( &s); // OK because the parameter is a const& // ... return 0; }

Sé que es posible pasar referencias de punteros, lo hice la semana pasada, pero no recuerdo cuál fue la sintaxis, ya que su código parece correcto para mi cerebro en este momento. Sin embargo, otra opción es usar punteros de punteros:

Myfunc(String** s)

Su función espera una referencia a un puntero de cadena real en el alcance de la llamada, no un puntero de cadena anónimo. Así:

string s; string* _s = &s; myfunc(_s);

debería compilar muy bien.

Sin embargo, esto solo es útil si tiene la intención de modificar el puntero que pasa a la función. Si tiene la intención de modificar la cadena en sí, debe usar una referencia a la cadena como lo sugirió Sake. Con esto en mente, debería ser más obvio por qué el compilador se queja de su código original. En su código, el puntero se crea ''sobre la marcha'', modificando que el puntero no tendría consecuencia y que no es lo que se pretende. La idea de una referencia (frente a un puntero) es que una referencia siempre apunta a un objeto real.

Tratar:

void myfunc(string& val) { // Do stuff to the string pointer } // sometime later { // ... string s; myfunc(s); // ... }

void myfunc(string* val) { // Do stuff to the string pointer } // sometime later { // ... string s; myfunc(&s); // ... }

myfunc ("cadena * y val") esto en sí mismo no tiene ningún sentido. "string * & val" implica "string val", * y & cancela entre sí. Finalmente, no se puede pasar la variable de cadena a una función ("string val"). Solo se pueden pasar tipos de datos básicos a una función, para que otros tipos de datos deban pasar como puntero o referencia. Puede tener string & val o string * val en una función.

&s produce un puntero temporal a la cadena y no puede hacer referencia al objeto temporal.