Classe CObject

  • Articolo

Classe base principale per la libreria Microsoft Foundation Class.

Sintassi

class AFX_NOVTABLE CObject

Membri

Costruttori protetti

Nome Descrizione
CObject::CObject Costruttore predefinito.

Metodi pubblici

Nome Descrizione
CObject::AssertValid Convalida l'integrità di questo oggetto.
CObject::Dump Produce un dump di diagnostica di questo oggetto.
CObject::GetRuntimeClass Restituisce la CRuntimeClass struttura corrispondente alla classe dell'oggetto.
CObject::IsKindOf Verifica la relazione dell'oggetto con una determinata classe.
CObject::IsSerializable Verifica se questo oggetto può essere serializzato.
CObject::Serialize Carica o archivia un oggetto da/in un archivio.

Operatori pubblici

Nome Descrizione
CObject::operator delete Operatore speciale delete .
CObject::operator new Operatore speciale new .

Osservazioni:

Funge da radice non solo per le classi di libreria, CFile ad esempio e CObList, ma anche per le classi scritte. CObject fornisce servizi di base, tra cui

  • Supporto per la serializzazione
  • Informazioni sulle classi di runtime
  • Output di diagnostica degli oggetti
  • Compatibilità con le classi di raccolta

CObject non supporta l'ereditarietà multipla. Le classi derivate possono avere una CObject sola classe di base e che CObject devono essere più a sinistra nella gerarchia. È tuttavia consentito avere strutture e classi non CObjectderivate in rami di ereditarietà multipla di destra.

Si otterranno grandi vantaggi dalla CObject derivazione se si usano alcune delle macro facoltative nell'implementazione e nelle dichiarazioni della classe.

Le macro di DECLARE_DYNAMIC primo livello e IMPLEMENT_DYNAMIC, consentono l'accesso in fase di esecuzione al nome della classe e alla relativa posizione nella gerarchia. Ciò, a sua volta, consente un dump diagnostico significativo.

Le macro DECLARE_SERIAL di secondo livello e IMPLEMENT_SERIAL, includono tutte le funzionalità delle macro di primo livello e consentono a un oggetto di essere "serializzato" da e verso un "archivio".

Per informazioni sulla derivazione delle classi Microsoft Foundation e delle classi C++ in generale e sull'uso CObjectdi , vedere Uso di CObject e serializzazione.

Gerarchia di ereditarietà

CObject

Requisiti

Intestazione:afx.h

CObject::AssertValid

Convalida l'integrità di questo oggetto.

virtual void AssertValid() const;

Osservazioni:

AssertValid esegue un controllo di validità su questo oggetto controllandone lo stato interno. Nella versione Debug della libreria può AssertValid asserire e quindi terminare il programma con un messaggio che elenca il numero di riga e il nome file in cui l'asserzione non è riuscita.

Quando si scrive una classe personalizzata, è necessario eseguire l'override della AssertValid funzione per fornire servizi di diagnostica per se stessi e altri utenti della classe. L'override AssertValid chiama in genere la AssertValid funzione della relativa classe di base prima di controllare i membri dati univoci per la classe derivata.

Poiché AssertValid è una const funzione, non è consentito modificare lo stato dell'oggetto durante il test. Le funzioni di classe AssertValid derivate personalizzate non devono generare eccezioni, ma devono invece asserire se rilevano dati di oggetto non validi.

La definizione di "validità" dipende dalla classe dell'oggetto. Come regola, la funzione deve eseguire un "controllo superficiale". Ovvero, se un oggetto contiene puntatori ad altri oggetti, deve verificare se i puntatori non NULLsono , ma non deve eseguire test di validità sugli oggetti a cui fanno riferimento i puntatori.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli CObject esempi.

void CAge::AssertValid() const
{
   CObject::AssertValid();
   ASSERT(m_years > 0); 
   ASSERT(m_years < 105);
}

Per un altro esempio, vedere AfxDoForAllObjects.

CObject::CObject

Queste funzioni sono i costruttori standard CObject .

CObject();
CObject(const CObject& objectSrc);

Parametri

objectSrc
Riferimento a un altro CObject

Osservazioni:

La versione predefinita viene chiamata automaticamente dal costruttore della classe derivata.

Se la classe è serializzabile (incorpora la IMPLEMENT_SERIAL macro), è necessario disporre di un costruttore predefinito (un costruttore senza argomenti) nella dichiarazione di classe. Se non è necessario un costruttore predefinito, dichiarare un costruttore "vuoto" privato o protetto. Per altre informazioni, vedere Uso di CObject.

Il costruttore di copia della classe C++ standard esegue una copia membro per membro. La presenza del costruttore di copia privata CObject garantisce un messaggio di errore del compilatore se il costruttore di copia della classe è necessario ma non disponibile. Specificare un costruttore di copia se la classe richiede questa funzionalità.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata negli CObject esempi.

// Create a CAge object using the default constructor.
CAge age1;

// Create a CAge object using the copy constructor.
CAge age2(age1);

CObject::Dump

Esegue il dump del contenuto dell'oggetto in un CDumpContext oggetto .

virtual void Dump(CDumpContext& dc) const;

Parametri

dc
Contesto del dump di diagnostica per il dump, in genere afxDump.

Osservazioni:

Quando si scrive una classe personalizzata, è necessario eseguire l'override della Dump funzione per fornire servizi di diagnostica per se stessi e altri utenti della classe. L'oggetto sottoposto a override Dump chiama in genere la Dump funzione della relativa classe di base prima di stampare membri dati univoci per la classe derivata. CObject::Dump stampa il nome della classe se la classe utilizza la IMPLEMENT_DYNAMIC macro o IMPLEMENT_SERIAL .

Nota

La Dump funzione non deve stampare un carattere di nuova riga alla fine dell'output.

Dump le chiamate hanno senso solo nella versione Debug della libreria di classi Microsoft Foundation. È consigliabile inserire tra parentesi le chiamate, le dichiarazioni di funzione e le implementazioni di funzioni con #ifdef _DEBUGistruzioni , #endif per la compilazione condizionale.

Poiché Dump è una const funzione, non è consentito modificare lo stato dell'oggetto durante il dump.

L'operatore CDumpContext di inserimento (<<) chiama Dump quando viene inserito un CObject puntatore.

Dump consente solo il dump "aciclico" di oggetti. È possibile eseguire il dump di un elenco di oggetti, ad esempio, ma se uno degli oggetti è l'elenco stesso, alla fine si sovrapporrà lo stack.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli CObject esempi.

void CAge::Dump(CDumpContext& dc) const
{
   CObject::Dump(dc);
   dc << _T("Age = ") << m_years;
}

CObject::GetRuntimeClass

Restituisce la CRuntimeClass struttura corrispondente alla classe dell'oggetto.

virtual CRuntimeClass* GetRuntimeClass() const;

Valore restituito

Puntatore alla CRuntimeClass struttura corrispondente alla classe dell'oggetto; mai NULL.

Osservazioni:

Esiste una CRuntimeClass struttura per ogni CObjectclasse derivata da . I membri della struttura sono i seguenti:

  • LPCSTR m_lpszClassName Stringa con terminazione Null contenente il nome della classe ASCII.

  • int m_nObjectSize Dimensione dell'oggetto, in byte. Se l'oggetto dispone di membri dati che puntano alla memoria allocata, le dimensioni di tale memoria non sono incluse.

  • UINT m_wSchema Numero di schema ( -1 per le classi nonerializzabili). Per una descrizione del numero di schema, vedere la IMPLEMENT_SERIAL macro.

  • CObject* (PASCAL* m_pfnCreateObject)() Puntatore di funzione al costruttore predefinito che crea un oggetto della classe (valido solo se la classe supporta la creazione dinamica; in caso contrario, restituisce NULL).

  • CRuntimeClass* (PASCAL* m_pfn_GetBaseClass )() Se l'applicazione è collegata dinamicamente alla versione AFXDLL di MFC, un puntatore a una funzione che restituisce la CRuntimeClass struttura della classe di base.

  • CRuntimeClass* m_pBaseClass Se l'applicazione è collegata staticamente a MFC, un puntatore alla CRuntimeClass struttura della classe di base.

Questa funzione richiede l'uso IMPLEMENT_DYNAMICdella macro , IMPLEMENT_DYNCREATEo IMPLEMENT_SERIAL nell'implementazione della classe . In caso contrario, si otterranno risultati non corretti.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli CObject esempi.

CAge a(21);
CRuntimeClass* prt = a.GetRuntimeClass();
ASSERT(strcmp(prt->m_lpszClassName, "CAge") == 0);

CObject::IsKindOf

Verifica la relazione dell'oggetto con una determinata classe.

BOOL IsKindOf(const CRuntimeClass* pClass) const;

Parametri

pClass
Puntatore a una CRuntimeClass struttura associata alla CObjectclasse derivata da .

Valore restituito

Diverso da zero se l'oggetto corrisponde alla classe ; in caso contrario, 0.

Osservazioni:

Questa funzione verifica pClass se (1) è un oggetto della classe specificata o (2) è un oggetto di una classe derivata dalla classe specificata. Questa funzione funziona solo per le classi dichiarate con la DECLARE_DYNAMICmacro , DECLARE_DYNCREATEo DECLARE_SERIAL .

Non usare questa funzione in modo esteso perché sconfigge la funzionalità di polimorfismo C++. Usare invece le funzioni virtuali.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli CObject esempi.

CAge a(21);  // Must use IMPLEMENT_DYNAMIC, IMPLEMENT _DYNCREATE, or
             // IMPLEMENT_SERIAL
ASSERT(a.IsKindOf(RUNTIME_CLASS(CAge)));
ASSERT(a.IsKindOf(RUNTIME_CLASS(CObject)));

CObject::IsSerializable

Verifica se questo oggetto è idoneo per la serializzazione.

BOOL IsSerializable() const;

Valore restituito

Diverso da zero se questo oggetto può essere serializzato; in caso contrario, 0.

Osservazioni:

Affinché una classe possa essere serializzabile, la relativa dichiarazione deve contenere la DECLARE_SERIAL macro e l'implementazione deve contenere la IMPLEMENT_SERIAL macro.

Nota

Non eseguire l'override di questa funzione.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli CObject esempi.

CAge a(21);
ASSERT(a.IsSerializable());

CObject::operator delete

Per la versione Release della libreria, l'operatore delete libera la memoria allocata dall'operatore new.

void PASCAL operator delete(void* p);

void PASCAL operator delete(
    void* p,
    void* pPlace);

void PASCAL operator delete(
    void* p,
    LPCSTR lpszFileName,
    int nLine);

Osservazioni:

Nella versione Debug l'operatore delete partecipa a uno schema di monitoraggio dell'allocazione progettato per rilevare le perdite di memoria.

Se si usa la riga di codice

#define new DEBUG_NEW

prima di una delle implementazioni in un oggetto . Il file CPP, quindi verrà usata la terza versione di , archiviando il nome file e il numero di riga nel blocco allocato per la creazione di delete report successivi. Non è necessario preoccuparsi di fornire i parametri aggiuntivi; una macro si occupa di questo per te.

Anche se non si usa DEBUG_NEW in modalità debug, si ottiene comunque il rilevamento delle perdite, ma senza la segnalazione del numero di riga del file di origine descritto in precedenza.

Se si esegue l'override degli operatori new e delete, si esegue il forfeit di questa funzionalità di diagnostica.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata negli CObject esempi.

void CAge::operator delete(void* p)
{
   free(p);
}

void CAge::operator delete(void *p, LPCSTR lpszFileName, int nLine)
{
   UNREFERENCED_PARAMETER(lpszFileName);
   UNREFERENCED_PARAMETER(nLine);
   free(p);
}

CObject::operator new

Per la versione Release della libreria, l'operatore new esegue un'allocazione di memoria ottimale in modo simile a malloc.

void* PASCAL operator new(size_t nSize);
void* PASCAL operator new(size_t, void* p);

void* PASCAL operator new(
    size_t nSize,
    LPCSTR lpszFileName,
    int nLine);

Osservazioni:

Nella versione Debug l'operatore new partecipa a uno schema di monitoraggio dell'allocazione progettato per rilevare le perdite di memoria.

Se si usa la riga di codice

#define new DEBUG_NEW

prima di una delle implementazioni in un oggetto . Il file CPP, quindi verrà usata la seconda versione di , archiviando il nome file e il numero di new riga nel blocco allocato per la creazione di report successivi. Non è necessario preoccuparsi di fornire i parametri aggiuntivi; una macro si occupa di questo per te.

Anche se non si usa DEBUG_NEW in modalità debug, si ottiene comunque il rilevamento delle perdite, ma senza la segnalazione del numero di riga del file di origine descritto in precedenza.

Nota

Se si esegue l'override di questo operatore, è anche necessario eseguire l'override di delete. Non usare la funzione della libreria _new_handler standard.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata negli CObject esempi.

void* CAge::operator new(size_t nSize)
{
   return malloc(nSize);
}

void* CAge::operator new(size_t nSize, LPCSTR lpszFileName, int nLine)
{
   UNREFERENCED_PARAMETER(lpszFileName);
   UNREFERENCED_PARAMETER(nLine);
   return malloc(nSize);
}

CObject::Serialize

Legge o scrive l'oggetto corrente da o in un archivio.

virtual void Serialize(CArchive& ar);

Parametri

ar
Oggetto CArchive da serializzare da o verso.

Osservazioni:

Eseguire l'override Serialize per ogni classe che si intende serializzare. L'override Serialize deve prima chiamare la Serialize funzione della relativa classe di base.

È inoltre necessario utilizzare la DECLARE_SERIAL macro nella dichiarazione di classe ed è necessario utilizzare la IMPLEMENT_SERIAL macro nell'implementazione.

Usare CArchive::IsLoading o CArchive::IsStoring per determinare se l'archivio sta caricando o archiviando.

Serialize viene chiamato da CArchive::ReadObject e CArchive::WriteObject. Queste funzioni sono associate all'operatore di inserimento ( <<) e all'operatore CArchive di estrazione ( >>).

Per esempi di serializzazione, vedere l'articolo Serializzazione di un oggetto.

Esempio

Vedere CObList::CObList per un elenco della CAge classe usata in tutti gli CObject esempi.

void CAge::Serialize(CArchive& ar)
{
   CObject::Serialize(ar);
   if(ar.IsStoring())
      ar << m_years;
   else
      ar >> m_years;
}

Vedi anche

Grafico della gerarchia