Справочное руководство по C++ - [58]

{
 int r = rand();
 if (r ‹ 0) r = -r;
 return 1 + r%u;
}

intset::intset(int m, int n)
{
 if (m‹1 || n‹m) error("illegal intset size");
 cursize = 0;
 maxsize = m;
 x = new int[maxsize];
}

intset::~intset()
{
 delete x;
}

void intset::insert(int t)
{
 if (++cursize › maxsize) error("too many elements");
 int i = cursize-1;
 x[i] = t;

while (i›0 && x[i-1]›x[i]) {
 int t = x[i];
 x[i] = x[i-1];
 x[i-1] = t;
 i--;
 }
}

int intset::member(int t)
{
 int l = 0;
 int u = cursize-1;

 int m =0;
 while (l ‹= u) {
  m = (l+u)/2;
  if (t ‹ x[m])
   u = m-1;
  else if (t › x[m])
   l = m+1;
  else
   return 1; // found
 }
 return 0; // not found
}

void print_in_order(intset* set)
{
 int var;
 set-›iterate(var);
 while (set-›ok(var)) cout ‹‹ set-›next(var) ‹‹ "\n";
}

main (int argc, char *argv[])
{
 if (argc!= 3) error("two arguments expected");
 int count = 0;
 int m = atoi(argv[1]);
 int n = atoi (argv[2]);
 intset s(m,n);

 int t = 0;
 while (count ‹m) {
  t = randint(n);
  if (s.member(t)==0) {
   s.insert(t);
   count++;
  }
 }
 print_in_order(&s);
}

b5_4_5.cxx

#include ‹stream.hxx›

struct cl
{
 char* val;
 void print(int x) { cout ‹‹ val ‹‹ x ‹‹ "\n"; }
 cl(char *v) { val = v; }
};

typedef void (cl::*PROC)(int);

main()
{
 cl z1("z1 ");
 cl z2("z2 ");
 PROC pf1 = &cl::print;
 PROC pf2 = &cl::print;
 z1.print(1);
 (z1.*pf1)(2);
 z2.print(3);
 ((&z2)-›*pf2)(4);
}

b5_5_3.cxx

main() {
 char *p = new char[100];
 char *q = new char[100];
 delete p;
 delete p;
}

b6_3_2.cxx

#include "stream.hxx"

int error (char * p)
{
 cout ‹‹ p ‹‹ "\n";
 return 1;
}

class tiny {
 char v;
 tiny assign(int i)
 {v  = (i&~63) ? (error("range error"),0) : i; return *this; }
public:
 tiny (int i) { assign(i); }
 tiny (tiny& t) { v = t.v; }
 tiny operator=(tiny& t1) { v = t1.v; return *this; }
 tiny operator=(int i) { return assign(i); }
 int operator int() { return v; }
};

void main()
{
 tiny c1 = 2;
 tiny c2 = 62;
 tiny c3 = (c2 - c1);
 tiny c4 = c3;
 int i = (c1 + c2);
 c1 = (c2 + (2 * c1));
 c2 = c1 - i;
 c3 = c2;
}

b6_6.cxx

#include ‹stream.hxx›

extern int strcpy(char*, char*);

extern int strlen(char *);

struct string {
 char *p;
 int size;
 inline string(int sz) { p = new char[size=sz]; }
 string(char *);
 inline ~string() { delete p; }
 void operator=(string&);
 string(string&);
};

string::string(char* s)
{
 p = new char [size = strlen(s) + 1];
 strcpy (p,s);
}

void string::operator=(string& a)
{
 if (this == &a) return;
 delete p;
 p=new char[size=a.size];
 strcpy(p,a.p);
}

string::string(string& a)
{
 p=new char[size=a.size];
 strcpy(p,a.p);
}
string g(string arg)
{
 return arg;
}

main()
{
 string s = "asdf";
 s = g(s);
 cout ‹‹ s.p ‹‹ "\n";
}

b6_7.cxx

#include ‹stream.hxx›
#include ‹string.h›
struct pair {
 char * name;
 int val;
};

class assoc {
 pair * vec;
 int max;
 int free;
public:
 assoc(int);
 int& operator[](char*);
 void print_all();
};

assoc::assoc(int s)
{
 max = (s‹16) ? s : 16;
 free = 0;
 vec = new pair[max];
}

int& assoc::operator[](char * p)
/*
 maintain a set of "pair"s
 search for p,
 return a reference to the integer part of its "pair"
 make a new "pair" if "p" has not been seen
*/
{
 register pair* pp;
 for (pp=&vec[free-1]; vec‹=pp; pp--)
  if (strcmp(p, pp-›name)-0) return pp-›val;

 if (free==max) {// overflow: grow the vector
  pair* nvec = new pair[max*2];
  for (int i=0; i‹max; i++) nvec[i] = vec[i];
  delete vec;
  vec = nvec;
  max = 2*max;
 }

 pp = &vec[free++];
 pp-›name = new char[strlen(p)+1];
 strcpy(pp-›name,p);
 pp-›val = 0;
 return pp-›val;
}

void assoc::print_all()
{
 for (int i=0; i‹free; i++)
  cout ‹‹ vec[i].name ‹‹ ": " ‹‹ vec[i].val ‹‹ "\n";
}

main()
{
 const MAX = 256;
 char buf[MAX];
 assoc vec(512);
 while (cin››buf) vec[buf]++;
 vec.print_all();
}

b6_8.cxx

#include ‹stream.hxx›
#include ‹string.h›

struct pair {
 char* name;
 int val;
};

class assoc {
 friend class assoc_iterator;
 pair* vec;
 int max;
 int free;
public:
 assoc(int);
 int& operator[](char*);
};
class assoc_iterator {
 assoc* cs;
 int i;
public:
 assoc_iterator(assoc& s) { cs =&s; i = 0; }
 pair* operator()()
 { return (i‹cs-›free) ? &cs-›vec[i++] : 0; }
};

assoc::assoc(int s)
{
 max = (s‹16) ? s : 16;
 free = 0;
 vec = new pair[max];
}

int& assoc::operator[](char* p)
{
 register pair* pp;

 for (pp = &vec[free-1]; vec‹=pp; pp--)
  if (strcmp(p,pp-›name)==0) return pp-›val;

 if (free == max) {
  pair* nvec = new pair[max*2];
  for (int i=0; i‹max; i++) nvec[i] = vec[i];
  delete vec;
  vec = nvec;
  max = 2*max;
 }

 pp =&vec[free++];
 pp-›name = new char[strlen(p)+1];
 strcpy(pp-›name,p);
 pp-›val = 0;
 return pp-›val;
}

main()
{
 const MAX = 256;
 char buf[MAX];
 assoc vec(512);
 while (cin››buf) vec[buf]++;
 assoc_iterator next(vec);
 pair* p;
 while (p = next())
  cout ‹‹ p-›name ‹‹ ": " ‹‹ p-›val ‹‹ "\n";
}

b6_9.cxx

#include ‹stream.hxx›
#include ‹string.h›

extern void exit(int);
class string {
 struct srep {
  char* s;
  int n;
 };
 srep *p;

public:
 string(char *);
 string();
 string(string&);
 string& operator=(char *);
 string& operator=(string&);
 ~string();
 char& operator[](int i);

 friend ostream& operator‹‹(ostream&, string&);
 friend istream& operator››(istream&, string&);

 friend int operator==(string&x, char *s)
  { return strcmp(x.p-›s, s) == 0; }

 friend int operator==(string&x, string&y)
  { return strcmp(x.p-›s, y.p-›s) == 0; }