Siento que todos deberíamos de dominar esto, o al menos estar enterados sobre estas tecnologías. Está muy padre:

Diseño de componentes

Compañeros,

Mostrando el gran interes por llevar con exito el proyecto que tenemos
asignado me di la tarea de buscar la bibliografía necesaria.
Logrando conseguir con exito los 3 Libros de ACE. Si compañeros
aquel libro azul ya lo tengo en mi poder... Se ve muy bueno.
Hoy por la mañana estare haciendo mis primeros ejercicios con ACE
siguiendo la guia del libro.

El proximo Miercoles recuerdenme de darle una copia.


SALUDOS

¡Hola!, ¿cómo les va? Aquí les envío una liga, está super padre porque te lleva de la manita a todo lo que nos
explicó Iván, espero que con esto podamos levantarnos más rápido y hacer cosas interesantes en menos tiempo.

Tutorial ACE


¡Cuídense!

Aqui dejo otra mas para que lo vean y estudien

Compañeros...

Encontre dos ligas buenas que posiblemente puedan ayudarnos con el proyecto
http://www.neurophys.wisc.edu/comp/wprogart.html
http://winapi.conclase.net/curso/index.php?cap=000

Hola, ya tenía tiempo de no escribir aquí. Aquí les va un pequeño ejemplo del RTTI
que hice hoy por la mañana. Espero les guste.

#include <iostream>
#include <vector>
#include <typeinfo>

class Animal
{
public:
Animal()
{
std::cout << "The Animal Kingdom rejoices because an " <<>\n\n";
std::vector Zoo;

Zoo.push_back(new Lion);
Zoo.push_back(new Cow);
Zoo.push_back(new Monkey);

std::vector::iterator it;

for(it = Zoo.begin(); it != Zoo.end(); ++it)
{
(*it)->SayHi();
}

for(it = Zoo.begin(); it != Zoo.end(); ++it)
{
delete *it;
}

return 0;
}

Aqui les paso una liga sobre los RFID que creo son parte importante del proyecto.
http://en.wikipedia.org/wiki/RFID

Compañeros aqui les paso una liga de ingieneria de software.
Aqui se muestra patrones de diseño y algunos ejemplos
http://www.info-ab.uclm.es/asignaturas/42579/

Les envío un nuevo ejemplo de cadena de responsabilidades, estos ejemplos los
estoy sacando de la página que les mostré en un post anterior, portando el código a c++.

#ifndef CONCRETEHANDLERA_DEF
#define CONCRETEHANDLERA_DEF

#include
#include "handler.h"

class CConcreteHandlerA : public CHandler
{
public:
CConcreteHandlerA();
virtual void handleRequest(int request);
virtual ~CConcreteHandlerA();

};

#endif // CONCRETEHANDLERA_DEF


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERB_DEF
#define CONCRETEHANDLERB_DEF

#include
#include "handler.h"

class CConcreteHandlerB : public CHandler
{
public:
CConcreteHandlerB();
virtual void handleRequest(int request);
virtual ~CConcreteHandlerB();

};

#endif // CONCRETEHANDLERB_DEF


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERC_DEF
#define CONCRETEHANDLERC_DEF

#include
#include "handler.h"

class CConcreteHandlerC : public CHandler
{
public:
CConcreteHandlerC();
virtual void handleRequest(int request);
virtual ~CConcreteHandlerC();

};

#endif // CONCRETEHANDLERC_DEF


//---------------------------------------------------------------------

#ifndef HANDLER_DEF
#define HANDLER_DEF

class CHandler
{
protected:
CHandler * m_successor;

public:
void setSuccessor(CHandler * successor);
virtual void handleRequest(int request);
};

#endif //HANDLER_DEF


#ifndef CONCRETEHANDLERA_IMP
#define CONCRETEHANDLERA_IMP


//---------------------------------------------------------------------

#include "ConcreteHandlerA.h"

CConcreteHandlerA::CConcreteHandlerA()
{

}

CConcreteHandlerA::~CConcreteHandlerA()
{

}

void CConcreteHandlerA::handleRequest(int request)
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerA handled request: " << request;
}
else if (m_successor != 0)
{
m_successor->handleRequest(request);
}
}

#endif //CONCRETEHANDLERA_IMP


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERB_IMP
#define CONCRETEHANDLERB_IMP

#include "ConcreteHandlerB.h"

CConcreteHandlerB::CConcreteHandlerB()
{

}

CConcreteHandlerB::~CConcreteHandlerB()
{

}

void CConcreteHandlerB::handleRequest(int request)
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerC handled request: " << request;
}
else if (m_successor != 0)
{
m_successor->handleRequest(request);
}
}

#endif //CONCRETEHANDLERB_IMP


//---------------------------------------------------------------------

#ifndef CONCRETEHANDLERC_IMP
#define CONCRETEHANDLERC_IMP

#include "ConcreteHandlerC.h"

CConcreteHandlerC::CConcreteHandlerC()
{

}

CConcreteHandlerC::~CConcreteHandlerC()
{

}

void CConcreteHandlerC::handleRequest(int request)
{
if (request >= 10 && request < 20)
{
std::cout << "ConcreteHandlerC handled request: " << request;
}
else if (m_successor != 0)
{
m_successor->handleRequest(request);
}
}

#endif //CONCRETEHANDLER_IMP


//---------------------------------------------------------------------


#ifndef HANDLER_IMP
#define HANDLER_IMP

#include "handler.h"

void CHandler::setSuccessor(CHandler * successor)
{
this->m_successor = successor;
}

#endif //HANDLER_IMP


//---------------------------------------------------------------------
#include
#include "handler.h"
#include "concretehandlera.h"
#include "concretehandlerb.h"
#include "concretehandlerc.h"

int main()
{
std::cout << ":This is a Chain of responsibility example:";
// Setup Chain of Responsibility
CHandler * h1 = new CConcreteHandlerA();
CHandler * h2 = new CConcreteHandlerB();
CHandler * h3 = new CConcreteHandlerC();
h1->setSuccessor(h2);
h2->setSuccessor(h3);

// Generate and process request
int requests[] = {2, 5, 14, 22, 18, 3, 27, 20};

for (int i=0; i < sizeof(requests); i++)
{
h1->handleRequest(requests[i]);
}
return 0;
}

Les paso el código del Singleton en C++:

// --------------------------------------------------------------------
// main.cpp

#include <iostream>

#include "singleton.h"

int main()
{
CSingleton * myFirstSingleton = 0;
CSingleton * mySecondSingleton = 0;
myFirstSingleton->instance();
myFirstSingleton->instance();
if (myFirstSingleton == mySecondSingleton)
{
std::cout << "It's the same instance!\n"; } return 0; }

// --------------------------------------------------------------------
// singleton.h

#ifndef CSINGLETON_DEF
#define CSINGLETON_DEF

class CSingleton {
private:
static CSingleton * m_instance;
protected:
CSingleton();
public:
static CSingleton * instance();
};

#endif

// --------------------------------------------------------------------
// singleton.cpp

#ifndef CSINGLETON_IMP
#define CSINGLETON_IMP

#include "singleton.h"

CSingleton * CSingleton::m_instance = 0;

CSingleton::CSingleton()
{
}

CSingleton * CSingleton::instance()
{
if (m_instance == 0)
{
m_instance = new CSingleton;
}
return m_instance;
}

#endif

Acabo de compartir en mi equipo algo de código, si gustan buscarme por red; todos los miembros de nuestro equipo de trabajo.

Hola, ¿cómo están? Les envío el site que les comenté hace unos momentos:

Design Patterns

Como les había comentado, los ejemplos vienen en c# pero el código está muy
limpio y entendible, a ver si les gusta.