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

 nn-›string = new char[strlen(p) + 1];
 strcpy(nn-›string,p);
 nn-›value = 1;
 nn-›next = table[ii];
 table[ii] = nn;
 return nn;
}

inline name* insert(char* s) { return look (s,1); }

token_value get_token();
double term();

double expr()
{
 double left = term();

 for (;;)
  switch (curr_tok) {
  case PLUS:
   get_token();
   left += term();
   break;
  case MINUS:
   get_token();
   left -= term();
   break;
  default:
   return left;
  }
}

double prim();

double term()
{
 double left = prim();

 for (;;)
  switch (curr_tok) {
  case MUL:
   get_token();
   left *= prim();
   break;
  case DIV:
   get_token();
   double d = prim();
   if (d == 0) return error("divide by 0");
   left /= d;
   break;
  default:
   return left;
  }
}
int number_value;
char name_string[80];

double prim()
{
 switch (curr_tok) {
 case NUMBER:
  get_token();
  return number_value;
 case NAME:
  if (get_token() == ASSIGN) {
   name* n = insert(name_string);
   get_token();
   n-›value = expr();
   return n-›value;
  }
  return look(name_string)-›value;
 case MINUS:
  get_token();
  return -prim();
 case LP:
  get_token();
  double e = expr();
  if (curr_tok != RP) return error(") expected");
  get_token();
  return e;
 case END:
  return 1;
 default:
  return error ("primary expected");
 }
}

token_value get_token()
{
 char ch = 0;

 do {
  if (!cin.get(ch)) return curr_tok = END;
 } while (ch !='\n' && isspace(ch));

 switch (ch) {
 case ';':
 case '\n':
  cin ›› WS;
  return curr_tok=PRINT;
 case '*':
 case '/':
 case '+':
 case '-':
 case '(':
 case ')':
 case '=':
  return curr_tok=ch;
 case '0': case '1': case '2': case '3': case '4':
 case '5': case '6': case '7': case '8': case '9':
 case '.':
  cin.putback(ch);
  cin ›› number_value;
  return curr_tok=NUMBER;
 default:
  if (isalpha(ch)) {
   char* p = name_string;
   *p++ = ch;
   while (cin.get(ch) && isalnum(ch)) *p++ = ch;
   cin.putback(ch);
   *p = 0;
   return curr_tok=NAME;
  }
  error ("bad token");
  return curr_tok=PRINT;
 }
}

int main(int argc, char* argv[])
{
 switch (argc) {
 case 1:
  break;
 case 2:
  cin = *new istream(strlen(argv[1]),argv[1]);
  break;
 default:
  error("too many arguments");
  return 1;
 }

 // insert predefined names:
 insert("pi")-›value = 3.1415926535897932385;
 insert("e")-›value = 2.7182818284590452354;

 while (1) {
  get_token();
  if (curr_tok == END) break;
  if (curr_tok == PRINT) continue;
  cout ‹‹ expr() ‹‹ "\n";
 }

 return no_of_errors;
}

b3_2_6a.cxx

extern void strcpy(char *,char *);
extern void exit(int);
extern int strlen(char *);

char *save_string(char* p)
{
 char* s = new char[strlen(p)+1];
 strcpy(s,p);
 return s;
}

int main (int argc, char* argv[])
{
 if (argc ‹ 2) exit(1);
 int size = strlen(argv[1])+1;
 char* p = save_string (argv[1]);
 delete[size] p;
}

b3_2_6b.cxx

#include ‹stream.hxx›

extern void exit(int);
void out_of_store()
{

 cout ‹‹ "operator new failed: out of store\n";
 exit(1);
}

typedef void (*PF)();

extern PF set_new_handler(PF);

main()
{
 set_new_handler(&out_of_store);
 char *p = new char[100000000];
 cout ‹‹ "done, p = " ‹‹ long(p) ‹‹ "\n";
}

b4_6_8.cxx

// This version of the program does not assume sizeof(int) == sizeof(char*)!

#include ‹stream.hxx›
#include ‹stdarg.hxx›

extern void exit(int);
void error (int …);

main(int argc, char* argv[])
{
 switch (argc) {
 case 1:
  error(0,argv[0],(char*)0);
  break;
 case 2:
  error(0,argv[0],argv[1],(char*)0);
  break;
 default:
  error(1,"with",dec(argc-1),"arguments",(char*)0);
 }
}

void error(int n …)
{
 va_list ap;
 va_start(ap,n);

 for (;;) {
  char *p = va_arg(ap,char*);
  if (p == 0) break;
  cerr ‹‹ p ‹‹ " ";
 }

 va_end(ap);

 cerr ‹‹ "\n";
 if (n) exit(n);
}

b4_6_9.cxx

#include ‹stream.hxx›

struct user {
 char *name;
 char* id;
 int dept;
};

typedef user* Puser;

user heads[] = {
 "Mcilroy M.D", "doug", 11271,
 "Aho A.V.", "ava", 11272,
 "Weinberger P.J.", "pjw", 11273,
 "Schryer N.L.", "nls", 11274,
 "Schryer N.L.", "nls", 11275,
 "Kernighan B.W.", "bwk", 11276
};

typedef int (*CFT)(char*,char*);

void sort(char* base, unsigned n, int sz, CFT cmp)
{
 for (int i=0; i‹n-1; i++)
  for (int j=n-1; i‹j; j--) {
   char* pj = base+j*sz;
   char *pj1 = pj-sz;
   if ((*cmp)(pj,pj1) ‹ 0)
    // swap b[j] and b[j-1]
    for (int k=0; k‹sz; k++) {
     char temp = pj[k];
     pj[k] = pj1[k];
     pj1[k] = temp;
    }
  }
}

void print_id(Puser v, int n)
{
 for (int i=0; i‹n; i++)
  cout ‹‹ v[i].name ‹‹ "\t"
   ‹‹ v[i].id ‹‹ "\t"
   ‹‹ v[i].dept ‹‹ "\n";
}
extern int strcmp(char*, char*);

int cmp1(char* p, char* q)
{
 return strcmp(Puser(p)-›name, Puser(q)-›name);
}

int cmp2(char* p, char* q)
{
 return Puser(p)-›dept - Puser(q)-›dept;
}

main ()
{
 sort((char*)heads,6,sizeof(user),cmp1);
 print_id(heads,6);
 cout ‹‹ "\n";
 sort ((char*)heads,6,sizeof(user),cmp2);
 print_id(heads,6); // in department number order
}

b5_3_2.cxx

#include ‹stream.hxx›

class intset {
 int cursize, maxsize;
 int *x;
public:
 intset(int m, int n);
 ~intset();

 int member(int t);
 void insert(int t);

 void iterate(int& i) { i = 0; }
 int ok(int& i) { return i‹cursize; }
 int next(int& i) { return x[i++]; }
};

extern void exit (int);

void error(char *s)
{
 cout ‹‹ "set: " ‹‹ s ‹‹ "\n";
 exit(1);
}

extern int atoi(char *);

extern int rand();

int randint (int u) // in the range 1…u