Создание диаграммы классов и кода на С++ в среде RationalRose, страница 3

#include "list.h"

list::list()

{}

list::list(const list &right)

{}

list::~list()

{}

list & list::operator=(const list &right)

{}

int list::operator==(const list &right) const

{}

int list::operator!=(const list &right) const

{}

h:

#ifndef cont_h

#define cont_h 1

#include "list.h"

template <class type>

class cont

{  public:

      cont();

      cont(const cont< type > &right);

      cont ();

      ~cont();

      ~cont ();

      cont< type > & operator=(const cont< type > &right);

      int operator==(const cont< type > &right) const;

      int operator!=(const cont< type > &right) const;

      Variant add ();

      Integer get (Integer l);

      list< T>* find (Integer k);

      Variant show (Integer rv);

  protected:

  private:

      const list< T>* get_data () const;

      void set_data (list< T>* value);

      const list< T>* get_last () const;

      void set_last (list< T>* value);

  private:

      list< T>* data;

      list< T>* last;};

template <class type>

inline const list< T>* cont<type>::get_data () const

{  return data;}

template <class type>

inline void cont<type>::set_data (list< T>* value)

{  data = value;}

template <class type>

inline const list< T>* cont<type>::get_last () const

{  return last;}

template <class type>

inline void cont<type>::set_last (list< T>* value)

{  last = value;}

#endif

cpp

#include "cont.h"

template <class type>

cont<type>::cont()

{}

template <class type>

cont<type>::cont(const cont<type> &right)

{}

template <class type>

cont<type>::cont ()

{}

template <class type>

cont<type>::~cont()

{}

template <class type>

cont<type>::~cont ()

{}

template <class type>

cont<type> & cont<type>::operator=(const cont<type> &right)

{}

template <class type>

int cont<type>::operator==(const cont<type> &right) const

{}

template <class type>

int cont<type>::operator!=(const cont<type> &right) const

{}

template <class type>

Variant cont<type>::add ()

{}

template <class type>

Integer cont<type>::get (Integer l)

{}

template <class type>

list< T>* cont<type>::find (Integer k)

{}

template <class type>

Variant cont<type>::show (Integer rv)

{}

h:

#ifndef fig_kont_h

#define fig_kont_h 1

#include "cont.h"

class fig_kont

{

  public:

      fig_kont();

      fig_kont(const fig_kont &right);

      ~fig_kont();

      fig_kont & operator=(const fig_kont &right);

      int operator==(const fig_kont &right) const;

      int operator!=(const fig_kont &right) const;

  protected:

  private:

  private: };

#endif

cpp

#include "fig_kont.h"

fig_kont::fig_kont()

{}

fig_kont::fig_kont(const fig_kont &right)

{}

fig_kont::~fig_kont()

{}

fig_kont & fig_kont::operator=(const fig_kont &right)

{}

int fig_kont::operator==(const fig_kont &right) const

{}

int fig_kont::operator!=(const fig_kont &right) const

{}

h:

#ifndef fig_fill_h

#define fig_fill_h 1

#include "cont.h"

class fig_fill

{  public:

      fig_fill();

      fig_fill(const fig_fill &right);

      ~fig_fill();

      fig_fill & operator=(const fig_fill &right);

      int operator==(const fig_fill &right) const;

      int operator!=(const fig_fill &right) const;

  protected:

  private:

  private:    };

#endif

cpp

#include "fig_fill.h"

fig_fill::fig_fill()

{}

fig_fill::fig_fill(const fig_fill &right)

{}

fig_fill::~fig_fill()

{}

fig_fill & fig_fill::operator=(const fig_fill &right)

{}

int fig_fill::operator==(const fig_fill &right) const

{}

int fig_fill::operator!=(const fig_fill &right) const

{}

h:

#ifndef fig_komb_h

#define fig_komb_h 1

#include "cont.h"

class fig_komb

{  public:

      fig_komb();

      fig_komb(const fig_komb &right);

      ~fig_komb();

      fig_komb & operator=(const fig_komb &right);

      int operator==(const fig_komb &right) const;

      int operator!=(const fig_komb &right) const;

  protected:

  private:

  private: };

#endif

cpp

#include "fig_komb.h"

fig_komb::fig_komb()

{}

fig_komb::fig_komb(const fig_komb &right)

{}

fig_komb::~fig_komb()

{}

fig_komb & fig_komb::operator=(const fig_komb &right)

{}

int fig_komb::operator==(const fig_komb &right) const

{}

int fig_komb::operator!=(const fig_komb &right) const

{}