Implementare le Proprietà

Tutti i linguaggi moderni contemplano l'utilizzo delle proprietà per interagire con gli attributi di un oggetto. Il C++ non offre un tale costrutto...

Quando si definisce una nuova classe, si dichiara un certo numero di attributi che caratterizzeranno gli oggetti creati a partire da quella classe.
Solitamente è buona norma definire dei metodi appositi per leggere e modificare il valore delle variabili interne, per eseguire validazioni in scrittura o calcoli in lettura.
Le proprietà sono costrutti che consentono di svolgere in modo elegante tali attività: in pratica consentono di isolare le variabili interne, mantendo, però, la possibilità di interagire con esse nello stesso modo, ovvero di eseguire assegnazioni dirette come ad esempio:
  Oggetto.Attributo = Valore
  Valore = Oggetto.Attributo

In C++ è necessario definire ed utilizzare metodi espliciti come:
  Oggetto.SetAttributo(Valore)
  Valore = Oggetto.GetAttributo()

Implementazione
Di seguito ho riportato l'implementazione del supporto alle proprietà con una classe di esempio che le espone e un esempio di codice che le utilizza:

Property.h: Classe Template che fornisce il supporto
Person.h: Classe di esempio che espone le proprietà
PropUsage.cpp: Frammento di codice che usa la classe CPerson

Il supporto è abbastanza completo, consente di usare proprietà di qualsiasi tipo, di settare il tipo di accesso (Read, Write, Read/Write) e di definire degli Handlers custom quando necessario.
Per quanto riguarda l'utilizzo, si puo vedere nella classe d'esempio che l'overhead di codice necessario è minimo.
Dal punto di vista dell'utilizzatore della classe, si opera come se le variabili fossero pubbliche e il codice risulta molto "pulito".

Property.h

#ifndef __PROPERTY_H__
#define __PROPERTY_H__

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000


template<typename pObject, 
         typename ValueType, 
         BOOL bCanRead = TRUE, 
         BOOL bCanWrite = TRUE>
class property
{
private:
  pObject* m_cObject;
	
  ValueType* m_pValue; 

  void (pObject::*Set)(ValueType value);
  ValueType (pObject::*Get)();

public:
  property() 
  { 
	m_cObject = NULL; 
	Get = NULL; 
	Set = NULL; }

  void Attach(pObject* cObject, ValueType* pValue) 
  { 
	m_cObject = cObject; 
	m_pValue = pValue; 
	Get = NULL; 
	Set = NULL; 
  }
	
  void AttachGet(pObject* cObject, ValueType* pValue, ValueType (pObject::*pGet)()) 
  { 
	m_cObject = cObject; 
	m_pValue = pValue; 
	Get = pGet; 
	Set = NULL;
  }

  void AttachSet(pObject* cObject, ValueType* pValue, void (pObject::*pSet)(ValueType value)) 
  { 
	m_cObject = cObject; 
	m_pValue = pValue; 
	Get = NULL; 
	Set = pSet;
  }
	
  void AttachGetSet(pObject* cObject, ValueType (pObject::*pGet)(), void (pObject::*pSet)(ValueType value)) 
  { 
	m_cObject = cObject;  
	Get = pGet; 
	Set = pSet; 
  }

  ValueType operator =(const ValueType& value)
  {
	ASSERT(m_cObject != NULL); 
	ASSERT(bCanWrite);

	if(Set != NULL) 
		(m_cObject->*Set)(value); 
	else 
		*m_pValue = value; 

	return value; 
  }

  operator ValueType()
  {
	ASSERT(m_cObject != NULL); 
	ASSERT(bCanRead);
			
	if(Get != NULL) 
		return (m_cObject->*Get)(); 
	else 
		return *m_pValue;
  }
};

#endif

Person.h

#ifndef __PERSON_H__
#define __PERSON_H__

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000


#include "Property.h"


class CPerson
{
private:
  CString  m_Name;
  int      m_Age;
  CPerson* m_Wife;
  BOOL     m_Hungry;

protected: // Property Handlers
  inline void SetName(CString sValue)
         { if (!sValue.IsEmpty()) m_Name = sValue; }

  inline void SetAge(int iValue)
         { if (iValue > 0 && iValue < 120) m_Age = iValue; }

  inline CPerson* GetWife()
         { return m_Wife; }		

  inline void SetWife(CPerson* pWife)
         { m_Wife = pWife; }

  inline BOOL GetMarried()
         { return m_Wife != NULL; }

public:
  property<CPerson, CString> Name;
  property<CPerson, int> Age;
  property<CPerson, CPerson*> Wife;
  property<CPerson, BOOL> Hungry;
  property<CPerson, BOOL, TRUE, FALSE> Married;

public:
  CPerson(CString sName, int iAge)
  {
        // Init the Property Handlers
        Name.AttachSet(this, &m_Name, &CPerson::SetName);
        Age.AttachSet(this, &m_Age, &CPerson::SetAge);
        Wife.AttachGetSet(this, &CPerson::GetWife, &CPerson::SetWife);
        Hungry.Attach(this, &m_Hungry);
        Married.AttachGet(this, (BOOL*)NULL, &CPerson::GetMarried);

        // Init this instance 
        Name = sName; //using property
        Age = iAge;   //using property
        m_Wife = NULL;
        m_Hungry = FALSE;
  }
};


#endif

PropUsage.cpp

#include "stdafx.h"
#include "Person.h"


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


....
....


void CPropertyExDlg::OnButtonTest() 
{
  CPerson Andy("Andrea", 38);
  CPerson Simi("Simona", 39);

  CString  sName = Andy.Name;
  int      iAge = Andy.Age;
  BOOL     bMarried = Andy.Married;

  Andy.Hungry = FALSE;
  Andy.Wife = &Simi;
  bMarried = Andy.Married; //bMarried change to TRUE

  Simi.Hungry = TRUE;
  Simi.Age = 130; //This Raise an Assert
}


....
....

Tutte le Utility