Operadores de acceso en C++

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.