Subject: demo 9 teht 1-8 Samuli Pekkola, Kimmo Wideroos, Pasi Kivinen

From: Jyri Samuli Pekkola <[email-masked]>
Date: Tue, 22 Nov 1994 15:22:17 +0200 (EET)

teht 1.

/*		CIRCLE.CPP
 	tehd„„n ympyr„-luokka, josta perit„„n piste	*/

 #include <stdio.h>
 #include <string.h>

 char *Tilat[] = {"Sammutettu","Sytytetty"};

 class ympyra {
 	int nakyy;
 	int vaihda_paikka(int nx, int ny);
 protected:
 	char nimi[20];
 	int x,y;
 	int r;
 public:
 	ympyra(char *s="ympyra", int ix=0, int iy=0, int ir=0) {
 		nakyy = 0;
 			x=ix;y=iy;r=ir; strcpy(nimi,s);
 		}
 	virtual ~ympyra() { sammuta(); }
 	int nakyvissa() {
 		return nakyy;
 		}
 	int sammuta();
 	int sytyta();
 	int siirra(int nx = 0, int ny = 0);
 	int muuta_koko(int nr) {
 		if (!nakyvissa()) { r = nr; return 0; }
 		sammuta(); r = nr; return sytyta();
 	}
 	virtual int piirra() {
 		printf("Ympyra„: %-10s %-10s:(%02d,%%d\n",
                         Tilat[nakyvissa()],nimi,x,y,r);
 		return nakyvissa();
 	}
 };

 int ympyra::vaihda_paikka(int nx, int ny) {
 	x = nx; y = ny; return nakyy;
 }

 int ympyra::sammuta()
 {
 	if (!nakyy) return 0;
 	nakyy = 0;
 	return piirra();
 }

 int ympyra::sytyta()
 {
 	if (nakyy) return 1;
 	nakyy=1;
 	return piirra();
 }

 int ympyra::siirra(int nx, int ny)
 {
 	if (!nakyy) return vaihda_paikka(nx,ny);
 	sammuta();
 	vaihda_paikka(nx,ny);
 	return sytyta();
 }

 class piste : public ympyra {

 public:
 	piste(char *s="piste",int ix = 0,int iy=0) :
          ympyra(s,ix,iy,0) {};
 	~piste() { sammuta(); }

 	int piste::piirra() {
 		printf("Piste : %-10s %-10s:(%02d,%02d); sade %d\n"
                                 ,Tilat[nakyvissa()],nimi,x,y,r);
 		return nakyvissa();
 	};
 };

 int main(void)
 {
 	printf("---------------------------------\n");
 	ympyra a("a",1,1,1),b("b",2,5);
 	piste y("y",3,3);
 	a.sytyta(); y.sytyta(); b.sytyta();
 	a.siirra(3,3); b.siirra(); a.muuta_koko(7);
 	return 0;
 }

****************************************************************************
 teht 6

#include <stdio.h>
#include <math.h>

class piste {
  int x,y;
public:
  void tulosta() {printf("(%d,%d)\n",x,y);}
  void aseta(int nx,int ny) { x=nx; y=ny; }
  piste(int ix=0, int iy=0) {aseta(ix,iy);}

  piste fabs(piste p) {
    if ( x<0 ) x=-x;
    if ( y<0 ) y=-y;
    return p;
  }

  int operator=(piste p) {
    if ( x = p.x && y = p.y ) return 1;
    return 0;
  }

  piste &operator+=(piste p) {
    x += p.x;
    y += p.y;
    return *this;
  }

  piste &operator-(piste p1) {
    x=-x;
    y=-y;
    (void)p1;
    return *this;
  }

};

int main(void)
{
  piste p1(0,3),p2(3,33);
  p1.tulosta();
  p1.aseta(-3,-33);
  p1.fabs(p1);
  p1.tulosta();
  if ( p1=p2 ) printf("ok\n");
  p1+=p2;
  p1.tulosta();
  p1 = p1-p2;
  p1.tulosta();
  p2.tulosta();
  return 0;
}

******************************************************************************
teht 8

#define LEFT       1
#define RIGHT      0

#define TYPE double

typedef struct linked_TYPE__ {
  TYPE elem;
  struct linked_TYPE__ *nxt;
  struct linked_TYPE__ *pre;
} linked_TYPE;

inline TYPE inside(linked_TYPE *a,linked_TYPE *x,linked_TYPE *b, int last) // x v„lille [a,b], jos b<a niin a
  { return x ? x->elem : last = LEFT ? a->elem : b->elem; }

class list {
protected:
  int nelem;           // Alkioiden lukum„„r„
  linked_TYPE *begin, *cursor, *end, *new_elem;
  int last_move;
public:
  list()           { nelem = 0;
		     begin = NULL;
		     tobegin();		    }
  ~list()          { dest(); nelem = 0;}
  void dest();

  int  out()       { return ( cursor = NULL );                             }
  int  tobegin()   { cursor = begin;       last_move = LEFT;  return out(); }
  int  forward()   { cursor = cursor->nxt; last_move = RIGHT; return out(); }
  int  toend()     { cursor = end;         last_move = RIGHT; return out(); }
  TYPE current()   { return inside(begin,cursor,end,last_move);             }
  TYPE first()     { tobegin(); return current();                           }
  TYPE next()      { forward(); return current();                           }
  TYPE last()      { toend();   return current();                           }
  int  empty()     { return ( nelem = 0 );                                 }
  int  add(TYPE p) { if ( nelem >= MAX_ELEM ) return 1;
		     new_elem = new linked_TYPE;
		     new_elem->elem = p;
		     new_elem->nxt = NULL;

		     if ( !begin ) {
		       begin = new_elem;
		       new_elem->pre = NULL;
		     }
		     else {
		       end->nxt = new_elem;
		       new_elem->pre = end;
		     }

		     end = new_elem;

		     nelem++;
		     return 0;
		   }
}; /* list */

void list::dest(){
  while(cursor){
    cursor = begin->nxt;
    delete []begin;
    begin = cursor;
  }
  nelem = 0;
}

class list2 : public list {
public:
  int  backward()   { --cursor;         return out();           }

};

#define VIIVA "------------------------------------------------------------\n"
/****************************************************************************/
int main(void)
{
  cout << VIIVA;

  list lc; lc.add(1.0); lc.add(1.1); lc.add(1.2); lc.add(1.3);

  for (char c=lc.first(); !lc.out(); c=lc.next() )
    cout << c << " ";

  cout << c << "\n" << VIIVA;

  for (lc.tobegin(); !lc.out(); lc.forward() )
    cout << lc.current() << " ";

  cout << lc.current() << "\n" << VIIVA;

  return 0;

}

*****************************************************************************
teht 2
  Jos on luokka piste ja luokka ympyra, ympyra perii pisteen.
Kutsuttaessa ympyran destructoria, se tuhoaa pisteen, mutta jattaa
ympyran koskematta.
  Koska silloin ei tiedeta kumpaa funktiota suoritetaan.

**************************************************************************
teht 3
  Koska nelioluokka maaritellaan vasta ympyra-luokan jalkeen.
Ei tiedeta, mita nelio-luokassa on.

***************************************************************************
teht 4
  Pitaa lisata 6 uutta friend-funktiota (jokaista mahtuuko-funktion
vastaava)

****************************************************************************
teht 5
  Koska muuten piste-luokka ei tieda kumpaa =-operaattoria kaytetaan ( kun
piste on muutettu int tai double ). Kaytetaanko
  piste &piste::operator=(int )
  vai
  piste &piste::operator=(piste )

*****************************************************************************
teht 7
  Koska [ ] on uudelleen maaritelty, ja se palauttaa referenssin oikeaan
alkioon.  ( Ja taulukko t on maaritelty (voi olla private))