Ein Tweet (Twitter-Eintrag) hat mich auf diese Idee gebracht. Da hat jemand seine alte Platte aus dem Keller geholt und mal drauf geschaut was da so alles drauf war. Ich habe heute mal eine alte Box mit CD’s aufgemacht aus vergangenen Tagen. Dabei ist mir eine Projekt CD ins Auge gesprungen die ich mir nochmal angeschaut habe.

Mein Aufruf

Ich fand das so Interessant das ich einfach mal einen Aufruf starten möchte: Postet doch mal Euer Zeug was Ihr so vor 10 oder mehr Jahren gemacht habt, ein Stück Code oder einfach nur einen Screenshot.

Mein Beispiel aus dem Jahre ‘99

Ich selbst habe mich für eine C++ Header Datei entschieden. Damals im Projekt haben wir oft VB6 Komponenten einbinden müssen und es gab meist einen generischen Parameter: SafeArrays. Jeder der schonmal mit C++ SafeArrays implementiert hat, weiß was das für ein Käse ist. Die entwickelte Hilfsklasse machte es einfacher mit den Dingern umzugehen. Hier ist der Code (nur der Header) aus dem Jahre 99:

////////////////////////////////////////////////////////////////////////////////
// ComDefEx.h - Erweiterung zu ComDef.h und ComUtil.h

#ifndef _COMDEFEX_H
#define _COMDEFEX_H

#ifndef _COMDEFEX_API
#define _COMDEFEX_API
#endif

#include <ComDef.h>


////////////////////////////////////////////////////////////////////////////////
// Exception handling

#define _COM_RAISE_ERROR( __hres )                                              \
{                                                                               \
  HRESULT hres = __hres;                                                        \
                                                                                \
  if( FAILED( hres ) )                                                          \
  {                                                                             \
    _com_raise_error( hres );                                                   \
  }                                                                             \
}


#define _COM_RAISE_UNEXPECTED()         _com_raise_error( E_UNEXPECTED )
#define _COM_RAISE_OUTOFMEMORY()        _com_raise_error( E_OUTOFMEMORY )
#define _COM_RAISE_INVALIDARG()         _com_raise_error( E_INVALIDARG )


////////////////////////////////////////////////////////////////////////////////
// _guid_t Declaration

class _COMDEFEX_API _guid_t : public GUID
{
  public:
    // Construction/Destruction
                              _guid_t();
                              _guid_t( const GUID& guid );
                              _guid_t( LPCSTR pszGuid );
                              _guid_t( BSTR bstrGuid );
                              _guid_t( const _bstr_t& bstrGuid );
                              _guid_t( VARIANT vGuid );
                              _guid_t( const _variant_t& vGuid );

    // Operators
    _guid_t&                  operator =( const GUID& guid );
    _guid_t&                  operator =( LPCSTR pszGuid );
    _guid_t&                  operator =( BSTR bstrGuid );
    _guid_t&                  operator =( const _bstr_t& bstrGuid );
    _guid_t&                  operator =( VARIANT vGuid );
    _guid_t&                  operator =( const _variant_t& vGuid );

                              operator _bstr_t() const;     // without braces
                              operator _variant_t() const;  // BSTR without braces

    // General Operations
    void                      GetAsString( _bstr_t& bstrGuid, bool bIncBraces = FALSE ) const;
    void                      GetAsString( _variant_t& vGuid, bool bIncBraces = FALSE ) const;
};


////////////////////////////////////////////////////////////////////////////////
// _safearray_elm/_safearray_t Declaration

template< class T >
class _safearray_t;

template< class T >
class _safearray_elm
{
  // Friends
  friend class _safearray_t< T >;

  // Construction/Destruction
  protected:
                              _safearray_elm( SAFEARRAY* psa, int ix1 );
                              _safearray_elm( SAFEARRAY* psa, int ix1, int ix2 );
                              _safearray_elm( SAFEARRAY* psa, int ix1, int ix2, int ix3 );
                              _safearray_elm( SAFEARRAY* psa, int ix1, int ix2, int ix3, int ix4 );

  // Operators
  public:
    _safearray_elm&           operator =( const T& src );
                              operator T() const;

  // Attributes
  protected:
    SAFEARRAY*                m_psa;
    long                      m_rgnIndexPath[ 4 ];
};


template< class T >
class _safearray_t
{
  // Construction/Destruction
  public:
                              _safearray_t();

                              _safearray_t( const _safearray_t& src );
                              _safearray_t( const SAFEARRAY* psa );
                              _safearray_t( SAFEARRAY* psa, bool bCopy );

                              _safearray_t( const VARIANT& src );
                              _safearray_t( VARIANT& src, bool bCopy );

                              ~_safearray_t();

  // Operators
  public:
    _safearray_t&             operator =( const _safearray_t& src );
    _safearray_t&             operator =( const SAFEARRAY* psa );
    _safearray_t&             operator =( const VARIANT& src );

    const _safearray_elm< T > operator ()( int ) const;
    _safearray_elm< T >       operator ()( int );

    const _safearray_elm< T > operator ()( int, int ) const;
    _safearray_elm< T >       operator ()( int, int );

    const _safearray_elm< T > operator ()( int, int, int ) const;
    _safearray_elm< T >       operator ()( int, int, int );

    const _safearray_elm< T > operator ()( int, int, int, int ) const;
    _safearray_elm< T >       operator ()( int, int, int, int );

                              operator const SAFEARRAY*() const;
                              operator SAFEARRAY*();

                              operator VARIANT() const;

  // General Operations
  public:
    void                      Attach( SAFEARRAY* psa );
    void                      Attach( VARIANT& src );

    SAFEARRAY*                Detach();
    _variant_t                DetachVariant();

    void                      Create( UINT nSize1 );
    void                      Create( UINT nSize1, UINT nSize2 );
    void                      Create( UINT nSize1, UINT nSize2, UINT nSize3 );
    void                      Create( UINT nSize1, UINT nSize2, UINT nSize3, UINT nSize4 );

    SAFEARRAY*                Copy() const;

    int                       GetLowerBound( UINT nDim = 1 ) const;
    int                       GetUpperBound( UINT nDim = 1 ) const;
    int                       GetSize( UINT nDim = 1 ) const;
    bool                      IsEmpty() const;

  // Attributes
  protected:
    SAFEARRAY*                m_psa;
};


////////////////////////////////////////////////////////////////////////////////
// Miscellaneous

extern _variant_t             vtEmpty;
extern GUID                   guidEmpty;


struct _SafeLPCSTR
{
  inline LPCSTR operator ,( LPCSTR psz ) { return psz ? psz : ""; }
};


#define SafeLPCSTR( p )       ( _SafeLPCSTR(), ( LPCSTR ) p )


#include "ComDefEx.inl"


#endif  // !_COMDEFEX_H