Бьярн Страустрап - Справочное руководство по C++

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;

}

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;

}

#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";

}

// 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);

}

#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

}

#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

{

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);