Los operadores de acceso en C++ nos permiten acceder miembros de clases y estructuras (a sus variables y métodos) o a elementos de colecciones..
Operador de Punto (.
)
El operador de punto (.
) es el operador de acceso más común en C++. Se utiliza para acceder a los miembros de una clase o estructura (incluyendo propiedades, métodos y campos).
Por ejemplo, si tenemos esta clase:
class Persona {
public:
std::string nombre;
void saludar() {
std::cout << "Hola, soy " << nombre << std::endl;
}
};
Podemos usar el operador punto .
para acceder a la propiedad nombre
o al método saludar()
.
Persona persona;
persona.nombre = "Carlos";
persona.saludar(); // Imprime: Hola, soy Carlos
En este ejemplo, el operador .
se usa para asignar un valor a nombre
y para llamar al método saludar()
.
Operador de Índice ([]
)
El operador de índice ([]
) se utiliza para acceder a los elementos de arrays y colecciones que implementan un índice.
Acceso a elementos de una colección
#include <iostream>
#include <vector>
int main() {
std::vector<std::string> nombres = {"Ana", "Luis", "Pedro"};
std::string nombre = nombres[1];
std::cout << nombre << std::endl; // Imprime: Luis
return 0;
}
En este caso, el operador []
se usa para acceder al segundo elemento del vector nombres
.
Operador de Miembro de Puntero (->
)
En C++ también se utiliza el operador de miembro de puntero (->
) para acceder a los miembros de un objeto a través de un puntero.
class Persona {
public:
std::string nombre;
void saludar() {
std::cout << "Hola, soy " << nombre << std::endl;
}
};
int main() {
Persona* persona = new Persona();
persona->nombre = "Carlos";
persona->saludar(); // Imprime: Hola, soy Carlos
delete persona;
return 0;
}
En este ejemplo, el operador ->
se usa para acceder a nombre
y saludar()
a través del puntero persona
.
Manejo de Punteros Inteligentes
Con la introducción de punteros inteligentes en C++11, como std::shared_ptr
y std::unique_ptr
, el operador ->
también se utiliza para acceder a los miembros de los objetos gestionados por estos punteros.
#include <iostream>
#include <memory>
class Persona {
public:
std::string nombre;
void saludar() {
std::cout << "Hola, soy " << nombre << std::endl;
}
};
int main() {
std::shared_ptr<Persona> persona = std::make_shared<Persona>();
persona->nombre = "Carlos";
persona->saludar(); // Imprime: Hola, soy Carlos
return 0;
}
En este caso, persona
es un std::shared_ptr
que gestiona un objeto Persona
, y el operador ->
se usa para acceder a los miembros del objeto.