No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Uso del Puntero This en C++ para Desambiguación y Autorreferencia

11/16
Recursos

¿Qué es el puntero this en programación orientada a objetos?

El puntero this es un elemento crucial en la programación orientada a objetos (OOP) en C++. Este puntero permite que un objeto acceda a sí mismo, facilitando la manipulación de sus propios atributos y métodos. En el contexto de la programación, cada objeto de una clase ocupa una variable independiente. Sin embargo, en situaciones donde un objeto necesita operar sobre sí mismo, el puntero this es indispensable. Permite resolver ambigüedades y realizar acciones que no serían posibles sin él.

¿Cómo se utiliza el puntero this en el código?

Para entender el uso del puntero this, podemos considerar el ejemplo de un objeto que representa a una persona. En este ejemplo, si tenemos una variable nombre para asignarle un valor, podemos usar this->nombre para referirnos a la variable de la clase y diferenciarnos del argumento del constructor o método.

Ejemplo de desambiguación en C++

#include <iostream>

class Persona {
    std::string nombre;
    int edad;
public:
    Persona(std::string n, int e) {
        this->nombre = n;
        this->edad = e;
    }
    
    void establecerNombre(std::string nuevoNombre) {
        this->nombre = nuevoNombre;
    }
    
    void establecerEdad(int nuevaEdad) {
        this->edad = nuevaEdad;
    }
    
    void saludar() {
        std::cout << "Hola, soy " << nombre << " y mi edad es " << edad << std::endl;
    }
};

En el ejemplo, hemos definido una clase Persona que puede actualizar su nombre y edad usando métodos que emplean el puntero this para referirse a las variables de la clase.

¿Cómo se retorna un objeto usando this?

Retornar un objeto usando el puntero this es una técnica avanzada que permite realizar cadenas de métodos de manera eficiente. Se puede lograr que un método, al modificar un atributo, devuelva el propio objeto, permitiendo encadenar múltiples llamadas a métodos en una sola línea.

Ejemplo de encadenamiento de métodos

#include <iostream>

class Persona {
    std::string nombre;
    int edad;
public:
    Persona(std::string n, int e) : nombre(n), edad(e) {}

    Persona& establecerNombre(std::string nuevoNombre) {
        this->nombre = nuevoNombre;
        return *this;
    }
    
    Persona& establecerEdad(int nuevaEdad) {
        this->edad = nuevaEdad;
        return *this;
    }
    
    void saludar() {
        std::cout << "Hola, soy " << nombre << " y mi edad es " << edad << std::endl;
    }
};

int main() {
    Persona persona("Diana", 26);
    persona.establecerNombre("Jimena").establecerEdad(26).saludar();
    persona.establecerNombre("Diana").saludar();
    return 0;
}

En este ejemplo, hemos modificado los métodos establecerNombre y establecerEdad para que devuelvan el objeto en sí mismo utilizando return *this;. Esto permite encadenar los métodos de manera que resulta en una sintaxis más limpia y eficiente.

Consideraciones y beneficios

  • Desambiguación: El uso de this elimina la confusión entre variables locales y de instancia.
  • Encadenamiento: Permite ejecutar múltiples métodos de un objeto en una sola línea, mejorando la legibilidad del código.
  • Flexibilidad: Al devolver el propio objeto, se pueden realizar más operaciones sobre él, facilitando el diseño de APIs más cohesivas en OOP.

Este enfoque que hemos explorado es solo una muestra de las capacidades que this añade a la programación orientada a objetos en C++ y otros lenguajes de programación. Te animamos a seguir practicando y explorando para descubrir más sobre este poderoso concepto. El puntero this es un elemento fundamental que no solo afecta el diseño del código, sino cómo entendemos y aplicamos el paradigma de la orientación a objetos. ¡Sigue aprendiendo!

Aportes 15

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Wow, Lo que realiza al final es impresionante, basicamente cambia el valor y a la vez retorna el objeto al que le esta cambiando el valor, por eso usa el punto, porque si recordamos para acceder a las metodos y atributos de un objeto utilizamos un punto, Wow Diana no puedo creer que este comprendiendo esto, es una locura, eres excelente !!!

Diferencias entre:

Persona &SetNombre(string nombre)
Persona SetNombre(string nombre)

Ambos son válidos.
Con Persona &SetNombre retornas la referencia del mismo objeto.
Con Persona SetNombre retornas un nuevo objeto realizando una copia del objeto actual

Existe otra forma alternativa al this para el constructor, cuando el nombre del parámetro del constructor es el mismo que el del miembro de datos.

A esta forma se le llama “Constructor member initializer lists”.

  • La edad dentro del paréntesis es la que recibimos como parámetro.
  • La edad fuera del paréntesis es this->edad.
// Consructor (Initializer List)
Persona::Persona(string nombre, int edad) : edad(edad), nombre(nombre) {}

¿Es recomendable esta forma?

en visual estudio , pulsas ctrl + r dos veses, para renombras variables o nombres sin tener que rescribirlas en todo lado

No sé si sea yo el único, pero creo que este curso no es muy bueno, realmente da por hecho sabes muchas cosas, creo más bien es para personas que ya saben programar y quieren aprender un lenguaje nuevo.
Cabe destecar que llevo la cronología de los cursos y me pierdo cañón, creo los programadores dan por hecho que ya todos saben lo que saben ellos, a diferencia de los cursos de otras áreas.

OHHHHHHHHHH, ¡¡¡Ahora entiendo!!!
En clases anteriores tenia la duda del por qué no me dejaba tener nombre = nombre en el constructor. Ahora lo tengo claro ❤️

Esto es similar a los metodos Getter y Setter que se usan habitualmente en Java ☕

Podemos notar cómo para acceder a establecerNombrey establecerEdad en la misma línea:

p->establecerNombre("Ximena").establecerEdad(26).establecerNombre("Diana");

al inicio se usa flecha para acceder a un método, y en los siguientes se utiliza punto (y no flecha todo el tiempo).

En las clases anteriores se me ocurrió una idea, que se pudiera desde un Void ingresar información a las variables o actualizarlas, total que no pude hacerlo y no sabía como buscar esta idea por internet, ahora con el puntero This, pude hacerlo.

Se los comparto y si tienen alguna corrección que hacerme me gustaría leerlos, soy muy nuevo en esto de la programación, por lo que sospecho que hay aberraciones en mi código jeje.

#include <iostream>
#include <string>
using  namespace std;

class persona {
private:
    string nombre;
    int edad;
    
public:
    //aquí se establece el constructor y destructor//
    persona (string nombre, int edad) {
        this-> nombre = nombre;
        this-> edad = edad;
    }
    
    ~persona () {}

    //Aquí se aplica el puntero THIS, para autorefenciar y actualizar datos//    
    persona &estnombre (string nombre) {
        this->nombre = nombre;
        cout << "Cuál es su nombre? ";
        cin >> this->nombre;
    
        return *this;
    }
    //el "&" es para indicar que la variable almacena una dirección y "*" antes del return, para que retorne el valor que almacena esa dirección.//
    persona &estedad (int edad) {
        this->edad = edad;
        cout << "Cuál es su edad? ";
        cin >> this->edad;
        return *this;
    }
    
    void saludar () {
        cout << "Hola mi nombre es: " << nombre << ", mi edad es " << edad << endl;
    }
};

int main () {
    persona* p = new persona("Miguel",48);
    
    //Aquí se actualiza los datos, invocando al método PERSONA//
    p->estnombre("");
    p->estedad(0);
    
    //Y luego se invoca al void salud//
    p->saludar();
    delete p;
}

Mi cabeza acaba de explotar al entender que pasa detras de tantos metodos utilizados en el pasado.

Declaracion de función en C++ que retorna un puntero.

Cuando se llama al constructor de una clase, se esta creando un nuevo objeto en memoria (una nueva instancia de la clase) y el constructor sirve para inicializar las variables miembro de esa instancia.
This es un puntero a la dirección de memoria donde esta alojada la propia instancia de la clase, por eso se debe utilizar el operador flecha -> y no el operador punto .

¿Qué es “::”?..Se llama Operador de resolución de alcance y se usa para dar a un elemento como una clase o función un nombre único y totalmente calificado en todo el programa.

por que al primer metodo se lo llama utilizando una flecha y al segundo con un punto

a fuerza de repetición aprenderé POO con los cursos C, C# y C++.