Construtor Parametrizado

Parte da seção Programação Orientada a Objetos do Journey de C++ da Coddy — lição 19 de 104.

Um construtor parametrizado aceita argumentos que permitem inicializar um objeto com valores específicos no momento da criação. Em vez de depender de valores padrão, você pode personalizar o 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);

Você pode definir múltiplos construtores parametrizados com diferentes listas de parâmetros. Isso é chamado de sobrecarga de construtores, e o compilador seleciona o apropriado com base nos argumentos que você fornece.

class Rectangle {
    int width, height;
public:
    Rectangle(int side) {          // Quadrado
        width = height = side;
    }
    
    Rectangle(int w, int h) {      // Retângulo
        width = w;
        height = h;
    }
};

Rectangle square(10);        // Chama o primeiro construtor
Rectangle rect(10, 20);      // Chama o segundo construtor

Parâmetros podem ter valores padrão, tornando alguns argumentos opcionais. Isso reduz a necessidade de múltiplos construtores sobrecarregados.

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

Enemy goblin("Goblin");       // damage assume o padrão 10
Enemy dragon("Dragon", 50);   // damage definido como 50

Lembre-se da lição anterior: uma vez que você define um construtor parametrizado, o compilador não gera mais um construtor padrão automaticamente. Se você precisar de ambos, deve definir o construtor padrão explicitamente.

Desafio

Fácil

Vamos construir um sistema de inventário de produtos que demonstra como construtores parametrizados permitem criar objetos com valores iniciais específicos e como a sobrecarga de construtores oferece flexibilidade na criação de objetos.

Você criará dois arquivos para organizar seu código:

Product.h: Defina uma classe Product que representa itens em um inventário. Sua classe deve ter:
- Atributos privados para name (string), price (double), e quantity (inteiro)
- Um construtor que recebe todos os três parâmetros (name, price, quantity) para inicializar totalmente um produto
- Um construtor que recebe apenas name e price, com quantity assumindo o valor padrão 1
- Um construtor que recebe apenas um name, com price assumindo o valor padrão 0.0 e quantity assumindo o valor padrão 0
- Um método display() que imprime as informações do produto no formato: "<name>: "<name>: $<price> (x<quantity>)"lt;price> (x<quantity>)"
- Um método getTotalValue() que retorna o preço multiplicado pela quantidade
main.cpp: Demonstre todos os três construtores lendo a entrada e criando produtos de diferentes maneiras. Leia o seguinte da entrada:
- Primeira linha: um nome de produto, preço e quantidade (separados por espaço)
- Segunda linha: um nome de produto e preço (separados por espaço)
- Terceira linha: apenas um nome de produto
Crie três objetos Product usando o construtor apropriado para cada entrada, chame display() em cada um deles e, em seguida, imprima o valor total dos três produtos combinados no formato: "Total inventory value: "Total inventory value: $<value>"lt;value>"

Para a saída do preço, exiba com uma casa decimal. Por exemplo, se você criar um produto "Laptop" com preço 999.99 e quantidade 5, a exibição deve mostrar "Laptop: $999.99 (x5)".

Inclua seu arquivo de cabeçalho no main.cpp usando #include "Product.h".

Folha de consulta

Um construtor parametrizado aceita argumentos para inicializar um objeto com valores específicos no momento da criação:

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);

A sobrecarga de construtores permite múltiplos construtores com diferentes listas de parâmetros:

class Rectangle {
    int width, height;
public:
    Rectangle(int side) {          // Quadrado
        width = height = side;
    }
    
    Rectangle(int w, int h) {      // Retângulo
        width = w;
        height = h;
    }
};

Rectangle square(10);        // Chama o primeiro construtor
Rectangle rect(10, 20);      // Chama o segundo construtor

Valores de parâmetros padrão tornam os argumentos opcionais:

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

Enemy goblin("Goblin");       // damage assume o padrão 10
Enemy dragon("Dragon", 50);   // damage definido como 50

Uma vez que você define um construtor parametrizado, o compilador não gera mais um construtor padrão automaticamente.

Experimente você mesmo

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

using namespace std;

int main() {
    // Ler o primeiro produto: nome, preço e quantidade
    string name1;
    double price1;
    int quantity1;
    cin >> name1 >> price1 >> quantity1;
    
    // Ler o segundo produto: nome e preço
    string name2;
    double price2;
    cin >> name2 >> price2;
    
    // Ler o terceiro produto: apenas o nome
    string name3;
    cin >> name3;
    
    // TODO: Criar três objetos Product usando o construtor apropriado para cada um
    
    // TODO: Chamar display() em cada produto
    
    // TODO: Calcular e imprimir o valor total do inventário
    // Formato: "Total inventory value: $<value>"
    // Usar fixed e setprecision(1) para uma casa decimal
    
    return 0;
}