UNIVERSIDAD CATÓLICA DE SANTA MARÍA

ESCUELA PROFESIONAL DE INGENERÍA DE SISTEMAS

Lenguajes de Programación II
Actividad N° 09

CÓDIGO APELLIDOS Y NOMBRES FECHA PARTICIPACIÓN

202020122 Chávez Barrios Tatyana Mykaela 24/06/202 SI
2 1
201320409 Soto Hizo Diego Humberto 24/06/202 SI
1 1
201782615 Tarqui Gómez Bryan Carlos 24/06/202 NO
1 1
202080326 Valverde Riveros María Fernanda 24/06/202 SI
2 1
201522321 Vargas Pareja Fredy Frans 24/06/202 NO
1 1

1. Desarrolle la clase Articulo con un atributo y el método constructor.

#pragma once
#include <iostream>
using namespace std;
//articulo.h
class Articulo
{
private:
char nombre;
double precio;
public:
Articulo(const char[20], double);
char* getNombre();
void setNombre(char*);
virtual double getPrecio();
};

#include "articulo.h"
//articulo.cpp
Articulo::Articulo(const char _nombre [20], double _precio)
{
nombre =* _nombre;
precio = _precio;
};

char* Articulo::getNombre()
{
cout << "Nombre del articulo: " << nombre << endl;
};
void Articulo::setNombre(const char_nuevoNombre [20])
{
nombre =* _nuevoNombre;
};
double Articulo::getPrecio()
{
cout << "Precio: " << precio << endl;
 UNIVERSIDAD CATÓLICA DE SANTA MARÍA
ESCUELA PROFESIONAL DE INGENERÍA DE SISTEMAS
};

2. Crear tres clases Camisa, Pantalon y Camiseta derivadas de Articulo, cada una
con un atributo y los operadores << y >> sobrecargados.
#pragma once
#include "articulo.h"
#include <iostream>
using namespace std;
//camisa.h
class Camisa : public Articulo
{
private:
string marca;
public:
Camisa(const char[20], double, string);
friend istream& operator>>(istream&, Camisa&);
friend ostream& operator<<(ostream&, Camisa&);
};

#include "camisa.h"
//camisa.cpp
Camisa::Camisa(const char nombre[20], double precio, string
mCami) : Articulo(nombre, precio)
{
marca = mCami;
}
istream& operator>>(istream& in, Camisa& objetoCamisa)
{
in >> objetoCamisa.marca;
return in;
}
ostream& operator<<(ostream& out, Camisa& objetoCamisa)
{
out << "Marca: " << objetoCamisa.marca << endl;
return out;
}

#pragma once
#include "articulo.h"
#include <iostream>
using namespace std;
//Camiseta.h
class Camiseta : public Articulo
{
private:
string color;
public:
Camiseta(const char[20], double, string);
friend istream& operator>>(istream&, Camiseta&);
friend ostream& operator<<(ostream&, Camiseta&);
};

#include "camiseta.h"
//camiseta.cpp
Camiseta::Camiseta(const char nombre[20], double precio, string
cCst) : Articulo(nombre, precio)
 UNIVERSIDAD CATÓLICA DE SANTA MARÍA
ESCUELA PROFESIONAL DE INGENERÍA DE SISTEMAS
{
color = cCst;
}
istream& operator>>(istream& in, Camiseta& objetoCamiseta)
{
in >> objetoCamiseta.color;
return in;
}
ostream& operator<<(ostream& out, Camiseta& objetoCamiseta)
{
out << "Color: " << objetoCamiseta.color << endl;
return out;
}

#pragma once
#include "articulo.h"
#include <iostream>
//pantalon.h
using namespace std;
class Pantalon : public Articulo
{
private:
string talla;
public:
Pantalon(const char[20], double, string);
friend istream& operator>>(istream&, Pantalon&);
friend ostream& operator<<(ostream&, Pantalon&);
};

#include "pantalon.h"
//pantalon.cpp
Pantalon::Pantalon(const char nombre[20], double precio, string
tPant) : Articulo(nombre, precio)
{
talla = tPant;
}
istream& operator>>(istream& in, Pantalon& objetoPantalon)
{
in >> objetoPantalon.talla;
return in;
}
ostream& operator<<(ostream& out, Pantalon& objetoPantalon)
{
out << "Talla: " << objetoPantalon.talla << endl;
return out;
}

3. Crear una plantilla de clase llamada Maleta con un puntero doble tipo Articulo
como atributo(apunta a un arreglo de punteros dinámico de objetos Articulo) y
los atributos enteros capacidad(cantidad de objetos articulo que puede
almacenar) y cantidad(número de artículos enteros que puede almacenar) con
los operadores de entrada y salida sobrecargados).
#pragma once
#include <iostream>
using namespace std;
//maleta.h
 UNIVERSIDAD CATÓLICA DE SANTA MARÍA
ESCUELA PROFESIONAL DE INGENERÍA DE SISTEMAS
template <typename TipoDato>
class Maleta
{
TipoDato** contenido;
int capacidad;
int cantidad;
public:
friend ostream& operator << (ostream&, Maleta<TipoDato>&);
friend istream& operator >> (istream&, Maleta<TipoDato>&);
};

//maleta.cpp
template <typename TipoDato>
ostream& operator << (ostream& out, Maleta<TipoDato>& objeto4)
{
out << "Capacidad: " << objeto4.capacidad << endl;
out << "Cantidad: " << objeto4.cantidad << endl;
return out;
};
template <typename TipoDato>
istream& operator >> (istream& in, Maleta<TipoDato>& objeto4)
{
cout << "Ingrese capacidad: ";
in >> objeto4.capacidad;
cout << "Ingrese cantidad: ";
in >> objeto4.cantidad;
return in;
};

4. Agregar un constructor a la clase plantilla que permita ingresar la capacidad y la

cantidad; debe de crear un arreglo de punteros dinámico de objetos Articulo.
//maleta.h
template <typename TipoDato>
class Maleta
{ . . .
Maleta<TipoDato>(int, int);
}

#include "maleta.h"
#include "articulo.h"
#include "camisa.h"
#include "camiseta.h"
#include "pantalon.h"
//maleta.cpp
template <typename TipoDato>
Maleta<TipoDato>::Maleta(int _capacidad, int _cantidad)
{
capacidad = _capacidad;
cantidad = _cantidad;
contenido = new TipoDato * [capacidad];
};

5. Crear un método que permita agregar al arreglo de punteros dinámico del tipo
Articulo objetos de los tipos Camisa, Pantalon y Camiseta.
//maleta.h
template <typename TipoDato>
 UNIVERSIDAD CATÓLICA DE SANTA MARÍA
ESCUELA PROFESIONAL DE INGENERÍA DE SISTEMAS
class Maleta
{ . . .
void agregar();
}

//maleta.cpp
template <typename TipoDato>
void Maleta<TipoDato>::agregar()
{
int tipo;
if (capacidad >= cantidad)
{
for (int i = 0; i < cantidad; i++)
{
cin >> tipo;
switch (tipo)
{
case 1:
contenido[i] = new Camisa;
break;
case 2:
contenido[i] = new Camiseta;
break;
case 3:
contenido[i] = new Pantalon;
break;
}
}
}
else
{
cout << "La cantidad excede la capacidad de la maleta" <<
endl;
}
};
6. Elaborar una función main(), donde se pueda crear objetos del tipo Maleta que
almacenen Artículos y se puedan ejecutar sus métodos y funciones amigas.
#include <iostream>
using namespace std;
#include "articulo.h"
#include "camisa.h"
#include "camiseta.h"
#include "pantalon.h"
#include "maleta.h"
#include "maleta.cpp"
int main()
{
Maleta<Articulo>maletita(2, 1);
maletita.agregar();
return 0;
}

7. Reunirse con un grupo alterno y comparar el código desarrollado por ellos

corrigiendo los errores producidos en la codificación y desarrollo de la aplicación.