¿Cómo puedo cambiar la variable a la que se refiere una referencia de C ++?

Si tengo esto:

int a = 2; int b = 4; int &ref = a; 

¿Cómo puedo hacer referencia a b después de este código?

Esto no es posible, y eso es por diseño . Las referencias no pueden ser rebotadas.

Con C ++ 11 existe la nueva (ish) std :: reference_wrapper .

 #include  int main() { int a = 2; int b = 4; auto ref = std::ref(a); //std::reference_wrapper ref = std::ref(a); <- Or with the type specified ref = std::ref(b); } 

Esto también es útil para almacenar referencias en contenedores.

No puede reasignar una referencia, pero si está buscando algo que le proporcione habilidades similares, puede hacer un puntero en su lugar.

 int a = 2; int b = 4; int* ptr = &a; //ptr points to memory location of a. ptr = &b; //ptr points to memory location of b now. 

Puede obtener o establecer el valor dentro del puntero con:

 *ptr = 5; //set int c = *ptr; //get 

No puedes reasignar una referencia.

Eso no es posible de la manera que quieres. C ++ simplemente no te permite volver a vincular a lo que apunta una referencia.

Sin embargo, si quiere usar trucos, puede simularlo con un nuevo scope ( NUNCA haga esto en un progtwig real):

 int a = 2; int b = 4; int &ref = a; { int& ref = b; // Shadows the original ref so everything inside this { } refers to `ref` as `b` now. } 

Formalmente hablando, eso es imposible, ya que está prohibido por diseño. Arbitrariamente hablando, eso es posible.

Las referencias se almacenan como un puntero, por lo que siempre puede cambiar a dónde apunta siempre y cuando sepa cómo obtener su dirección. Del mismo modo, también puede cambiar el valor de las variables de const, las variables de miembros de const o incluso las variables de miembros privados cuando no tiene acceso.

Por ejemplo, el siguiente código ha cambiado la referencia de miembros privados const de clase A:

 #include  using namespace std; class A{ private: const int &i1; public: A(int &a):i1(a){} int geti(){return i1;} int *getip(){return (int*)&i1;} }; int main(int argc, char *argv[]){ int i=5, j=10; A a(i); cout << "before change:" << endl; cout << "&a.i1=" << a.getip() << " &i=" << &i << " &j="<< &j << endl; cout << "i=" << i << " j=" <
		      	

Puede hacer que un contenedor de referencia sea muy fácil usando la ubicación nueva:

 template< class T > class RefWrapper { public: RefWrapper( T& v ) : m_v( v ){} operator T&(){ return m_v; } T& operator=( const T& a ){ m_v = a; return m_v;} //...... // void remap( T& v ) { //re-map reference new (this) RefWrapper(v); } private: T& m_v; }; int32 a = 0; int32 b = 0; RefWrapper< int > r( a ); r = 1; // a = 1 now r.remap( b ); r = 2; // b = 2 now 

Esto es posible. Porque debajo del capó, la referencia es un puntero. El siguiente código imprimirá “hello world”

 #include "stdlib.h" #include "stdio.h" #include  using namespace std; class ReferenceChange { public: size_t otherVariable; string& ref; ReferenceChange() : ref(*((string*)NULL)) {} void setRef(string& str) { *(&this->otherVariable + 1) = (size_t)&str; } }; void main() { string a("hello"); string b("world"); ReferenceChange rc; rc.setRef(a); printf("%s ", rc.ref.c_str()); rc.setRef(b); printf("%s\n", rc.ref.c_str()); } 

Aunque es una mala idea, ya que no permite el uso de referencias, es posible cambiar la referencia directamente

 const_cast< int& >(ref)=b;