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

main()

{

for (int i=0; i‹10; i++) cout ‹‹ pow(2,i) ‹‹ "\n";

}

extern void error(char *);

float pow(float x, int n)

{

if (n ‹ 0) {

error ("sorry, negative exponent to pow()");

return 0;

}

switch (n) {

case 0: return 1;

case 1: return x;

default: return x*pow(x,n-1);

}

}

void error(char *s)

{

cout ‹‹ s;

}

#include ‹stream.hxx›

// 1.11

class vector {

int *v;

int sz;

public:

vector(int); // constructor

~vector(); // destructor

int size() { return sz; }

void set_size(int);

int& operator[](int);

int& elem(int i) { return v[i]; }

};

// 1.13

class vec: public vector {

int low, high;

public:

vec(int, int);

int& elem(int);

int& operator[](int);

};

main()

{

vector a(10);

for (int i=0; i‹a.size(); i++) {

a[i] = i;

cout ‹‹ a[i] ‹‹ " ";

}

cout ‹‹ "\n";

vec b(10,19);

for (i=0; i‹b.size(); i++) b[i+10] = a[i];

for (i=0; i‹b.size(); i++) cout ‹‹ b[i+10] ‹‹ " ";

cout ‹‹ "\n";

}

extern void exit(int);

// 1.13

void error(char* p)

{

cerr ‹‹ p ‹‹ "\n";

exit (1);

}

// 1.11

vector::vector(int s)

{

if (s‹=0) error("bad vector size");

sz = s;

v = new int[s];

}

int& vector::operator[](int i)

{

if (i‹0 || sz‹=i) error("vector index out of range");

return v[i];

}

vector::~vector()

{

delete v;

}

// 1.13

int& vec::elem(int i)

{

return vector::elem(i-low);

}

vec::vec(int lb, int hb): (hb-lb+1)

{

if (hb-lb‹0) hb = lb;

low = lb;

high = hb;

}

void vector::set_size(int) {/* dummy */}

int& vec::operator[](int i)

{

if (i‹low || high‹i) error("vec index out of range");

return elem(i);

}

#include‹stream.hxx›

extern void exit(int);

extern void error(char*);

// 1.11

class vector {

int *v;

int sz;

public:

vector(int); // constructor

~vector(); // destructor

int size() { return sz; }

void set_size(int);

int& operator[](int);

int& elem(int i) { return v[i]; }

};

vector::vector(int s)

{

if (s‹=0) error("bad vector size");

sz = s;

v = new int[s];

}

int& vector::operator[](int i)

{

if (i‹0 || sz‹=i) error("vector index out of range");

return v[i];

}

vector::~vector()

{

delete v;

}

// 1.14

class Vec: public vector {

public:

Vec(int s): (s) {}

Vec(Vec&);

~Vec() {}

void operator=(Vec&);

void operator*=(Vec&);

void operator*=(int);

};

Vec::Vec(Vec& a): (a.size())

{

int sz = a.size();

for (int i = 0; i‹sz; i++) elem(i) =a.elem(i);

}

void Vec::operator=(Vec& a)

{

int s = size();

if (s != a.size()) error("bad vector size for =");

for (int i =0; i‹s; i++) elem(i)=a.elem(i);

}

Vec operator+(Vec& a, Vec& b)

{

int s = a.size();

if (s!= b.size()) error("bad vector size for +");

Vec sum(s);

for (int i=0; i‹s; i++)

sum.elem(i) = a.elem(i) + b.elem(i);

return sum;

}

void error(char* p)

{

cerr ‹‹ p ‹‹ "\n";

exit (1);

}

void vector::set_size(int) {}

main()

{

Vec a(10);

Vec b(10);

for (int i=0; i‹a.size(); i++) a[i] = i;

b = a;

Vec c = a+b;

for (i=0; i‹c.size(); i++) cout ‹‹ c[i] ‹‹ "\n";

}

#include ‹vector.hxx›

declare(vector,int);

implement(vector,int);

main()

{

vector(int) vv(10);

vv[2] = 3;

vv[10] = 4; // range error

}

#include ‹stream.hxx›

int a = 1;

void f()

{

int b = 1;

static int c = 1;

cout ‹‹ " a = " ‹‹ a++

‹‹ " b = " ‹‹ b++

‹‹ " c = " ‹‹ c++ ‹‹ "\n";

}

main ()

{

while (a ‹ 4) f();

}

#include ‹stream.hxx›

main()

{

int* p = new int;

cout ‹‹ "sizeof(int) = " ‹‹ sizeof(int) "\n";

}

#include ‹stream.hxx›

extern int strlen(char*);

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

main ()

{

int sz = strlen(alpha);

for (int i=0; i‹sz; i++) {

char ch = alpha[i];

cout ‹‹ "'" ‹‹ chr(ch) ‹‹ "'"

‹‹ " = " ‹‹ ch

‹‹ " = 0" ‹‹ oct(ch)

‹‹ " = 0x" ‹‹ hex(ch) ‹‹ "\n";

}

}

#include ‹stream.hxx›

char v[2][5] = {

'a', 'b', 'c', 'd', 'e',

'0', '1', '2', '3', '4'

};

main() {

for (int i = 0; i‹2; i++) {

for (int j = 0; j ‹5; j++)

cout ‹‹ "v[" ‹‹ i ‹‹ "][" ‹‹ j

‹‹ "]=" ‹‹ chr(v[i][j]) ‹‹ " ";

cout ‹‹ "\n";

}

}

#include ‹stream.hxx›

main()

{

char cv[10];

int iv[10];

char* pc = cv;

int* pi = iv;

cout ‹‹ "char* " ‹‹ long(pc+1)-long(pc) ‹‹ "\n";

cout ‹‹ "int* " ‹‹ long(pi+1)-long(pi) ‹‹ "\n";

}

#include ‹stream.hxx›

struct pair {

char* name;

int val;

};

extern int strlen(char*);

extern int strcpy(char*, char*);

extern int strcmp(char*, char*);

const large = 1024;

static pair vec[large];

pair* find(char* p)

{

for (int i=0; vec[i].name; i++)

if (strcmp(p,vec[i].name)==0) return &vec[i];

if (i == large) return &vec[large-1];

return &vec[i];

}

int& value(char* p)

{

pair* res = find(p);

if (res-›name == 0) {

res-›name = new char[strlen(p)+1];

strcpy(res-›name,p);

res-›val = 0;

}

return res-›val;

}

const MAX = 256;

main ()

{

char buf [MAX];

while (cin››buf) value(buf)++;

for (int i=0; vec[i].name; i++)

cout ‹‹ vec[i].name ‹‹ ":" ‹‹ vec[i].val ‹‹ "\n";

}

#include ‹xstream.hxx›

#include ‹ctype.h›

enum token_value {

NAME, NUMBER, END,

PLUS = '+', MINUS = '-', MUL='*', DIV='/',

PRINT=';', ASSIGN='=', LP='(', RP=')'

};

token_value curr_tok;

struct name {

char* string;

name* next;

double value;

};

const TBLSZ = 23;

name* table[TBLSZ];

int no_of_errors;

double error(char* s) {

cerr ‹‹ "error: " ‹‹ s ‹‹ "\n";

no_of_errors++;

return 1;

}

extern int strlen(const char*);

extern int strcmp(const char*, const char*);

extern char* strcpy(char*, const char*);

name* look(char* p, int ins = 0)

{

int ii= 0;

char *pp = p;

while (*pp) ii = ii‹‹1 ^ *pp++;

if (ii ‹ 0) ii = -ii;

ii %= TBLSZ;

for (name* n=table [ii]; n; n=n-›next)

if (strcmp(p,n-›string) == 0) return n;

if (ins == 0) error("name not found");

name* nn = new name;

nn-›string = new char[strlen(p) + 1];

strcpy(nn-›string,p);

nn-›value = 1;