Constructor parametrizado

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 19 de 104.

Un constructor parametrizado acepta argumentos que te permiten inicializar un objeto con valores específicos en el momento de su creación. En lugar de depender de valores por defecto, puedes personalizar el estado inicial de cada objeto.

class Player {
    std::string name;
    int health;
    int level;
public:
    Player(std::string n, int h, int lvl) {
        name = n;
        health = h;
        level = lvl;
    }
};

Player hero("Archer", 100, 5);
Player mage("Wizard", 80, 7);

Puedes definir múltiples constructores parametrizados con diferentes listas de parámetros. Esto se llama sobrecarga de constructores, y el compilador selecciona el adecuado basándose en los argumentos que proporciones.

class Rectangle {
    int width, height;
public:
    Rectangle(int side) {          // Cuadrado
        width = height = side;
    }
    
    Rectangle(int w, int h) {      // Rectángulo
        width = w;
        height = h;
    }
};

Rectangle square(10);        // Llama al primer constructor
Rectangle rect(10, 20);      // Llama al segundo constructor

Los parámetros pueden tener valores predeterminados, lo que hace que algunos argumentos sean opcionales. Esto reduce la necesidad de múltiples constructores sobrecargados.

class Enemy {
    std::string type;
    int damage;
public:
    Enemy(std::string t, int d = 10) : type(t), damage(d) {}
};

Enemy goblin("Goblin");       // el daño por defecto es 10
Enemy dragon("Dragon", 50);   // el daño se establece en 50

Recuerda de la lección anterior: una vez que defines un constructor parametrizado, el compilador ya no genera un constructor por defecto automáticamente. Si necesitas ambos, debes definir el constructor por defecto explícitamente.

Desafío

Fácil

Construyamos un sistema de inventario de productos que demuestre cómo los constructores parametrizados permiten crear objetos con valores iniciales específicos y cómo la sobrecarga de constructores proporciona flexibilidad en la creación de objetos.

Crearás dos archivos para organizar tu código:

Product.h: Define una clase Product que represente artículos en un inventario. Tu clase debe tener:
- Atributos privados para name (string), price (double) y quantity (integer)
- Un constructor que tome los tres parámetros (name, price, quantity) para inicializar completamente un producto
- Un constructor que tome solo name y price, con quantity por defecto en 1
- Un constructor que tome solo un name, con price por defecto en 0.0 y quantity por defecto en 0
- Un método display() que imprima la información del producto en el formato: "<name>: "<name>: $<price> (x<quantity>)"lt;price> (x<quantity>)"
- Un método getTotalValue() que devuelva el precio multiplicado por la cantidad
main.cpp: Demuestra los tres constructores leyendo la entrada y creando productos de diferentes maneras. Lee lo siguiente de la entrada:
- Primera línea: un nombre de producto, precio y cantidad (separados por espacios)
- Segunda línea: un nombre de producto y precio (separados por espacios)
- Tercera línea: solo un nombre de producto
Crea tres objetos Product utilizando el constructor apropiado para cada entrada, llama a display() en cada uno, luego imprime el valor total de los tres productos combinados en el formato: "Total inventory value: "Total inventory value: $<value>"lt;value>"

Para la salida del precio, muéstralo con un decimal. Por ejemplo, si creas un producto "Laptop" con precio 999.99 y cantidad 5, la visualización debería mostrar "Laptop: $999.99 (x5)".

Incluye tu archivo de cabecera en main.cpp usando #include "Product.h".

Hoja de referencia

Un constructor parametrizado acepta argumentos para inicializar un objeto con valores específicos en el momento de su creación:

class Player {
    std::string name;
    int health;
    int level;
public:
    Player(std::string n, int h, int lvl) {
        name = n;
        health = h;
        level = lvl;
    }
};

Player hero("Archer", 100, 5);

La sobrecarga de constructores permite múltiples constructores con diferentes listas de parámetros:

class Rectangle {
    int width, height;
public:
    Rectangle(int side) {          // Cuadrado
        width = height = side;
    }
    
    Rectangle(int w, int h) {      // Rectángulo
        width = w;
        height = h;
    }
};

Rectangle square(10);        // Llama al primer constructor
Rectangle rect(10, 20);      // Llama al segundo constructor

Los valores de parámetros por defecto hacen que los argumentos sean opcionales:

class Enemy {
    std::string type;
    int damage;
public:
    Enemy(std::string t, int d = 10) : type(t), damage(d) {}
};

Enemy goblin("Goblin");       // damage por defecto es 10
Enemy dragon("Dragon", 50);   // damage establecido en 50

Una vez que defines un constructor parametrizado, el compilador ya no genera automáticamente un constructor por defecto.

Pruébalo tú mismo

#include <iostream>
#include <iomanip>
#include <string>
#include "Product.h"

using namespace std;

int main() {
    // Leer el primer producto: nombre, precio y cantidad
    string name1;
    double price1;
    int quantity1;
    cin >> name1 >> price1 >> quantity1;
    
    // Leer el segundo producto: nombre y precio
    string name2;
    double price2;
    cin >> name2 >> price2;
    
    // Leer el tercer producto: solo el nombre
    string name3;
    cin >> name3;
    
    // TODO: Crear tres objetos Product usando el constructor apropiado para cada uno
    
    // TODO: Llamar a display() en cada producto
    
    // TODO: Calcular e imprimir el valor total del inventario
    // Formato: "Total inventory value: $<value>"
    // Usar fixed y setprecision(1) para un lugar decimal
    
    return 0;
}