Pasando referencias a punteros en C++

Question

Por lo que puedo ver, no hay ninguna razón por la que 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 estoy recibiendo este error:

cannot convert parameter 1 from 'std::string *' to 'std::string *&'

Answer 1

Su función espera una referencia a un puntero de cadena real en el ámbito de llamada, no un puntero de cadena anónimo. Por lo tanto:

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.

Answer 2

Probar:

void myfunc(string& val) 
{ 
    // Do stuff to the string pointer 
} 

// sometime later 
{ 
    // ... 
    string s; 
    myfunc(s); 
    // ... 
} 

o

void myfunc(string* val) 
{ 
    // Do stuff to the string pointer 
} 

// sometime later 
{ 
    // ... 
    string s; 
    myfunc(&s); 
    // ... 
} 

Answer 3

Cambiar a:

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

EDIT:

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

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

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

} 

Answer 4

Yo sé que es Posible para 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 utilizar punteros de punteros:

Myfunc(String** s) 

Answer 5

&s produce puntero temporal para la cadena y no se puede hacer referencia al objeto temporal.

Answer 6

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

Así que se puede hacer ya sea uno de los siguientes:

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; 
} 

Answer 7

EDIT: He experimentado algunos, y descubrí que son un poco más sutil de lo que pensaba.Esto es lo que ahora creo que es una respuesta precisa.

&s no es un lvalue, por lo que no puede crear una referencia a menos que el tipo de referencia sea const. Así, por ejemplo, no se puede hacer

string * &r = &s; 

pero se puede hacer

string * const &r = &s; 

Si se pone una declaración similar en la cabecera de la función, que va a funcionar.

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

Existe 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, se 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 son temporales. No soy un experto en el estándar.)

Habiendo dicho esto, su problema es probablemente en un nivel superior. ¿Por qué quiere una referencia a la dirección de s? Si desea una referencia a un puntero a s, es necesario definir un puntero como en

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

si quieres una referencia a s o un puntero a s, hacer lo que es sencillo.

Answer 8

myfunc ("cadena * & val") esto en sí mismo no tiene ningún sentido. "string * & val" implica "string val", * y & se cancelan 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 la cadena & val o string * val en una función.

Answer 9

Acabo de utilizar una referencia a un puntero para hacer todos los punteros en un árbol binario borrado 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álido cuando el parámetro formal es el (este) del puntero.

Answer 10

Bienvenido a C++ 11 y rvalue referencias:

#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 usted tiene acceso al valor del puntero (contempladas en el val), que es la dirección de la cadena.

Puede 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 myfunc() regresa. Por fin, es un temporal.