Crear clases y objetos en C++

Introducción

En este laboratorio, aprenderás cómo crear clases y objetos en la programación C++. Definirás clases con miembros de datos privados, implementarás funciones miembro públicas, crearás constructores con diferentes parámetros, escribirás destructores para la limpieza de recursos, usarás especificadores de acceso, implementarás la herencia entre clases, sobrescribirás métodos de la clase base, crearás funciones amigas para el control de acceso y usarás miembros y métodos estáticos. Estos conceptos son fundamentales para la programación orientada a objetos en C++ y proporcionarán una base sólida para la construcción de aplicaciones más complejas.

Este es un Guided Lab, que proporciona instrucciones paso a paso para ayudarte a aprender y practicar. Sigue las instrucciones cuidadosamente para completar cada paso y obtener experiencia práctica. Los datos históricos muestran que este es un laboratorio de nivel principiante con una tasa de finalización del 85%. Ha recibido una tasa de reseñas positivas del 100% por parte de los estudiantes.

Definir una clase con miembros de datos privados

Una clase en C++ es un modelo para crear objetos. Define un conjunto de propiedades (miembros de datos) y métodos (funciones miembro) que tendrán los objetos creados a partir de la clase. Las clases ayudan a organizar el código e implementar principios de programación orientada a objetos como la encapsulación, la herencia y el polimorfismo.

La sintaxis básica para definir una clase en C++ es la siguiente:

class ClassName {
private:
    // Private data members
    int dataMember1;
    std::string dataMember2;

public:
    // Public member functions
    void memberFunction1();
    int memberFunction2();
};

Hay tres especificadores de acceso en C++ que controlan la visibilidad y accesibilidad de los miembros de una clase:

private: Los miembros declarados como privados son accesibles solo dentro de la clase.
public: Los miembros declarados como públicos son accesibles desde fuera de la clase.
protected: Los miembros declarados como protegidos son accesibles dentro de la clase y por instancias de clases derivadas.

En este paso, aprenderás cómo definir una clase con miembros de datos privados en C++. Los miembros de datos privados son un concepto esencial en la programación orientada a objetos que ayuda a encapsular y proteger el estado interno de un objeto.

Primero, abre el WebIDE y navega hasta el directorio ~/project. Crea un nuevo archivo llamado student.cpp:

touch ~/project/student.cpp

Abre el archivo student.cpp en el WebIDE y agrega el siguiente código para definir una clase Student con miembros de datos privados:

#include <iostream>
#include <string>

class Student {
private:
    // Private data members
    std::string name;
    int age;
    double gpa;

public:
    // We'll add methods to interact with these private members in later steps
    void displayInfo() {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    Student student;
    // Note: We can't directly access private members
    // student.name = "John"; // This would cause a compilation error

    student.displayInfo();
    return 0;
}

Analicemos los conceptos clave:

Miembros de datos privados:
- Declarados usando el especificador de acceso private:
- No se pueden acceder directamente desde fuera de la clase
- Proporcionan protección y encapsulación de datos
Tipos de datos:
- std::string name: Almacena el nombre del estudiante
- int age: Almacena la edad del estudiante
- double gpa: Almacena el promedio académico del estudiante
Encapsulación:
- Los miembros privados solo se pueden acceder a través de métodos públicos
- Evita la modificación directa de los datos internos

Compila el programa:

g++ student.cpp -o student
./student

Ejemplo de salida al ejecutar el programa:

Name:
Age: 0
GPA: 0

Puntos clave:

Los miembros privados están ocultos para el acceso desde fuera
Solo se pueden modificar a través de métodos de la clase
Esto ayuda a mantener la integridad y el control de los datos

Implementar funciones miembro públicas

En este paso, aprenderás cómo implementar funciones miembro públicas en C++. Las funciones miembro públicas permiten un acceso controlado a los miembros de datos privados y proporcionan formas de interactuar con los objetos de la clase.

Abre el archivo student.cpp en el WebIDE y modifica la clase Student para incluir funciones miembro públicas:

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    double gpa;

public:
    // Setter methods to modify private data members
    void setName(std::string studentName) {
        name = studentName;
    }

    void setAge(int studentAge) {
        if (studentAge > 0 && studentAge < 120) {
            age = studentAge;
        } else {
            std::cout << "Invalid age!" << std::endl;
        }
    }

    void setGPA(double studentGPA) {
        if (studentGPA >= 0.0 && studentGPA <= 4.0) {
            gpa = studentGPA;
        } else {
            std::cout << "Invalid GPA!" << std::endl;
        }
    }

    // Getter methods to access private data members
    std::string getName() {
        return name;
    }

    int getAge() {
        return age;
    }

    double getGPA() {
        return gpa;
    }

    // Display method to print student information
    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    Student student;

    // Using public member functions to set and get data
    student.setName("Alice Johnson");
    student.setAge(20);
    student.setGPA(3.75);

    // Display student information
    student.displayInfo();

    // Demonstrate getter methods
    std::cout << "\nStudent Name: " << student.getName() << std::endl;
    std::cout << "Student Age: " << student.getAge() << std::endl;
    std::cout << "Student GPA: " << student.getGPA() << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.75

Student Name: Alice Johnson
Student Age: 20
Student GPA: 3.75

Puntos clave sobre las funciones miembro públicas:

Proporcionan un acceso controlado a los miembros de datos privados
Los métodos "setter" permiten la modificación con validación
Los métodos "getter" permiten leer los datos privados
Ayudan a mantener la encapsulación y la integridad de los datos

Crear constructores con diferentes parámetros

En este paso, aprenderás cómo crear constructores con diferentes parámetros en C++. Los constructores son funciones miembro especiales que inicializan los objetos cuando se crean.

Abre el archivo student.cpp en el WebIDE y modifica la clase Student para incluir múltiples constructores:

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    double gpa;

public:
    // Default constructor
    Student() {
        name = "Unknown";
        age = 0;
        gpa = 0.0;
    }

    // Constructor with name parameter
    Student(std::string studentName) {
        name = studentName;
        age = 0;
        gpa = 0.0;
    }

    // Constructor with name and age parameters
    Student(std::string studentName, int studentAge) {
        name = studentName;
        age = studentAge;
        gpa = 0.0;
    }

    // Full constructor with all parameters
    Student(std::string studentName, int studentAge, double studentGPA) {
        name = studentName;
        age = studentAge;
        gpa = studentGPA;
    }

    // Display method to print student information
    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    // Using different constructors
    Student student1;  // Default constructor
    Student student2("Alice Johnson");  // Constructor with name
    Student student3("Bob Smith", 22);  // Constructor with name and age
    Student student4("Charlie Brown", 20, 3.75);  // Full constructor

    std::cout << "Student 1:" << std::endl;
    student1.displayInfo();

    std::cout << "\nStudent 2:" << std::endl;
    student2.displayInfo();

    std::cout << "\nStudent 3:" << std::endl;
    student3.displayInfo();

    std::cout << "\nStudent 4:" << std::endl;
    student4.displayInfo();

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Student 1:
Student Information:
Name: Unknown
Age: 0
GPA: 0

Student 2:
Student Information:
Name: Alice Johnson
Age: 0
GPA: 0

Student 3:
Student Information:
Name: Bob Smith
Age: 22
GPA: 0

Student 4:
Student Information:
Name: Charlie Brown
Age: 20
GPA: 3.75

Puntos clave sobre los constructores:

Los constructores tienen el mismo nombre que la clase
Inicializan los miembros de datos del objeto
Pueden haber múltiples constructores con diferentes parámetros
Se llaman automáticamente cuando se crea un objeto

Escribir un destructor para la limpieza de recursos

En este paso, aprenderás sobre los destructores en C++, que son funciones miembro especiales responsables de limpiar los recursos cuando un objeto es destruido. Demostraremos cómo escribir un destructor y entender su importancia en la gestión de memoria.

Abre el archivo student.cpp en el WebIDE y modifica el código para incluir un destructor y asignación dinámica de memoria:

#include <iostream>
#include <string>

class Student {
private:
    std::string name;
    int age;
    double gpa;
    char* dynamicBuffer;  // Simulating dynamic memory allocation

public:
    // Constructors
    Student() {
        name = "Unknown";
        age = 0;
        gpa = 0.0;
        dynamicBuffer = new char[50];  // Allocate dynamic memory
        std::cout << "Default Constructor Called" << std::endl;
    }

    Student(std::string studentName) : name(studentName), age(0), gpa(0.0) {
        dynamicBuffer = new char[50];
        std::cout << "Parameterized Constructor Called" << std::endl;
    }

    // Destructor
    ~Student() {
        // Clean up dynamically allocated memory
        delete[] dynamicBuffer;
        std::cout << "Destructor Called for " << name << std::endl;
    }

    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
    }
};

int main() {
    // Demonstrating object creation and destruction
    {
        std::cout << "Creating first student:" << std::endl;
        Student student1("Alice Johnson");
        student1.displayInfo();

        std::cout << "\nCreating second student:" << std::endl;
        Student student2("Bob Smith");
        student2.displayInfo();
    }  // Objects go out of scope here, destructors are called

    std::cout << "\nExiting main function" << std::endl;
    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Creating first student:
Parameterized Constructor Called
Student Information:
Name: Alice Johnson
Age: 0
GPA: 0

Creating second student:
Parameterized Constructor Called
Student Information:
Name: Bob Smith
Age: 0
GPA: 0

Destructor Called for Bob Smith
Destructor Called for Alice Johnson

Exiting main function

Puntos clave sobre los destructores:

Definidos con ~ seguido del nombre de la clase
Llamados automáticamente cuando un objeto es destruido
Utilizados para liberar recursos asignados dinámicamente
Ayudan a prevenir fugas de memoria
No tienen tipo de retorno ni parámetros

Características importantes de los destructores:

Llamados cuando un objeto sale de su ámbito (scope)
Invocados automáticamente por el compilador
Cruciales para la limpieza de memoria dinámica
Ayudan a gestionar eficientemente los recursos del sistema

Utilizar especificadores de acceso (público, privado, protegido)

En este paso, aprenderás sobre los especificadores de acceso en C++ y cómo controlan la visibilidad y accesibilidad de los miembros de una clase. Exploraremos las diferencias entre los niveles de acceso público, privado y protegido.

Abre el archivo student.cpp en el WebIDE y modifica el código para demostrar los especificadores de acceso:

#include <iostream>
#include <string>

class Student {
private:
    // Private members: accessible only within the class
    std::string name;
    int age;
    double gpa;

protected:
    // Protected members: accessible within the class and its derived classes
    std::string school;

public:
    // Public members: accessible from anywhere
    Student(std::string studentName, int studentAge, double studentGPA) {
        name = studentName;
        age = studentAge;
        gpa = studentGPA;
        school = "Default School";
    }

    // Public method to demonstrate access to private members
    void displayInfo() {
        std::cout << "Student Information:" << std::endl;
        std::cout << "Name: " << name << std::endl;  // Accessing private member
        std::cout << "Age: " << age << std::endl;
        std::cout << "GPA: " << gpa << std::endl;
        std::cout << "School: " << school << std::endl;
    }

    // Public method to modify private members
    void updateGPA(double newGPA) {
        if (newGPA >= 0.0 && newGPA <= 4.0) {
            gpa = newGPA;
        }
    }
};

class GraduateStudent : public Student {
public:
    GraduateStudent(std::string name, int age, double gpa)
        : Student(name, age, gpa) {
        // Can access protected 'school' member from base class
        school = "Graduate School";
    }

    void displaySchool() {
        std::cout << "School: " << school << std::endl;
    }
};

int main() {
    Student student("Alice Johnson", 20, 3.75);
    student.displayInfo();  // Public method accessing private members

    // Uncommenting the lines below would cause compilation errors
    // student.name = "John";  // Error: Cannot access private member
    // student.age = 25;       // Error: Cannot access private member

    student.updateGPA(3.90);  // Modifying private member through public method
    student.displayInfo();

    GraduateStudent gradStudent("Bob Smith", 25, 3.90);
    gradStudent.displayInfo();
    gradStudent.displaySchool();

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.75
School: Default School
Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.90
School: Default School
Student Information:
Name: Bob Smith
Age: 25
GPA: 3.90
School: Graduate School
School: Graduate School

Puntos clave sobre los especificadores de acceso:

private: Los miembros solo son accesibles dentro de la misma clase
protected: Los miembros son accesibles dentro de la clase y sus clases derivadas
public: Los miembros son accesibles desde cualquier lugar
Ayudan a controlar el acceso a los datos y a mantener la encapsulación

Implementar herencia entre clases

En este paso, aprenderás sobre la herencia en C++, un concepto fundamental de la programación orientada a objetos que permite crear nuevas clases basadas en clases existentes.

Abre el archivo student.cpp en el WebIDE y modifica el código para demostrar la herencia:

#include <iostream>
#include <string>

// Base class
class Person {
protected:
    std::string name;
    int age;

public:
    // Constructor
    Person(std::string personName, int personAge) {
        name = personName;
        age = personAge;
    }

    // Method to display basic information
    void displayInfo() {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
    }
};

// Derived class: Student inherits from Person
class Student : public Person {
private:
    double gpa;
    std::string major;

public:
    // Constructor that calls base class constructor
    Student(std::string studentName, int studentAge, double studentGPA, std::string studentMajor)
        : Person(studentName, studentAge) {
        gpa = studentGPA;
        major = studentMajor;
    }

    // Additional method specific to Student
    void displayStudentInfo() {
        // Calling base class method
        displayInfo();
        std::cout << "GPA: " << gpa << std::endl;
        std::cout << "Major: " << major << std::endl;
    }
};

// Another derived class: Employee inherits from Person
class Employee : public Person {
private:
    std::string company;
    double salary;

public:
    // Constructor that calls base class constructor
    Employee(std::string employeeName, int employeeAge, std::string employeeCompany, double employeeSalary)
        : Person(employeeName, employeeAge) {
        company = employeeCompany;
        salary = employeeSalary;
    }

    // Additional method specific to Employee
    void displayEmployeeInfo() {
        // Calling base class method
        displayInfo();
        std::cout << "Company: " << company << std::endl;
        std::cout << "Salary: $" << salary << std::endl;
    }
};

int main() {
    // Creating objects of derived classes
    Student student("Alice Johnson", 20, 3.75, "Computer Science");
    std::cout << "Student Information:" << std::endl;
    student.displayStudentInfo();

    std::cout << "\n";

    Employee employee("Bob Smith", 35, "Tech Corp", 75000.0);
    std::cout << "Employee Information:" << std::endl;
    employee.displayEmployeeInfo();

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Student Information:
Name: Alice Johnson
Age: 20
GPA: 3.75
Major: Computer Science

Employee Information:
Name: Bob Smith
Age: 35
Company: Tech Corp
Salary: $75000

Puntos clave sobre la herencia:

La clase base (Person) contiene atributos comunes
Las clases derivadas (Student, Employee) heredan de la clase base
Utiliza : public BaseClassName para heredar
Se pueden agregar nuevos atributos y métodos en las clases derivadas
Se pueden utilizar métodos de la clase base en las clases derivadas

Sobrescribir métodos de la clase base

En este paso, aprenderás cómo sobrescribir métodos de la clase base en C++, lo que permite a las clases derivadas proporcionar su propia implementación de los métodos heredados de la clase base.

Abre el archivo student.cpp en el WebIDE y modifica el código para demostrar la sobrescritura de métodos:

#include <iostream>
#include <string>

class Animal {
protected:
    std::string name;

public:
    Animal(std::string animalName) : name(animalName) {}

    // Virtual keyword allows method to be overridden
    virtual void makeSound() {
        std::cout << "Some generic animal sound" << std::endl;
    }

    // Virtual method for displaying information
    virtual void displayInfo() {
        std::cout << "Animal Name: " << name << std::endl;
    }
};

class Dog : public Animal {
private:
    std::string breed;

public:
    Dog(std::string dogName, std::string dogBreed)
        : Animal(dogName), breed(dogBreed) {}

    // Override makeSound method
    void makeSound() override {
        std::cout << "Woof! Woof!" << std::endl;
    }

    // Override displayInfo method
    void displayInfo() override {
        // Call base class method first
        Animal::displayInfo();
        std::cout << "Breed: " << breed << std::endl;
    }
};

class Cat : public Animal {
private:
    std::string color;

public:
    Cat(std::string catName, std::string catColor)
        : Animal(catName), color(catColor) {}

    // Override makeSound method
    void makeSound() override {
        std::cout << "Meow! Meow!" << std::endl;
    }

    // Override displayInfo method
    void displayInfo() override {
        // Call base class method first
        Animal::displayInfo();
        std::cout << "Color: " << color << std::endl;
    }
};

int main() {
    // Create animal objects
    Animal genericAnimal("Generic Animal");
    Dog myDog("Buddy", "Labrador");
    Cat myCat("Whiskers", "Orange");

    // Demonstrate polymorphic behavior
    std::cout << "Generic Animal:" << std::endl;
    genericAnimal.displayInfo();
    genericAnimal.makeSound();

    std::cout << "\nDog:" << std::endl;
    myDog.displayInfo();
    myDog.makeSound();

    std::cout << "\nCat:" << std::endl;
    myCat.displayInfo();
    myCat.makeSound();

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Generic Animal:
Animal Name: Generic Animal
Some generic animal sound

Dog:
Animal Name: Buddy
Breed: Labrador
Woof! Woof!

Cat:
Animal Name: Whiskers
Color: Orange
Meow! Meow!

Puntos clave sobre la sobrescritura de métodos:

Utiliza la palabra clave virtual en la clase base para habilitar la sobrescritura
Utiliza la palabra clave override en la clase derivada para sobrescribir explícitamente
Puedes llamar al método de la clase base utilizando BaseClass::method()
Permite diferentes implementaciones para el mismo método
Habilita el comportamiento polimórfico

Crear funciones amigas para control de acceso

En este paso, aprenderás sobre las funciones amigas en C++, que permiten a funciones externas u otras clases acceder a los miembros privados y protegidos de una clase.

Abre el archivo student.cpp en el WebIDE y modifica el código para demostrar las funciones amigas:

#include <iostream>
#include <string>

class BankAccount {
private:
    std::string accountHolder;
    double balance;

    // Declare friend functions
    friend void displayAccountDetails(const BankAccount& account);
    friend class AccountManager;

public:
    // Constructor
    BankAccount(std::string name, double initialBalance) {
        accountHolder = name;
        balance = initialBalance;
    }

    // Method to deposit money
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
};

// Friend function that can access private members
void displayAccountDetails(const BankAccount& account) {
    std::cout << "Account Holder: " << account.accountHolder << std::endl;
    std::cout << "Current Balance: $" << account.balance << std::endl;
}

// Friend class that can access private members
class AccountManager {
public:
    // Method that can access private members of BankAccount
    void transferFunds(BankAccount& from, BankAccount& to, double amount) {
        if (from.balance >= amount) {
            from.balance -= amount;
            to.balance += amount;
            std::cout << "Transfer successful!" << std::endl;
        } else {
            std::cout << "Insufficient funds!" << std::endl;
        }
    }
};

int main() {
    // Create bank accounts
    BankAccount account1("Alice Johnson", 1000.0);
    BankAccount account2("Bob Smith", 500.0);

    // Use friend function to display account details
    std::cout << "Account 1 Details:" << std::endl;
    displayAccountDetails(account1);

    std::cout << "\nAccount 2 Details:" << std::endl;
    displayAccountDetails(account2);

    // Use friend class to transfer funds
    AccountManager manager;
    std::cout << "\nTransferring $200 from Alice to Bob:" << std::endl;
    manager.transferFunds(account1, account2, 200.0);

    std::cout << "\nUpdated Account Details:" << std::endl;
    displayAccountDetails(account1);
    displayAccountDetails(account2);

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

Account 1 Details:
Account Holder: Alice Johnson
Current Balance: $1000

Account 2 Details:
Account Holder: Bob Smith
Current Balance: $500

Transferring $200 from Alice to Bob:
Transfer successful!

Updated Account Details:
Account Holder: Alice Johnson
Current Balance: $800
Account Holder: Bob Smith
Current Balance: $700

Puntos clave sobre las funciones amigas:

Se declaran utilizando la palabra clave friend
Pueden acceder a los miembros privados y protegidos de una clase
Se declaran dentro de la definición de la clase
Pueden ser funciones individuales o clases enteras
Rompen la encapsulación, así que úsalas con moderación

Utilizar miembros y métodos estáticos

En este paso, aprenderás sobre los miembros y métodos estáticos en C++, que se comparten entre todas las instancias de una clase y pertenecen a la clase misma en lugar de a objetos individuales.

Abre el archivo student.cpp en el WebIDE y modifica el código para demostrar los miembros y métodos estáticos:

#include <iostream>
#include <string>

class University {
private:
    std::string name;
    static int totalStudents;  // Static member variable
    static double totalTuition;  // Another static member variable

public:
    // Constructor
    University(std::string universityName) : name(universityName) {}

    // Method to add students
    void addStudents(int count) {
        totalStudents += count;
    }

    // Method to add tuition
    void addTuition(double amount) {
        totalTuition += amount;
    }

    // Static method to display total students
    static void displayTotalStudents() {
        std::cout << "Total Students Across All Universities: "
                  << totalStudents << std::endl;
    }

    // Static method to display total tuition
    static void displayTotalTuition() {
        std::cout << "Total Tuition Collected: $"
                  << totalTuition << std::endl;
    }

    // Static method to calculate average tuition
    static double calculateAverageTuition() {
        return (totalStudents > 0)?
               (totalTuition / totalStudents) : 0.0;
    }
};

// Initialize static member variables outside the class
int University::totalStudents = 0;
double University::totalTuition = 0.0;

int main() {
    // Create university objects
    University harvard("Harvard University");
    University mit("MIT");
    University stanford("Stanford University");

    // Add students and tuition
    harvard.addStudents(5000);
    harvard.addTuition(75000000.0);

    mit.addStudents(4500);
    mit.addTuition(65000000.0);

    stanford.addStudents(4200);
    stanford.addTuition(60000000.0);

    // Call static methods directly on the class
    std::cout << "University Statistics:" << std::endl;
    University::displayTotalStudents();
    University::displayTotalTuition();

    // Calculate and display average tuition
    std::cout << "Average Tuition per Student: $"
              << University::calculateAverageTuition() << std::endl;

    return 0;
}

Compila y ejecuta el programa:

g++ student.cpp -o student
./student

Ejemplo de salida:

University Statistics:
Total Students Across All Universities: 13700
Total Tuition Collected: $2e+08
Average Tuition per Student: $14598.5

Puntos clave sobre los miembros y métodos estáticos:

Se comparten entre todas las instancias de una clase
Se declaran utilizando la palabra clave static
Pueden ser accedidos sin crear un objeto
Pertenece a la clase, no a objetos individuales
Son útiles para realizar un seguimiento de la información a nivel de clase

Resumen

En este laboratorio, aprendiste cómo definir una clase con miembros de datos privados, que es un concepto esencial en la programación orientada a objetos. Los miembros de datos privados ayudan a encapsular y proteger el estado interno de un objeto. También aprendiste sobre la importancia de las funciones miembro públicas, que permiten un acceso controlado a los miembros de datos privados. Esto ayuda a mantener la integridad y el control de los datos. Además, exploraste el uso de constructores, destructores, especificadores de acceso, herencia, sobrescritura de métodos, funciones amigas (friend functions) y miembros y métodos estáticos, todos ellos principios fundamentales de la programación orientada a objetos en C++.