Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » clases

C/Visual C - clases

Volver
Nuevo Tema
<<>>
 
Vista:

clases

Publicado por carlos (1 intervención) el 01/08/2002 03:58:48
necesito entregar esto resuelto para un final y no lo puedo sacar, alguien me daria una mano..... un trillon de gracias
UN FABRICANTE DE COMPUTADORAS NECESITA REGISTRAR DATOS SOBRE SUS EQUIPOS. Los productos estan organizados en familias o grupos de productos, entro de la cual existen variantes en cuanto a los componentes que lo forman y cada una de estas es un nuevo producto. Ademas, cada equipo puede distribuirse con adicionales (memoria, mas discos, etc). El precio de cada producto standard esta definido para el producto, pero para cada equipo particular el precio se obtiene de la suma de este precio standard mas los adicionales o diferencias. Modele una jerarquia de clases para esta situacion e implemente los metodos mas relevantes. (al menos 4).

Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Modelado de productos de computadoras

Publicado por Alejandro (913 intervenciones) el 12/03/2025 19:47:52
Para resolver el problema planteado, podemos crear una jerarquía de clases en C++ que represente los productos de computadoras, sus variantes y los adicionales. A continuación, se presenta un modelo básico que incluye las clases necesarias y algunos métodos relevantes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
#include <iostream>
#include <string>
#include <vector>
 
// Clase base para un Producto
class Producto {
protected:
    std::string nombre;
    double precioBase;
 
public:
    Producto(std::string n, double p) : nombre(n), precioBase(p) {}
 
    virtual double obtenerPrecio() const {
        return precioBase;
    }
 
    virtual std::string obtenerDescripcion() const {
        return nombre + " (Precio base: " + std::to_string(precioBase) + ")";
    }
};
 
// Clase derivada para un Producto con Variantes
class ProductoConVariantes : public Producto {
private:
    std::vector<std::string> variantes;
 
public:
    ProductoConVariantes(std::string n, double p) : Producto(n, p) {}
 
    void agregarVariante(const std::string& variante) {
        variantes.push_back(variante);
    }
 
    std::string obtenerDescripcion() const override {
        std::string desc = Producto::obtenerDescripcion() + "\nVariantes: ";
        for (const auto& variante : variantes) {
            desc += variante + " ";
        }
        return desc;
    }
};
 
// Clase para Adicionales
class Adicional {
private:
    std::string nombre;
    double precio;
 
public:
    Adicional(std::string n, double p) : nombre(n), precio(p) {}
 
    double obtenerPrecio() const {
        return precio;
    }
 
    std::string obtenerNombre() const {
        return nombre;
    }
};
 
// Clase para un Producto Final que incluye Adicionales
class ProductoFinal : public Producto {
private:
    std::vector<Adicional> adicionales;
 
public:
    ProductoFinal(std::string n, double p) : Producto(n, p) {}
 
    void agregarAdicional(const Adicional& adicional) {
        adicionales.push_back(adicional);
    }
 
    double obtenerPrecio() const override {
        double precioTotal = Producto::obtenerPrecio();
        for (const auto& adicional : adicionales) {
            precioTotal += adicional.obtenerPrecio();
        }
        return precioTotal;
    }
 
    std::string obtenerDescripcion() const override {
        std::string desc = Producto::obtenerDescripcion() + "\nAdicionales: ";
        for (const auto& adicional : adicionales) {
            desc += adicional.obtenerNombre() + " (Precio: " + std::to_string(adicional.obtenerPrecio()) + ") ";
        }
        return desc;
    }
};
 
int main() {
    // Crear un producto estándar
    ProductoConVariantes laptop("Laptop gamer", 1200.00);
    laptop.agregarVariante("16GB RAM");
    laptop.agregarVariante("1TB SSD");
 
    // Crear un producto final con adicionales
    ProductoFinal laptopConAdicionales("Laptop gamer", 1200.00);
    laptopConAdicionales.agregarAdicional(Adicional("Memoria extra", 200.00));
    laptopConAdicionales.agregarAdicional(Adicional("Disco duro adicional", 150.00));
 
    // Mostrar descripciones y precios
    std::cout << laptop.obtenerDescripcion() << std::endl;
    std::cout << "Precio estándar: " << laptop.obtenerPrecio() << std::endl;
 
    std::cout << std::endl;
 
    std::cout << laptopConAdicionales.obtenerDescripcion() << std::endl;
    std::cout << "Precio total: " << laptopConAdicionales.obtenerPrecio() << std::endl;
 
    return 0;
}

Métodos relevantes implementados:


1. obtenerPrecio(): Calcula y devuelve el precio total del producto, considerando los adicionales.
2. obtenerDescripcion(): Devuelve una descripción detallada del producto, incluyendo variantes y adicionales.
3. agregarVariante(): Permite agregar variantes a un producto con variantes.
4. agregarAdicional(): Permite agregar adicionales a un producto final.

Este modelo proporciona una base sólida para registrar y gestionar los datos de los productos de computadoras, permitiendo la extensión y personalización según sea necesario. ¡Buena suerte con tu entrega, Carlos!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar