|
|
R.18.3.1 Определения функций старого стиля
Можно использовать синтаксис С для определений функций: старое-определение-функции: спецификации-описаний opt старый-описатель-функции список-описаний opt тело-функции старый-описатель-функции: описатель ( список-параметров opt ) список-параметров: идентификатор список-параметров , идентификатор Приведем пример: max(a,b) int b; { return (a‹b) ? b : a; } Если определенная таким образом функция не была описана ранее, то тип ее формальных параметров полагается (…), т.е. он не будет проверяться. Если она была описана, то тип должен согласовываться с типом, указанным в описании. Приведенный синтаксис нельзя использовать для определения функций-членов.
R.18.3.2 Старый стиль задания инициализатора базового класса
В конструкции инициализатор-памяти (§R.12.6.2) можно не указывать имя-класса, обозначающее базовый класс при условии, что существует только один прямой (непосредственный) базовый класс. Поэтому в описании class B { //… public: B(int); };
class D: public B { //… D(int i): (i) {/*… */} }; будет вызываться конструктор B с параметром i.
R.18.3.3 Присваивание указателю this
Присваивая определенные значения указателю this, пользователь мог управлять выделением памяти для объекта некоторого класса. В конструкторе до использования членов класса можно было с помощью такого присваивания реализовать свой алгоритм выделения памяти. Присваивая в деструкторе указателю this нуль, можно было обойти стандартную операцию освобождения объектов класса. Кроме того, присваивание нуля в деструкторе отменяло неявные вызовы деструкторов для членов и базовых классов, например: class Z { int z[10]; Z() { this = my_allocator(sizeof(Z)); } ~Z() { my_deallocator(this); this = 0; } }; Если выделение памяти уже произошло (как бывает для членов и объектов auto или static), то при входе в конструктор this имеет ненулевое значение и значение нуль в противном случае. Вызовы конструкторов для членов и базовых классов произойдут только после того, как this получил значение. Если в конструкторе базового класса есть присваивание this, то новое значение this будет использоваться и в конструкторах производных классов, если они есть. Отметим, что при наличии указанного анахронизма или тип указателя this не может быть *const, или нужно делать исключение для this из правила о присваивании указателям со спецификацией const.
R.18.3.4 Приведение указателей на функцию-член
Указатель на функцию-член некоторого объекта можно привести к указателю на какую-то другую функцию, например (int (*) ())p-›f. Результирующий указатель будет настроен на функцию, вызов которой будет происходить с помощью обращения к этой функции-члену для того же объекта. Как обычно результат такого вызова считается неопределенным.
R.18.3.5 Невложенность классов
Если класс описан внутри другого класса и в программе больше не описано классов с этим именем, то его можно использовать, как если бы он был описан вне класса (так обстоит дело с описанием struct в С), например: struct S { struct T { int a; }; int b; };
struct T x; // означает `S::T x;'
Список служебных слов
auto автоматический break разрыв case вариант catch перехватить char символ class класс const конст continue продолжить default по умолчанию delete удалить do делать double двойной else иначе enum перечисление extern внешний float плавающий for для friend друг goto переход на if если inline подстановка int целый long длинный new новый operator оператор private частный protected защищенный public общий register регистровый return возврат short короткий signed знаковый sizeof размер static статический struct структура switch переключатель template шаблон типа this текущий throw запустить try проверить typedef тип union объединение unsigned беззнаковый virtual виртуальный void пустой volatile изменяемый while пока
* ПРИМЕРЫ *
B1_1_1.cxx
#include ‹stream.hxx›
main() { cout ‹‹ "Hello, world\n"; }
B1_1_3.cxx
#include ‹stream.hxx›
main () { int inch = 0; cout ‹‹ "inches="; cin ›› inch; cout ‹‹ inch; cout ‹‹ "in = "; cout ‹‹ inch*2.54; cout ‹‹ " cm\n"; }
B1_4_5v.cxx
#include ‹stream.hxx›
main() { const float fac = 2.54; float x, in, cm; char ch = 0;
for (int i= 0; i‹ 8; i++) { cerr ‹‹ "enter length: "; cin ›› x ›› ch;
if (ch == 'i') {// inch in = x; cm = x*fac; } else if (ch == 'c') {// cm in = x/fac; cm = x; } else in = cm = 0;
cerr ‹‹ in ‹‹ "in = " ‹‹ cm ‹‹ " cm\n"; } }
B1_5.cxx
#include ‹stream.hxx› extern float pow(float, int);
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; }
b1__13.cxx
#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); }
b1__14.cxx
#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"; }
b1__16.cxx
#include ‹vector.hxx›
declare(vector,int); implement(vector,int);
main() { vector(int) vv(10); vv[2] = 3; vv[10] = 4; // range error }
B2_1_3.cxx
#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(); }
B2_3.cxx
#include ‹stream.hxx›
main() { int* p = new int; cout ‹‹ "sizeof(int) = " ‹‹ sizeof(int) "\n"; }
B2_3_6a.cxx
#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"; } }
B2_3_6b.cxx
#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"; } }
B2_3_7.cxx
#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"; }
b2_3__10.cxx
#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"; }
B3_1all.cxx
#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; 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 { 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; }
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;} };
string::string() { p = new srep; p-›s = 0; p-›n = 1; }
string::string(char* s) { p = new srep; p-›s = new char[strlen(s) +1]; strcpy(p-›s, s); p-›n = 1; } string::string(string& x) { x.p-›n++; p = x.p; }
string::~string() { if (--p-›n - 0) { delete p-›s; delete p; } }
string& string::operator=(char* s) { if (p-›n › 1) { p-›n--; p = new srep; } else if (p-›n == 1) delete p-›s;
p-›s = new char[strlen(s)+1]; strcpy(p-›s, s); p-›n = 1; return *this; }
string& string::operator=(string& x) { x.p-›n++; if (--p-›n == 0) { delete p-›s; delete p; } p = x.p; return *this; }
ostream& operator‹‹(ostream& s, string& x) { return s ‹‹ x.p-›s ‹‹ " [" ‹‹ x.p-›n ‹‹ "]\n"; }
istream& operator››(istream& s, string& x) { char buf[256]; s››buf; x = buf; cout ‹‹ "echo: " ‹‹ x ‹‹ "\n"; return s; }
void error(char* p) { cout ‹‹ p ‹‹ "\n"; exit(1); } char& string::operator[](int i) { if (i‹0 || strlen(p-›s)‹i) error("index out of range"); return p-›s[i]; }
main() { string x[100]; int n;
cout ‹‹ "here we go\n"; for (n = 0; cin››x[n]; n++) { string y; if (n==100) error("too many strings"); cout ‹‹ (y = x[n]); if (y=="done") break; } cout ‹‹ "here we go back again\n"; for (int i=n-1; 0‹=i; i--) cout ‹‹ x[i]; }
B7_2_8.cxx
#include ‹stream.hxx›
struct employee { friend class manager; employee* next; char* name; short department; virtual void print(); };
struct manager: employee { employee* group; short level; void print(); };
void employee::print() { cout ‹‹ name ‹‹ "\t" ‹‹ department ‹‹ "\n"; }
void manager::print() { employee::print(); cout ‹‹ "\tlevel " ‹‹ level ‹‹ "\n"; }
void f(employee* ll) { for (; ll; ll=ll-›next) ll-›print(); }
main () { employee e; e.name = "J. Brown"; e.department = 1234; e.next = 0; manager m; m.name = "J. Smith"; m.department = 1234; m.level = 2; m.next = &e; f(&m); }
B7_7.cxx
#include ‹stream.hxx›
struct base { base(); };
struct derived: base { derived(); };
base:: base() { cout ‹‹ "\tbase 1: this=" ‹‹ long(this) ‹‹ "\n"; if (this == 0) this = (base*)27; cout ‹‹ "\tbase 2: this=" ‹‹ long(this) ‹‹ "\n"; }
derived::derived() { cout ‹‹ "\tderived 1: this=" ‹‹ long(this) ‹‹ "\n"; if (this == 0) this = (derived*)43; cout ‹‹ "\tderived 2: this=" ‹‹ long(this) ‹‹ "\n"; }
main() { cout ‹‹ "base b;\n"; base b; cout ‹‹ "new base;\n"; new base; cout ‹‹ "derived d;\n"; derived d; cout ‹‹ "new derived;\n"; new derived; cout ‹‹ "new derived;\n"; new derived; cout ‹‹ "at the end\n"; }
B8_3_3.cxx
#include ‹xstream.hxx›
extern void exit(int);
void error(char* s, char* s2) { cerr ‹‹ s ‹‹ " " ‹‹ s2 ‹‹ "\n"; exit(1); }
main(int argc, char* argv[]) { if (argc != 3) error ("wrong number of arguments",");
filebuf f1; if (f1.open(argv[1],input) == 0) error("cannot open input file",argv[1]); istream from(&f1);
filebuf f2; if (f2.open(argv[2],output) == 0) error("cannot open input file",argv[2]); ostream to(&f2);
char ch; while (from.get(ch)) to.put(ch);
if (!from.eof() || to.bad()) error("something strange happened","); }
Спасибо, что скачали книгу в бесплатной электронной библиотеке Royallib.ru Оставить отзыв о книге Все книги автора [1]"The C Programming Language" B. Kernighan, D. Ritchie. Prentice Hall, 1978, 1988. Есть русский перевод: "Язык программирования С. Задачи по языку С" Б. Керниган, Д. Ритчи, А. Фьюер. "Финансы и статистика". 1984
[2]American National Standard X3.159-1989. Американский национальный стандарт.
Не нашли, что искали? Воспользуйтесь поиском по сайту: ©2015 - 2024 stydopedia.ru Все материалы защищены законодательством РФ.
|