Tip |
The table shown below illustrates the meaning of several concepts used in programming. La tabla mostrada debajo ilustra el significado de varios conceptos usados en programación. |
Function | Skill |
Variable | Store Something |
Class | I am (I can perform activities and I have properties) |
Interface | I have a set of skills for a profession (I have a set of functions) |
Función | Habilidad |
Variable | Almacenar Algo |
Clase | Yo soy (Puedo hacer actividades y tengo propiedades) |
Interface | Tengo un conjunto de habilidades para una profesión (Tengo un conjunto de funciones). |
Name | Description |
Class | Use a class to share a set of variables and functions between objects |
Interface | Use an interface to share a set of functions between objects |
Nombre | Descripción |
Class | Use una clase para compartir un conjunto de variables y funciones entre objetos |
Interface | Use una interface para compartir un conjunto de funciones entre objetos |
Interface |
An interface is a set of pure virtual functions. Most programmers use an upper I to give names to theirs interfaces, for example: ITeacher, IDoctor, IMechanic, etc. An interface in C++ is defined using the class keyword in a header file (*.h); no source file (*.cpp) is required to define the interface. Once an interface has been defined, other classes may implement the interface. A class has a set of member variables, and a set of member functions. As an interface is a set of functions, it can be said that a class has a set of member variables and a set of interfaces. Una interface es un conjunto de funciones virtuales puras. La mayoría de los programadores usan una letra I mayúscula para dar nombre a sus interfaces, por ejemplo: ITeacher, IDoctor, IMechanic, etc. Una interface en C++ es definida usando la palabra clave class en una archivo de encabezado (*.h); no se requiere archivo fuente (*.cpp) para definir una interface. Una vez que la interface se ha definido, otras clases pueden implementar la interface. Una clase tiene un conjunto de variables miembro y un conjunto de funciones miembro. Como una interface es un conjunto de funciones, se puede decir que una clase tiene un conjunto de variables miembro y un conjunto de interfaces. |
Interface vs Abstract Class |
The main difference between an interface and an abstract class is that the interface has no member variables. La diferencia entre una interface y una clase abstracta es que la interface no tiene variables miembro. |
Problem 1 |
Work on teams to compare: Structure, Class and Interface. Trabajando en equipos compare: Structure, Class and Interface. |
Problem 2 |
List the skills of a lawyer (interface ILawyer). Create the ILawyer.h file with the pure virtual functions of the interface. Haga una lista de las habilidades del abogado (interface IAbogado). Cree el archivo IAbogado.h con las funciones puras de la interface. |
ILawyer.h |
//_______________________________ ILawyer.h #pragma once class ILawyer { public: virtual void Defend() = 0; virtual void GetPaid(double amount) = 0; virtual void SpeakOut() = 0; }; |
Problem 3 |
List the skills of an engineer (interface IEngineer). Create the IEngineer.h file with the pure virtual functions of the interface. Haga una lista de las habilidades del ingeniero (interface IIngeniero). Cree el archivo IIngeniero.h con las funciones puras de la interface. |
Problem 4 |
Suppose there is an interface called IWorker with the following pure virtual functions: Work(int numbHours) and ReceivePayment(double amount) as shown below in the IWorker.h file (there is no IWorker.cpp file). Now suppose that the classes: Electrician and Accountant implement the IWorker interface. Finally, suppose that there are three functions as shown in the list. Which function is more convenient to implement by the programmer?
Suponga que hay una interface llamada ITrabajador (IWorker) con las siguientes funciones virtuales puras: Work(int numbHours) y ReceivePayment(double amount) como se muestra debajo en el archivo IWorker.h (no hay archivo IWorker.cpp). Ahora suponga que las clases: Electricista y Contador implementan la interface ITrabajador (IWorker). Finalmente, suponga que hay tres funciones como se muestra en la lista. Cual función le conviene más implementar al programador?
|
IWorker.h |
#pragma once class IWorker { public: virtual void Work(int numHours) = 0; virtual void ReceivePayment(double amount) = 0; }; |
Electrician.h |
#pragma once #include "IWorker.h" class Electrician: public IWorker { public: Electrician(void); ~Electrician(void); //___________________________ IWorker void Work(int numHours); void ReceivePayment(double amount); }; |
Accountant.h |
#pragma once #include "IWorker.h" class Accountant: public IWorker { public: Accountant(void); ~Accountant(void); //___________________________ IWorker void Work(int numHours); void ReceivePayment(double amount); }; |
Tip |
In the Interface declaration all the necessary functions are declared but not implemented, that is why they are set to zero. At the moment of implementing an interface, it is necessary to implement all the functions specified in the interface. In the example, la Electrician class implements the IWorker interface, and must implement the two functions specified in the interface. En la declaración de la interface se declaran todas las funciones que se necesitan pero no se implementan por lo que se igualan a cero. En el momento en el que se implementa la interface se deben implementar todas las funciones especificadas en la interface. En el ejemplo, la clase Electrician implementa la interface IWorker, y debe implementar las dos funciones especificadas en la interface. |
Tip |
The use of interfaces increases the chances of reusing a function because any object that implements the required interface can be passed to the function. In the previous problem, it is possible to provide two implementations for the Contract function, one that takes an Electrician and another that takes an Accountant. However, if the Contract function takes an object that implements the IWorker interface, one single function is enough for many types of objects. El uso de las interface incrementa la probabilidad de reusar una función porque cualquier objeto que implementa la interface puede ser pasado a la función. En el problema previo, es posible proporcionar dos implementaciones para la función Contract, una que tome un Electricista y otra que tome un Contador. Sin embargo, si la función Contract toma un objeto que implemente la interface IWorker una sola función es suficiente para muchos tipos de objetos. |
Tip |
An interface is advanced concept of the OOP. An interface is a contract of services (a list of functions that must be implemented). The object that implements the interface must implement all the functions in the interface. A class unites objects by what they are, while an interface unites object by what they can do. Una interface es un concepto avanzado de Programación Orientada a Objetos. Una interface es un contrato de servicios (una lista de funciones que deben de implementarse). El objeto que implementa una interface debe implementar todas las funciones especificadas en la interface. Una clase agrupa un objeto por lo que es, mientras que las interfaces agrupan los objetos por lo que hacen. |
Tip |
Structure programming does not require planning the code. OOP requires some degree of planning and allows expressing with the language more complex ideas than structure programming. Interfaces require more planning time (abstract ideas) but offer powerful options to express an idea. La programación estructurada no requiere de planear el código. La programación orientada objetos requiere de cierta planeación y permite expresar con el lenguaje ideas más complejas que las de la programación estructurada. Las interfaces requieren de más tiempo de planeación (ideas abstractas) pero ofrecen opciones poderosas para expresar una idea. |
Problem 5 |
Discuss the set of files shown below. Discuta el conjunto de archivos mostrados debajo. |
IDoubleLinkedList.h |
class IDoubleLinkedList { public: virtual int GoNext() = 0; virtual int GoBack() = 0; }; |
PeopleList.h |
#include "IDoubleLinkedList.h" class PeopleList: public IDoubleLinkedList { public: PeopleList() { index = 0; } ~PeopleList() { } //________________________________ IDoubleLinkedList int GoNext() { return data[index++]; } int GoBack() { return data[index--]; } private: int index; int data[256]; }; |
Problem 6 |
Discuss the set of files shown below. Discuta el conjunto de archivos mostrados debajo. |
IPartner.h |
class IPartner { public: virtual void Ask() = 0; virtual void Listen() = 0; virtual void Cook() = 0; virtual void Enjoy() = 0; virtual void Clean() = 0; virtual void EnjoyCompany() = 0; }; |
Wife.h |
#include "IPartner.h" class Wife : public IPartner { public: Wife(); ~Wife(); //_____________________________ Member variables of Wife . . . //_____________________________ IPartner void Ask(); void Listen(); void Cook(); void Enjoy(); void Clean(); void EnjoyCompany(); //_____________________________ Other functions of Wife . . . }; |
Husband.h |
#include "IPartner.h" class Husband: public IPartner { public: Husband(); ~Husband(); //_____________________________ Member variables of Husband . . . //_____________________________ IPartner void Ask(); void Listen(); void Cook(); void Enjoy(); void Clean(); void EnjoyCompany(); //_____________________________ Other functions of Husband . . . }; |
Problem 7 |
Indicate whether the next statement is true or false: Suppose that there is a new class called Lover that implements all the functions in the IPartner interface except Cook(), thus Lover can be considered as an IPartner. Indique si el siguiente enunciado es cierto o false: Suponga que hay una nueva clase llamada Amante que implementa todas las funciones en la interface IPartner excepto Cook(), así Amante puede ser considerado un IPartner. |
Tip |
In some unusual cases, if you do not know what code must be write in the function definition, you must write the function declaration and omit the code in the function definition, that is, { }. El algunos casos inusuales, si no se sabe que código colocar en la definición de una función se debe colocar su declaración y omitir el código en su definición, es decir, { }. |
Polymorphism |
An object may behave differently according the way it is used. For instance, consider the interfaces IChef (functions: Cook) and ICleaner (functions: Sweep, Mope the floor, Clean Windows). Suppose now that a Lawyer class implements IChef and ICleaner. Suppose that an Engineer class implements only ICleaner. If there is a Party object that has a function Prepare that takes any object that implements IChef, then the function can take only an object of the class Lawyer. If there is a House object that has a function Clean that takes any object that implements ICleaner, then the function can take an object of the Lawyer or Engineer class. When an object of the Lawyer class is passed to the party.Prepare(IChef ichef) function it behaves as IChef, when the same Lawyer object is passed to the house.Clean(IClearner icleaner) function, it behaves as ICleaner. Un objeto puede comportarse en forma diferente de acuerdo a la forma en que es usado. Por ejemplo, considere las interfaces IChef (funciones: Cocinar) y ILimpiador (funciones: Barrer, Trapear el piso, Limpiar Ventanas). Suponga ahora que una clase Abogado implementa IChef y ILimpiador. Suponga que una clase Ingeniero implementa solamente ILimpiador. Si hay un objeto Fiesta que tiene una función Preparar que toma un objeto que implementa IChef, entonces la función puede tomar solamente un objeto de la clase Abogado. Si hay un objeto Casa que tiene una función Limpiar que toma un objeto que implemente ILimpiador, entonces la función puede tomar un objeto de las clases Abogado o Ingeniero. Cuando un objeto de la clase Abogado se pasa a la función fiesta.Preparar(IChef ichef), este se comporta como un IChef, cuando el mismo objeto de Abogado se pasa a la función casa.Limpiar(ILimpiador ilimpiador), este se comporta como ILimpiador. |
ILawyer.h |
//_______________________________ ILawyer.h #pragma once class ILawyer { virtual void Defend() = 0; virtual void GetPaid(double amount) = 0; virtual void SpeakOut() = 0; }; |
IChef.h |
//_______________________________ IChef.h #pragma once class IChef { virtual void Cook(wstring mealName) = 0; }; |
ICleaner.h |
//_______________________________ ICleaner.h #pragma once class ICleaner { virtual void Sweep() = 0; virtual void Mope(wstring what) = 0; virtual void Clean(wstring what) = 0; }; |
Lawyer.h |
//______________________________________ Lawyer.h #pragma once #include "ILayer.h" #include "IChef.h" #include "ICleaner.h" class Lawyer : public ILawyer, public IChef, public ICleaner { public: Lawyer(); ~Lawyer(); //___________________________ ILayer void Defend(); void GetPaid(double amount); void SpeakOut(); //___________________________ IChef void Cook(wstring mealName); //___________________________ ICleaner void Sweep(); void Mope(wstring what); void Clean(wstring what); }; |
Tip |
An interface defines a contract between two objects (similar to when a client negotiates with another person). Whenever you create a function that takes as a parameter an object of a class, it is important to analyze if an interface should be created instead. This way, the function can be used for objects of different classes. Not to mention that only the operation of the object that will be needed has to be exposed. It is suggested that several classes implement the interface so that they can use the function (transaction performed by means of the contract they agreed upon.) Una interface define un contrato entre dos objetos (Como cuando un cliente negocia con otra persona). Siempre que se cree una función que toma como parámetro un objeto de una clase, es importante analizar si conviene crear mejor una interface. De esta forma la función puede ser usada por objetos de distintas clases. A parte de que sólo se expone la operación del objeto que se va a necesitar en la función. Se sugiere que varias clases implementen la interface para que hagan uso de la función (transacción por medio del contrato que establecieron). |
Tip |
An interface is a template that indicates the functions that a class must have. In this way, the programmer has a place to add his code in the functions described in the interface. Una interface es una plantilla que indica las funciones debe tener una clase. De esta forma, el programador tiene un espacio para agregar su código en las funciones descritas en la interface. |
Problem 8 |
Create a Wintempla dialog application called MyTrapz to compute value of the integral using the trapezoidal formula. Create a class called Integral. See Wintempla > Sentence for > Review Cree una aplicación de Wintempla de diálogo llamada MyTrapz para calcular el valor de la integral usando la fórmula trapezoidal. Cree una clase llamada Integral. Ver Wintempla > Sentence for > Review . |
MyTrapz.h |
#pragma once //______________________________________ MyTrapz.h #include "Resource.h" #include "Integral.h" class MyTrapz: public Win::Dialog { public: ... }; |
MyTrapz.cpp |
... void MyTrapz::Window_Open(Win::Event& e) { Integral integral; this->Text = Sys::Convert::ToString(integral.ComputeIntegral()); } |
Integral.h |
#pragma once class Integral { public: Integral(void); ~Integral(void); double a; double b; int stepCount; double ComputeIntegral(); double Func(double x); }; |
Integral.cpp |
#include "stdafx.h" #include "Integral.h" Integral::Integral(void) { a = 0.0; b = M_PI; stepCount = 10; } Integral::~Integral(void) { } double Integral::ComputeIntegral() { ... return delta*sum/2.0; } double Integral::Func(double x) { return sin(x); } |
Problem 9 |
If you would like to compute the integral of another function without editing the Integral class, what options do we have? Si quisieramos calcular la integral de otra función sin editar la clase Integral, que opciones se tienen? |
Problem 10 |
Use inheritance to be able to override the Integral::Func method. Add a new class (to project of problem 7) called Squared to compute the integral of f(x) = 2*x*x+5. Use la herencia para poder sobrecargar (reemplazar) el método Integral::Func. Agregue una nueva clase (al proyecto del problema 7) llamada Squared para calcular la integral de f(x) = 2*x*x +5. |
Step A |
Edit the Integral.h file to declare the Integral::Func as virtual so that it can be override using inheritance. Edite el archivo Integral.h para declarar la función Integral::Func como virtual para que pueda sobrecargase usando la herencia. |
Integral.h |
#pragma once class Integral { public: Integral(void); ~Integral(void); double a; double b; int stepCount; double ComputeIntegral(); virtual double Func(double x); }; |
Step B |
Add and edit the Squared class. Agregue y edite la clase Squared. |
Squared.h |
#pragma once #include "integral.h" class Squared : public Integral { public: Squared(void); ~Squared(void); double Func(double x); }; |
Squared.cpp |
#include "stdafx.h" #include "Squared.h" Squared::Squared(void) { } Squared::~Squared(void) { } double Squared::Func(double x) { return 2.0*x*x+5; } |
Step C |
Edit the MyTrapz.h and MyTrapz.cpp files as shown. |
MyTrapz.h |
#pragma once //______________________________________ MyTrapz.h #include "Resource.h" //#include "Integral.h" #include "Squared.h" class MyTrapz: public Win::Dialog { public: ... }; |
MyTrapz.cpp |
... void MyTrapz::Window_Open(Win::Event& e) { Squared squared; this->Text = Sys::Convert::ToString(squared.ComputeIntegral()); } |
Problem 11 |
Create a Wintempla dialog application called TrapX to compute value of the integral using the trapezoidal formula using interfaces. Cree una aplicación de Wintempla de diálogo llamada TrapX para calcular el valor de la integral usando la fórmula trapezoidal usando interfaces. |
Step A |
Add the Trapecio class, and edit the files to declare the IFunc interface as shown. Observe that the ComputeIntegral function takes any object that implements IFunc. Agregue clase Trapecio, y edite los archivos para declarar la interface IFunc como se muestra. Observe que la función ComputeIntegral toma cualquier objeto que implemente IFunc. |
Trapecio.h |
#pragma once //______________________________ Interface IFunc Declaration class IFunc { public: virtual double Func(double x) = 0; }; class Trapecio { public: Trapecio(void); ~Trapecio(void); double a; double b; int stepCount; double ComputeIntegral(IFunc* func); }; |
Trapecio.cpp |
#include "stdafx.h" #include "Trapecio.h" Trapecio::Trapecio(void) { a = 0.0; b = M_PI; stepCount = 10; } Trapecio::~Trapecio(void) { } double Trapecio::ComputeIntegral(IFunc* func) { ... for(int i = 0; i <= stepCount; i++) { x = a + i*delta; y = func->Func(x); ... } return delta*sum/2.0; } |
Step B |
Modify the TrapX class so that it implements the IFunc interface. The class must implement all functions in the interface; in this case, there is only one function in the interface. Modifique la clase TrapX para que implemente la interface IFunc. La clase debe implementar todas las funciones en la interface; en este caso, sólo hay una función en la interface. |
TrapX.h |
#pragma once //______________________________________ TrapX.h #include "Resource.h" #include "Trapecio.h" class TrapX: public Win::Dialog, public IFunc { public: TrapX() { } ~TrapX() { } //______________________________ Interface IFunc Implementation double Func(double x); ... }; |
TrapX.cpp |
... void TrapX::Window_Open(Win::Event& e) { Trapecio trapecio; this->Text = Sys::Convert::ToString(trapecio.ComputeIntegral(this)); // Interface passing } double TrapX::Func(double x) { return 2.0*x*x+5.0; // It is possible to write any function without modifying the Trapecio class } |
Tip |
The previous example illustrates the power of the interfaces. Basically, an interface allows passing a set of function from one objet to another. El ejemplo previo ilustra el poder de las interfaces. Básicamente, una interface permite pasar un conjunto de funciones de un objeto a otro. |
Tip |
Tasks you can do with an interface:
Tareas que puedes hacer con una interface:
|
Tip |
An interface is an elegant way to interchange a set of functions between two or more objects. Una interface es una forma elegante para intercambiar un conjunto de funciones entre dos o más objetos. |
Problem 12 |
Indicate if interfaces:
Indique si las interfaces:
|
Problem 13 |
Working on teams answer the following questions:
Trabajando en equipos conteste las siguientes preguntas:
|
Problem 14 |
Complete using structure, interface, class, variable, function, namespace, library:
Complete usando estructura, interface, clase, variable, función, namespace, librería:
|