---------------------------------------------------------------
---------------------------------------------------------------
++
1991. ++ - ,
.
"The C Programming Language" B. Kernighan, D. Ritchie. Prentice
Hall, 1978, 1988.
: " . "
. , . , . . " ". 1984
++ ,
, , ,
, , ,
.
$$R.18.1. ++ ANSI C++ $$R.18.2 .
American National Standard X3.159-1989.
.
++ 1985
$$R.18.1.2. , ($$R.14)
($$R.15),
.
:
1. .
2. .
3. .
4. .
5. .
6. .
7. .
8. .
9. .
10. .
11. .
12. -.
13. .
14. .
15. .
16. .
A:
B:
,
. ,
,
" ".
"opt",
{ opt }
, .
++ ($$R.3.3).
.
($$R.16),
.
, ,
# ($$R2.1).
.
, .. ,
.
: , ,
, . ,
, ,
( "" ), , ,
, .
, ,
.
,
,
.
/* , */.
. //
, . //,
/* */ //
. // /*
/*.
- .
, _
. .
.
:
asm continue float new signed try
auto default for operator sizeof typedef
break delete friend private static union
case do goto protected struct unsigned
catch double if public switch virtual
char else inline register template void
class enum int return this volatile
const extern long short throw while
,
(__) ++
.
++ ASCII
:
! % ^ & * ( ) - + = { } | ~
[ ] \ ; ' : " < > ? , . /
:
-> ++ -- .* ->* << >> <= >= == != &&
|| *= /= %= += -= <<= >>= &= ^= |= ::
.
:
# ##
, , ,
sizeof ($$R5.3.2)
($$R.3.6.1)
($$R.16.4)
<float.h> <limits.h> <stddef.h>
ANSI .
<new.h> <stdarg.h> <stdlib.h>
.
ANSI , <new.h>
++.
( "").
:
, ,
( ),
0 ( ). , 0,
( ). 8 9
. ,
0x 0X, (
).
a A f F
. , 12,
014 0XC.
,
. ,
: int, long int,
unsigned long int.
,
: int, unsigned int, long int, unsigned long int.
u U,
: unsigned int, unsigned long int.
l L,
: long int, unsigned long int.
ul, lu, uL, Lu, Ul, lU, UL LU,
unsigned long int.
,
, 'x'.
char.
.
int.
.
, ,
', ", ?,
\, (
\) :
NL (LF) \n
HT \t
VT \v
BS \b
CR \r
() FF \f
BEL \a
\ \\
? \?
' \'
" \"
ooo \ooo
hhh \xhhh
,
, .
\ooo ,
, . ,
. \xhhh
, x, ,
, .
, .
.
, ,
.
char,
.
,
L, , , L'ab'.
wchar_t,
($$R.3.6.1),
<stddef.h>.
, .
,
, , e E,
, .
(
) . ,
( ) . , e ( E)
( ).
double,
. f F
float, l L long double.
(
$$R.2.5.2), , .. "...".
" " static ($$R.3.5),
.
(.. ), .
. ,
, . ,
"\xA" "B"
'\xA' 'B' (
'\xAB').
'\0', , ,
. ,
.
" \.
, L,
, , L"asdf".
" wchar_t", wchar_t
,
<stddef.h>.
.
, , ,
, , , , .
.
,
. , .
, ,
( ) , , ,
, ($$R.3.3)
.
($$R.3.7).
($$R.3.5),
. , ,
, .
($$r.7)
. ,
($$R.8.3),
extern ($$R.7.11), ,
($$R.9.4), ($$R.9.1),
typedef ($$R.7.1.3). :
int a;
extern const c = 1;
int f(int x) { return x+a; }
struct S { int a; int b; };
enum { up, down };
:
extern int a;
extern const c;
int f(int);
struct S;
typedef int Int;
, , ,
,
($$R.3.3).
, . ,
, ,
.
: , , .
: , ($$R.6.3),
,
.
,
.
: ($$R.6.1) ,
. ,
.
: ($$R.6.3) ($$R.9)
, . ,
, .
:
-
($$R.9.3), . ,
($$R.5.2.4) ($$R.10),
->,
($$R.5.2.4) ,
:: ($$R.5.1),
. ,
friend ($$R.11.4), ,
, friend. ,
return ,
.
,
($$R.8.2.5) friend ($$R.11.4).
. -
, ,
:: ($$R.4.1, $$R.9.4, $$R.10). ,
,
, ::
($$R.5.1). , ($$R.9.1)
, ,
. , ,
( )
, .
,
, ,
- ,
class, struct union ($$R.7.1.6). ,
,
enum ($$R.7.1.6). $$R.10.4
.
($$R.8), ( ).
,
int x = 12;
{ int x = x; }
x ()
.
, :
enum { x = x };
x
() .
,
($$R.2). .
,
static,
, ..
. ,
. ,
inline,
. ,
const extern,
. ,
, ,
($$R.9.4), -,
($$R.9.3.2).
,
, ,
($$R.3.7),
($$R.8.2.5) ($$R.9).
, . ,
static,
, ()
,
-,
, .
(typedef $$R.7.13),
($$R.7.2) ($$R.14)
.
($$R.9.4) .
-, ,
. -, ,
.
($$R.3.2),
extern, ,
static ($$R.7.1.1).
, ,
,
($$R.7.1.3) ($$R.8.2.4).
, ,
, . ,
,
. ,
, ,
.
.
($$R.7.4).
main().
.
, ,
. ,
argv . main
int main() { /* ... */ }
int main(int argc, char* argv[]) { /* ... */ }
argc ,
, . argc
, ,
'\0', argv[0] argv[argc-1],
argv[0] , ,
"". , argv[argc]==0.
main() .
main() ($$R.3.3) .
main() inline static.
void exit(int);
<stdlib.h>, .
.
($$R.3.5)
, .
($$R.8.4, $$R.9.4, &&R.12.1, $$R.12.6.1)
main()
,
, .
($$R.8.4)
( )
.
.
$$R.8.4.
($$R.12.4)
main() exit().
. atexit() <stdlib.h>
, .
atexit(), ,
atexit(), ,
, atexit(). ++
, ,
, atexit(),
.
void abort();
<stdlib.h>,
,
atexit().
: .
.
.
($$R.12.1) ,
,
($$R.12.4) ($$R.6.7).
, ,
,
, ,
.
,
, , ,
, .
$$R.3.4 $$R.6.7.
, . $$R.5.3.3 $$R.12.2.
.
static ($$R.7.1.1).
: .
.
<limits.h>
.
, (char),
.
,
.
unsigned signed. char, signed char
unsigned char .
.
short int, int long int
.
,
, ,
. ,
,
.
signed char, short, int long
,
.
-
, ($$R.5.4).
, unsigned,
2@n, n ,
. ,
.
: float, double long double.
double ,
float, long double ,
double.
<float.h>.
char, int ($$R.7.2)
.
.
void .
, .
void.
void ($$R.5.4),
- ($$R.6.2),
($$R.5.18)
?: ($$R.5.16).
,
:
, $$R.8.4;
,
, $$R.8.2.5;
, $$R.8.2.1;
, $$R.8.2.2;
, , $$R.7.1.6;
, ($$R.9),
($$R.9.3)
, $$R.11;
,
, $$r.11;
, ,
, $$R.9.5;
,
, $$R.8.2.3.
, $$r.8.2.1, $$R.8.2.4, $$R.8.2.5
$$R.8.2.2.
T " T". ,
int " int",
X " X".
void* ( void), const void*
volatile void*
. void* ,
.
, "",
,
.
typedef ($$R.7.1.3),
($$R.14).
- , - ,
.
. , , ,
E , *E - ,
, E. ""
("lvalue" .. left value - )
E1 = E2, E1 ""
. $$R.5
.
, ,
const.
.
, ,
.
.
($$R.8.4, $$R.8.4.3, $$R.12.8, $$R.12.1).
$$R.12.3 $$R.13.2 ,
, .
,
($$R.8.2.2).
, , char, short int,
($$R.7.2) ($$R.9.6),
. int
, int,
unsigned int.
.
,
,
(mod 2**n), n
.
,
.\
, ,
, ,
.
float
.
float ,
.
float
,
,
.
,
.
"", .. .
,
. ,
.
,
. ,
.
R.4.5
.
" ".
long double,
long double.
, double,
double.
, float,
float.
, ($$R.4.1)
.
, unsigned long,
unsigned long.
, long int, -
unsigned int, , long int
unsigned int, unsigned int
long int,
unsigned long int.
, long,
long.
, unsigned,
unsigned.
, int.
, ($$R.8.2.1) , ,
,
:
($$R.5.19), ,
, .
,
.
, const
volatile, void*.
void*, ,
void* ,
.
($$R.10),
($$R.10.1).
, ($$R.11.1).
, .
(0) .
" T"
.
", T" "
, T", ,
&
().
, ($$R.8.2.2) (
($$R.5.2.2) ($$R.6.6.3))
, :
($$R.10, $$R.11.1) ($$R.8.4.3),
,
($$R.10.1.1).
, .
, ($$R.8.2.3) ,
, ,
:
($$R.5.19), ,
. ,
.
, ,
,
($$R.10.1.1).
(..
)
,
(..
) ($$R.4.6, $$R.10).
.
,
.
void*.
,
. - ,
.
.
, .. ,
($$R.9).
$$R.13.4.
, ,
,
. , ++a
a+=1, ($$R.13.4).
,
.
,
.
.
,
.
. ,
, ,
, :
i = v[i++]; // the value of `i' is undefined
i=7,i++,i++; // `i' becomes 9
. ++
.
.
, const T, volatile T,
T&, const T& volatile T& ,
T. , T* const, T*volatile
, T*,
. , T
, volatile T const T.
, const T* volatile
, T*,
. ($$R.13.2)
.
" T" ($$R.8.2.2, $$R.8.4.3),
"T",
. .
.
( ) , .. ($$R.12.3)
($$R.13.2),
,
,
($$R.8.4), , ($$R.6.4),
, ($$R.6.5),
, ($$R.6.6.3),
($$R.5.2.2).
, ,
::.
-:
this
::
:: --
:: -
( )
.
($$R.2.5).
- ($$R.9.3)
this ,
. this
- .
:: ,
-- -
. ,
--. ,
--. ,
. --
. ::
, , ,
($$R.3.2).
,
.
, .
- -,
. -> ($$R.5.2.4):
:
--
--
~-
-
,
($$R.7). -- ($$R.13.4),
-- ($$R.12.3.2).
~- ($$R.12.4).
-:
-- ::
--, ::
($$R.9.2),
($$R.10) -.
, .
, .
( ),
.
-::- -::~-,
- .
($$R.12.1) ($$R.12.4)
.
, , N1::N2::N3::n,
($$R.9.7).
.
-:
-
- [ ]
- ( - opt )
-- ( - opt )
- .
- ->
- ++
- --
-:
-
- , -
,
, .
. " T",
. "T".
E1[E2] ( ) *((E1) + (E2)).
* + $$R.5.3 $$R.5.7,
$$R.8.2.4.
, ,
, , .
.
", T", "
, T" " , T",
"T".
($$R.8.4.3, $$R.12.8, $$r.12.1) .
($$R.4) ($$R.12.3)
.
,
, ,
const ($$R.8.2.2).
($$R.7.1.6, $$R.2.5,$$R.2.5.4,$$R.8.2.4,
$$R.12.2). ,
-.
,
( $$R.8.2.6)
( ... $$R.8.2.5),
($$R.8.3).
,
, . ,
, ,
, (...).
float,
, double,
char, short, ,
, int unsigned
($$R.4.1).
, ,
.
,
,
($$R.12.2, $$R.12.8).
,
.
.
.
.
,
.
-- ($$R.7.1.6),
-
.
, ,
($$R.8.4, $$R.12.1).
-- ($$R.7.1.6),
(), .
, ,
,
, . ($$R.5.4).
, (.) ,
.
, .
,
.
, (->) ,
.
,
. ,
,
. E1->MOS , (*E1).MOS.
, " "
($$R.9.2) ($$R.9.5).
$$R.9.
, ++,
. .
.
( )
1. ,
(. $$R.5.7 $$R.5.17).
-- (
1) ++.
.
-:
-
++
--
- -
sizeof -
sizeof ( - )
-
-
-:
* & + - ! ~
* :
, , ,
. " T",
"T".
& .
-. ,
"T", " T". ,
const T const T*,
volatile. "C"
"T",
" C T". T
" T".
($$R.13)
,
($R13.3).
+
.
. .
-
.
.
2**n, n
.
.
!
, 1,
0, 0, 0.
int.
~ ,
.
.
.
++ 1.
.
. ,
. ++x x+=1.
($$R.5.7) ($$R.5.17).
-- 1
++.
sizeof .
, ,
. sizeof , ,
, void
. ,
sizeof, sizeof(char) 1.
,
, . ,
,
.
.
. , n
, n.
sizeof ,
.
size_t.
<stddef.h>
.
new -
($$R.8.1).
, .
-:
::opt new -new opt --new -new
::opt new -new opt ( - ) -new
-new:
( - )
--new:
-- -new opt
-new:
* --cv opt -new opt
- :: --cv opt -new opt
-new opt [ ]
-new:
( - opt )
, new,
, . new
. ,
. ,
new int new int[1] int* ,
new int[i][10] int(*)[10].
($$R.8.2.4), , , -
($$R.5.19) .
,
- ( ,
-
- ($$R.5.19)).
, operator new()
. .
.
-- const,
volatile, .
new
operator new() ($$R.12.5). T
sizeof(T).
-new .
, new T operator new(sizeof(T)),
new(2,f) T operator new(sizeof(T),2,f).
-new ,
operator new() .
new
( ),
::operator new(). new
T, T::operator new(),
(
, $$R.10.1.1),
::operator new(). ::new() ,
::operator new(),
T::operator new().
- -new.
($$R.12.1)
,
-new
( ) ( ). ,
, ,
.\
,
new , ,
, ($$R.12.1).
operator new, , .
, operator new()
($$R.12).
.
new
, ($$R.12.1).
.
,
operator new() . 0 (
), 0.
operator new()
.
,
operator new() 0.
--new .
new int (*[10])(); // error
, ..
(new int) (*[10])(); // error
new
, ,
new (int (*[10])());
10 (
int).
--new -
-new.
&, *, [] , ,
new int* i; // syntax error: parsed as `(new int*) i'
// not s `(new int)*i'
* ,
.
delete , new.
-:
::opt delete -
::opt delete [] -
void. delete ,
new. delete ,
new
-new,
. ,
.
,
. ,
, , ,
.
.
delete ( $$12.4)
, .
, ,
delete operator delete ($$R.12.5).
, (
), ::operator delete().
T T::operator delete(),
(
, $$R.10.1.1),
::operator delete().
::delete ,
::operator delete(), T::operator delete().
delete [ ] -
. ,
.
delete
,
delete [].
($$R.5.2.3) .
-:
-
( - ) -
,
--.
.
,
($$R.12.3),
.
,
($$R.4),
()
.
,
, .
, ,
, ,
.
. ,
( ),
, .
.
( ,
).
(" "),
, .
,
.
.
,
. void*
.
B D,
B
, D B
($$R.4.6, $$.R10.1.1) B
($$R.10.1).
,
.
, .
,
.
(0) .
,
($$R.10.1).
X&,
X*.
.
, ,
..
,
.
,
.
,
, .
, ,
. ,
, ,
, - ,
.
.
, ,
,
(. $$R.4.6).
,
($$R.12.3).
,
, ,
- ,
($$R.4.8).
, const,
const.
.
, const,
const.
.
,
, const.
.
volatile
volatile.
, . volatile
volatile.
-- .
-pm:
-
-pm .* -
-pm ->* -
.* ,
" T", ,
T , T
.
, .
->* ,
" T", ,
" T" " , T
".
,
.
.* ->* ,
(), ,
(ptr_to_obj->*ptr_to_mfct)(10);
-, ptr_to_mfct,
, ptr_to_obj.
.* ->* ,
.
*, /, % .
-:
-pm
- * -pm
- / -pm
- % -pm
* / ,
% .
($$R.4.5)
.
* .
/ , %
.
/ % 0, ,
(a/b)*b + a%b a. ,
,
.
R.5.7
+ - ,
($$R.4.5)
.
-:
-
+ -
- - -
.
+ .
.
, ,
. , P
, P+1
.
,
, ,
.
- .
,
, +.
.
,
,
.
1.
, ptrdiff_t
<stddef.h>. ,
. P
, (P+1) - 1 P.
<< >> .
-:
-
- <<
- >>
,
.
. ,
.
E1<<E2 E1 (
), E2 ,
. E1>>E2 E1,
E2 . E1
, ,
- ( ), .
,
, a<b<c (a<b)<c, (a<b)&&(b<c).
-:
-
- < -
- > -
- <= -
- >= -
.
< ( ), > ( ), <= ( )
>= ( ) 0,
, 1, . int.
.
. ,
, 0,
, void* (
void*).
( ) ,
.
.
,
, , ,
, ,
- ($$R.11.1), .
- ($$R.11.1) ,
.
() , .
, , ,
.
.
-:
-
- == -
- != -
== () != ( )
, , . ( ,
a<b == c<d 1, a<b c<d
.)
, .
($$R.4.8).
-,
0.
-:
-
- & -
, -
.
.
--:
-
-- ^ -
, -
.
.
-:
--
- | --
, -
.
.
--:
-
-- && -
&& .
1, , - 0.
& && ,
, , 0.
,
. int.
.
--:
--
-- || --
|| . 1,
, - 0.
| || ,
, ,
.
,
. int.
.
-:
--
-- ? : -
.
. , ,
,
, -
.
.
,
, , ,
,
.
-, 0,
,
. ,
, .
void,
void.
T, T. , .
.
( ). ,
.
,
. ,
.
. - ,
.
.
-:
-
- - -
-:
= *= /= %= += -= >>= <<= &= ^= |=
(=)
, .
, ,
, .
($$R.7.2) ,
,
. ,
-,
0. ,
.
T* const T*,
($$R.7.1.6).
const T volatile T T
volatile T (. $$R.8.4).
,
-,
0;
.
X ($$R.9)
X::operator=() ($$R.13.4.3).
X::operator=(),
($$R.12.8). , ,
X,
public ($$R.4.6),
X.
B
D , D
B,
public ($$R.10.1.1).
" T"
T, .
E1 op= E2
E1 = E1 op (E2), E1 .
+= -= ,
() , $$R.5.7.
, ,
.
($$R.8.4, $$R.12.1, $$R.12.6, $$R.12.8).
.
:
-
, -
, ,
.
.
. ,
.
, ,
($$R.5.2.2)
($$R.8.4),
, ,
f(a, (t=3,t+2), c);
, 5.
++ ,
, :
($$R.8.2.4), case ($$R.6.4.2),
($$R.9.6)
($$R.7.2).
-:
-
- :
($$R.2.5), ,
const, -
($$R.8.4) sizeof. ($$R.2.5.3)
.
.
, , ,
sizeof.
-.
, ,
.
:
-
-
-
-
-
-
-
.
-:
:
case - :
default :
.
goto.
, .
. goto
.
.
case default
.
;
:
-:
opt ;
-
. -
. -
.
,
({)
while ($$R.6.5.1).
,
, (
"").
-:
{ - opt }
-:
-
, ($$R.6.7).
.
-:
if ( )
if ( ) else
switch ( )
- .
, ,
,
($$R.12.3).
, ,
.
else 0,
. else
else if,
else.
.
,
($$R.12.3). .
, :
case - :
- ($$R.5.19)
. case
.
default:
,
case default ,
.
,
(case).
,
, .
,
default, .
default , ,
.
, ,
- ,
" case default" .
break (. $$R.6.6.1).
, ,
. .
,
, ,
, (..
, $$R.6.7). ,
.
.
-:
while ( )
do while ()
for ( - opt ; opt )
-:
-
-
, -
.
- .
while ,
.
.
, ,
,
($$R.12.3).
do ,
.
.
, ,
,
($$R.12.3).
for
for (- -1 opt ; -2 opt )
-
while (-1) {
-2 ;
}
, continue for
-2 &
-1. ,
, ,
, ,
,
, .
, ,
,
($$R.12.3).
.
-1, while while (1).
- , ,
, ,
for.
.
-:
break ;
continue ;
return opt ;
goto ;
( )
($$R.12.4) ,
, .
,
($$R.12.2).
break
,
.
, , .
continue
, .. .
, :
while (foo) { do { for (;;) {
// ... // ... // ...
contin: ; contin: ; contin: ;
} } while (foo); }
continue, ,
goto contin.
return.
return
, , .. ,
void, ($$R.12.1)
($$R.12.4). return
, .
, .
, ,
return, .
($$R.12.2).
, ,
.
goto ,
.
($$R.6.1), .
:
-:
, ,
,
, .
(auto) (register)
,
-. ,
, ($$R.6.6).
, ,
. , Index j
i:
for (int i = 0; i<100; i++)
for (Index j = 0; j<100; j++) {
// ...
}
,
,
, , ,
, .
,
. ,
, ,
, (..
) ,
. ,
void f()
{
// ...
goto lx; //: ,
// ...
ly:
X a = 1;
// ...
lx:
goto ly; // ,
// `a'
}
,
, ,
. ,
if (i)
for (int j = 0; j<100; j++) {
// ...
}
if (j!=100) // :
// ...
;
static ($$R.7.1.1)
,
. ,
-,
,
($$R.8.4).
,
.
, atexit() ($$R.3.4).
,
- , , -,
,
($$R.5.2.3),
, (.
.
,
- .
. ,
T - -- ($$R.7.1.6),
T(a)->m = 7; // -
T(a)++; // -
T(a,5)<<c; // -
T(*e)(int); //
T(f)[]; //
T(g) = {1, 2 }; //
T(*d)(double(3)); //
. ,
T(a); //
T(*b)(); //
T(c)=7; //
T(d),e,f=3; //
T(g)(h,2); //
, ..
, - .
- ,
,
($$R.6.3) -, :
void g()
{
int f(); //
int a; //
f(); // -
a; // -
}
;
, ,
.
:
- opt - opt ;
-asm
-
-
- ($$R.8)
. -
($$R.8.3) .
- , ($$R.9)
($$R.7.2), .. -
- -.
-asm $$R.7.3, -
$$R.7.4.
($$R.3.2), $$R.10.4.
:
-:
--
-
-fct
--
friend
typedef
-:
- opt -
-,
, , ,
-. ,
. ,
typedef char* Pc;
static Pc; // :
static Pc ,
Pc.
int Pc,
- int, , ()
Pc typedef, Pc
-, ,
void f(const Pc); // void f(char* const)
void g(const int Pc); // void g(const int)
, signed, unsigned, long short
int, -typedef,
,
() , ,
void h(unsigned Pc); // void h(unsigned int)
void k(unsigned int Pc); // void k(unsigned int)
:
--:
auto
register
static
extern
auto register
, ($$R.6.3),
($$R.8.3). auto
, , auto ,
- - ($$R.6.2).
register auto,
,
. ,
,
.
,
extern ($$R.3.1).
($$R.8.4).
static extern
.
static
static extern.
$$R.9.4.
extern .
static .
, const, ,
.
extern ,
.
--
,
const. ,
, inline static
($$R.3.3). ,
, . ,
static char* f(); // f()
char* f() // f()
{ /* ... */ }
char* g(); // g()
static char* g() // :
{ /* ... */ }
static int a; // `a'
int a; // :
static int b; // `b'
extern int b; // `b'
int c; // `c'
static int c; // :
extern int d; // `d'
static int d; // :
extern. , ,
, ,
struct S;
extern S a;
extern S f();
extern void g(S);
void h()
{
g(a); // : S
f(); // : S
}
.
-fct:
inline
virtual
inline ,
. . ,
, inline
($$R.3.3). ($$R.5.2.2,
$$R.8.2.5), ,
inline.
- inline
, .
-
inline , .
inline , ,
inline
.
class X {
public:
int f();
inline int g(); // X::g()
int h();
};
void k(X* p)
{
int i = p->f(); // X::f()
int j = p->g();
// ...
}
inline int X::f() // :
// inline
{
// ...
}
inline int X::g()
{
// ...
}
inline int X::h() // X::h()
{
// ...
}
virtual
- (. $$R.10.2).
typedef ,
. typedef -
($$R.8.3).
-typedef:
($$R.3.2) typedef
, ,
,
, $$R.8. ,
-typedef .
($$R.9.1) -typedef . ,
typedef int MILES, *KLICKSP;
MILES distance;
extern KLICKSP metricp;
, distance int, metricp
" int".
typedef ,
, ,
, , ,
typedef struct s { /* ... */ } s;
typedef int I;
typedef int I;
typedef I I;
, typedef,
, typedef, ,
typedef struct { /* .... */ } S; // S
typedef ,
, ,
, ,
class complex { /* ... */ };
typedef int complex; // :
, ,
, ,
, ,
typedef int complex;
class complex { /* ... */ }; // :
-typedef, , -
($$R.9.1). :
class, struct union,
, ,
struct S {
S();
~S();
};
typedef struct S T;
S a = T(); //
struct T* p; //
(. $$R.14).
friend
(. $$R.11.4).
:
-:
--
-
-
--
:: -
const
volatile
const volatile
-.
-.
const ,
. const,
extern,
($$R.8.4, $$R.12.1).
const, -,
- ($$R.5.19).
const ,
, ,
const const ($$R.9.3.1).
, const,
, .
, ,
const.
volatile.
, ,
,
. volatile
,
, volatile
volatile ($$R.9.3.1).
- ,
int.
--:
--
--
char
short
int
long
signed
unsigned
float
double
void
int long
short. , ,
int. long
double. char, short, int long
signed unsigned.
, , int.
signed , char
,
.
- -
$$R.9 $$R.7.2 .
--:
-- -
--
--:
class
struct
union
, --
- (. $$R.9.1).
,
union, .
, class,
class struct.
, struct,
class
struct. ($$R.9.7)
:
--:
-typedef
- :: --
--:
--
:: --
--:
-
- :: --
, - ,
. , ,
,
(. $$R.3.2).
($$R.3.6.1)
-.
-, .. .
-:
-:
enum opt { - }
-:
-
- , -
-:
= -
-
, .
=,
.
=,
,
, .
int ,
int
($$R.4.1).
.
. ,
,
( ). ,
enum { a, b, c=0 };
enum { d, e, f=e+2 };
a, c, d 0, b e 1, f 3.
,
.
.
($$R.4.1). ,
:
enum color { red, yellow, green=20, blue };
color col = red;
color* cp = &col;
if (*cp == blue ) // ...
color , ,
col , cp
. color
red, yellow, green, blue.
0, 1, 20 21. -
, color
color, ,
color c = 1; // :
// int color
int i = yellow; // : yellow int 1
//
$$R.18.3.
, ($$R.9),
,
-
($$R.5.1).
($$R.9.7), ,
class X {
public:
enum direction { left='l', right='r' };
int f(int i)
{ return i==left ? 0 : i==right ? 1 : 2; }
};
void g(X* p)
{
direction d; // : `direction'
int i; //
i = p->f(left); // : `left'
i = p->f(X::right); //
// ...
}
asm :
-asm:
asm ( -) ;
asm .
.
- ($$R.3.3)
++ :
-:
extern - { - opt }
extern -
-:
-
-.
.
("")
++ ("++"). "++",
,
complex sqrt(complex); // C++
extern "C" {
double sqrt(double); // C
}
.
. -
($$R.3.2). -
, , ,
. -,
, , .
, ,
.
-,
, .. -.
-
.
, ,
, .
($$R.13)
, . $$R.7.4.
, :
extern "C" {
// ...
_iobuf_iob[_NFILE];
// ...
int _flsbuf(unsigned,_iobuf*);
// ...
}
,
{ }.
. , , ,
, extern, ,
($$R.7.1.1):
extern "C" double f();
static double f(); //
,
extern "C" { /* ... */ }
, .
++ ,
, ,
. ,
.
- -
, ,
,
, , Ada ( ADA) Fortran ( FORTRAN).
-, , -
,
.
-:
--
- , --
--:
opt
: (-;
. $$R.7.1) (-).
,
. , ,
, , * ( )
() ( ).
, $$R.8.4 $$R.12.6.
:
:
--
-ptr
(--) --cv opt
[ - opt]
( )
-ptr:
* --cv opt
& --cv opt
-- :: * --cv opt
--cv:
const
volatile
--:
-
~-
-typedef
--
-
, ::
($$R.12.1, $$R.12.4).
sizeof
new. -,
,
.
-:
-- - opt
--:
- --
-:
-ptr - opt
- opt ( -- ) - cv opt
- opt [ - opt ]
( - )
, -
, ,
. ,
. ,
int // int i
int * // int *pi
int *[3] // int *p[3]
int (*)[3] // int (*p3i)[3]
int *() // int *f()
int (*)(double) // int (*pf)(double)
: "", " ",
" 3 ", " 3 ",
" , ",
" double, ".
, $$R.6.8, -
, , ,
.
,
, ,
,
. ,
,
, .
,
, =
, ,
struct S {
S(int);
};
void foo(double a)
{
S x(int(a)); //
S y((int)a); //
S z = int(a); //
}
( )
- ($$R.7.1).
--, .
($$R.12.3,
$$R.13.4), -- .
auto, static, extern, register, friend, inline, virtual
typedef --
. --
- ($$R.7.1), .
,
T D
T , D - . D
, T.
, D
( D1 )
D1 , D.
--,
.
T D, D
* --cv opt D1
"... --cv T".
--cv ,
.
,
const ci = 10, *pc = &ci, *const cpc = pc;
int i *p, *const cp = &i;
: ci ; pc
; cpc ; i ;
p ; cp .
ci, cpc cp .
pc , ,
cp. :
i = ci;
*cp = ci;
pc++;
pc = cpc;
pc = p;
:
ci = 1; //
ci++; //
*pc = 2; //
cp = &ci; //
cpc++; //
p = pc; //
,
, const, ,
,
const.
volatile.
$$R.5.17 $$R.8.4.
($$R.8.2.2)
($$R.9.6).
T D, D
& --cv opt D1
"...--cv T". void& .
,
void f(double& a) { a += 3.14; }
// ...
double d = 0;
f(d);
a , ,
f(d) d 3.14.
int v[20];
// ...
int& g(int i) { return v[i]; }
// ...
g(3) = 7;
: g() ;
g() = 7; 7 v.
:
struct link {
link* next;
};
link* first;
void h(link*& p) // `p'
{
p->next = first;
first = p;
p = 0;
}
void k()
{
link* q = new link;
h(q);
}
p link, h(q)
q, 0, . $$R.8.4.3.
, ($$R.9.6),
.
($$R.8.4.3), ,
extern ($$R.7.1.1),
($$R.9.2) ,
($$R.8.2.5),
. $$R.3.1.
T D, D
-- :: * --cv opt D1
"... --cv -- T".
,
class X {
public:
void f(int);
int a;
};
int X::* pmi = &X::a;
void (X::* pmf)(int) = &X::f;
pmi pmf X T
X void(int) .
:
X obj;
// ...
obj.*pmi = 7; // 7 obj int
(obj.*pmf)(7); // - obj
// 7
,
($$R.9.4), . $$R.5.5 $$R.5.3.
T D, D
D1 [ - opt ]
" ... T".
- ($$R.5.19),
, 0.
. - N,
N 0 N-1.
: (
void), , , ,
.
" ...",
, -,
, .
,
, ,
, . -
,
- ($$R.8.4).
, ($$R.8.4.1).
float fa[17], *afp[17];
float float,
static int x3d[3][5][7];
3x5x7.
, x3d ,
,
.
: x3d, x3d[i], x3d[i][j], x3d[i][j][k].
, ,
sizeof &
($$R.8.4.3),
. ,
.
($$R.13.4.5),
, E1[E2] *((E1) + (E2)).
+, E1 , E2
, E1[E2] E2- E1. ,
, - .
.
E - n- ixjx...xk,
(n-1)- jx...xk.
*, (n-1)-
.
,
int x[3][5];
3x5 . x,
.
x[i], *(x+i),
x , , x+i
x, i ,
x, .. .
, (
),
. , ,
.
, ++
( ),
,
,
.
T D, D
D1 (-- ) --cv opt
"...--cv
-- T".
--:
-- opt ... opt
-- , ...
--:
-
-- , -
-:
-
- =
- - opt
- - opt =
-- (...),
,
, ,
. void
. , void
( , void, void*, ).
-:
- opt -ctor -
-:
-
-
D1 ( -- ) --cv opt
$$R.8.2.5
-.
.
int max( int a, int b, int c)
{
int m = (a > b) ? a : b;
return (m > c) ? m : c;
}
int -, max(int a, int b, int c)
- , { /* ... */ } - -.
-ctor ,
. $$R.9.3.1 $$R.12.6.
--cv :
-,
- -, . $$R.9.3.1.
.
,
, ,
void print(int a, int)
{
printf("a = %d\n",a);
}
.
:
= -
= { - , opt }
( - )
-:
-
- , -
{ - , opt }
, ,
,
.
int f(int);
int a = 2;
int b = f(a);
int c(b);
const T*, .. T,
T*,
. T
T const
volatile ,
,
int a;
const int b = a;
int c = b;
const int* p0 = &a;
const int* p1 = &b;
int* p2 = &b; // : const
// const
int *const p3 = p2;
int *const p4 = p1; // : const
// const
const int* p5 = p1;
: ,
-, const.
, . $$R.8.2.6.
$$R.12.6.1. $$R.12.8.
$$R.3.4
$$R.6.7.
, ($$R.3.5),
,
0, .
.
, , .
, ( ).
,
, .
, () ,
X a();
a X,
, X.
, ,
int a;
struct X {
static int a;
static int b;
};
int X::a = 1;
int X::b = a; // X::b = X::a
($$R.9),
($$R.12.1), ($$R.11),
($$R.10) ($$R.10.2).
,
-,
, ,
.
. ,
.
, ,
.
,
struct S { int a; char* b; int c; }
S ss = { 1, "asdf" };
ss.a 1, ss.b - "asdf", ss.c - 0.
, , ,
,
($$R.12.8).
.
- ,
, ,
, ,
, . , -
,
,
;
,
.
,
int x[] = { 1, 3, 5 };
x ,
, .
.
float y[4][3] = {
{ 1, 3, 5 },
{ 2, 4, 6 },
{ 3, 5, 7},
};
1, 3, 5 y[0],
.. y[0][0], y[0][1] y[0][2]. ,
y[1] y[2]. ,
y[3] .
:
float y[4][3] = {
1, 3, 5, 2, 4, 6, 3, 5, 7,
};
( ) .
y
, y[0] ,
,
y[1] y[2].
float y[4][3] = {
{ 1 }, { 2 }, { 3 }, { 4 }
};
y (
), 0.
$$R.12.6.1.
,
, , ,
union u { int a; char* b; };
u a = { 1 };
u b = a;
u c = 1; //
u d = { 0, "asdf" }; //
u e = { "asdf" }; //
, . ,
:
char cv[4] = { 'a', 's', 'd', 'f', 0 }; //
(, )
-:
.
, :
char msg[] = "Syntax error on line %s\n";
, '\n' ,
'\0', sizeof(msg) 25.
, ,
:
('\0'):
char cv[4] = "asdf"; //
, T&, .. " T" ($$R.8.2.2),
T ,
T, ,
void f()
{
int i;
int& r = i; // `r' `i'
r = 1; // `i' 1
int* p = &r; // `p' `i'
int& rr = r; // `rr' , `r',
// .. `i'
};
,
. ,
, .
($$R.5.2.2) ($$R.6.6.3)
.
($$R.8.2.5), ,
($$R.9.2) ,
extern, ,
int& r1; // :
extern int& r2; //
T T
, T ($$R.10), T
($$R.4.6), ,
. , ,
const,
T , .
, ,
double d = 1.0;
double& rd = d; // rd `d'
const double& rcd = d; // rcd `d'
double& rd2 = 1; // :
const double& rcd2 = 1;// rcd2
// `1'
volatile T
volatile T T, const T. const T
const T, T -,
T, volatile T. T ( const volatile)
T.
,
, ,
($$R.3.5). , B
D ,
D (
, "D B"), . $$R.4.7.
. - ($$R.9.1), ..
.
-:
- -
-- ($$R.7.1.6).
( ) .
-:
- { - opt }
-:
-- opt - opt
-- - - opt
--:
class
struct
union
-
- . -
. ,
-, , -
.
.
,
,
( ,
, . $$R.12.8). , ,
, , . $$R.13.4.
, --
struct; ($$R.10)
($$R.11). ,
-- union;
,
($$R.9.5).
. ,
:
struct X { int a; };
struct Y { int a; };
X a1;
Y a2;
int a3;
,
:
a1 = a2; // : Y X
a1 = a3; // : int X
($$R.13) f(),
:
int f(X);
int f(Y);
,
, S:
struct S { int a; };
struct S { int a; }; // ,
,
, , ,
($$R.3.2).
,
, ,
-- ($$R.7.1.6), :
struct stat {
// ...
};
stat gstt; // `stat'
//
int stat(struct stat*); // `stat'
void f()
{
struct stat* ps; // struct
// stat
// ...
stat(ps); // stat()
// ...
}
--
--,
, ,
, :
struct s { int a; };
void g()
{
struct s; // `s'
s* p; // `s'
struct s { char* p; }; // `s'
}
, ,
class vector;
class matrix {
// ...
friend vector operator*(matrix&, vector&);
};
class vector {
// ...
friend vector operator*(matrix&, vector&);
};
friend ( ) $$R.11.4,
operator $$R.13.4. , ,
,
, ,
friend ($$R.11.4).
-- ($$R.7.1.6).
, ,
, ,
, :
struct s { int a; }
void g()
{
struct* s p = new s; // `s'
p->a = 1;
}
. ,
class A * A;
A , ,
,
- class A.
"" , .
-typedef ($$R.7.1.3)
-, . $$R.7.1.3.
-:
- - opt
- : - opt
-:
- opt -- opt ;
- ; opt
- ;
--:
-
-- , -
-:
- opt
opt : -
-:
= 0
- , ,
, ($$R.7.2), ,
($$R.11.4) ($$R.7.1.3, $$R.9.1). ,
- ,
, . $$R.11.3.
-. -
, .. -
.
, -
, ($$R.13).
, - ($$R.8.4).
, . $$R.12.1.
auto, extern register.
-
. --
-,
- -,
friend --.
-
($$R.10.2).
,
. , C1
C1, C1.
,
.
:
struct tnode {
char tword[20];
int count;
tnode *left;
tnode *right;
};
,
.
:
tnode s, *sp;
s tnode sp tnode.
s->count count ,
sp; s.left left
s; s.right->tword[0]
tword s, right.
,
-,
, .
,
-, ($$R.11.1).
,
.
($$R.10.2) ($$R.10.1);
. $$R.5.4.
- ($$R.9.3), ,
($$R.12.1). ,
,
.
, ( friend $$R.11.4),
-
($$R.5.2.4), :
struct tnode {
char tword[20];
int count;
tnode *left;
tnode *right;
void set(char*, tnode* l, tnode *r);
};
set - :
void f(tnode n1, tnode n2)
{
n1.set("abc",&n2,0);
n2.set("def",0,0);
}
, -
. , - (
, $$R.9.4)
. -
,
. -
,
::, :
void tnode::set(char* w, tnode* l, tnode* r)
{
count = strlen(w)+1;
if (sizeof(tword)<=count)
error("tnode string too long");
strcpy(tword,w);
left = 1;
right = r;
}
tnode::set , set
tnode. tword,
count, left right ,
n1.set("abc",&n2,0) tword
n1.tword, n2.set("def",0,0) tword
n2.tword. strlen, error strcpy -
.
($$R.3.1) ;
, ,
, . $$R.3.3.
- .
-
.
- ($$R.9.4) X,
X, .
($$R.9.3) - this
, . -
X this X *const, -
const volatile; this
const X *const volatile X *const .
const volatile, this
const volatile X *const, . $$R.18.3.3. :
struct s {
int a;
int f() const;
int g() { return a++; }
int h() const { return a++; } //
};
int s::f() const { return a; }
a++ s::h ,
( ),
s::h(). -,
const, .. this const,
, *this const.
- const (.. -,
const) const,
const, -
const const,
:
void k(s& x, const s& y)
{
x.f();
x.g();
y.f();
y.g(); //
}
y.g() , .. y const, s::g() -
- const,
( ) , .
, - volatile (.. -,
volatile)
volatile. -
const volatile.
const volatile
($$R.12.1) ($$R.12.4). ($$R.12.1)
($$R.12.4) const
volatile.
- ($$R.8.3) ,
(inline, $$R.7.1.2).
- ,
inline
. ,
.
int b;
struct x {
char* f() { return b; }
char* b;
};
int b;
struct x {
char* f();
char* b;
};
inline char* x::f() { return b; } //
x::f() x::b, b.
-
, .
R.9.8, $$R.9.7.
, ,
static. ,
, ,
.
.
($$R.3.3). ,
, .
, . . $$R.18.3.
- this,
. ->. - .
-
.
($$R.9.8)
.
, ,
.
mem c1 c1::mem
($$R.5.1), .. .
. ->.
,
, . -> .
mem ,
c1. run_chain, idle ,
process:
class process {
static int no_of_process;
static process* run_chain;
static process* running;
static process* idle;
// ...
public:
// ...
int state();
static void reshedule();
// ...
};
reshedule
process :
void f()
{
process::reshedule();
}
, - , :
void process::reshedule() { /* ... */ };
int process::no_of_process = 1;
process* process::running = get_main();
process* process::run_chain = process::running;
($$R.11), ,
.
,
process::no_of_process int, &process::reshedule() -
void(*)().
,
, ,
.
.
- ( ),
($$R.10.2).
.
,
($$R.13.4.3).
, .
union { - }
,
( ).
,
;
, ($$R.5.2.4).
:
void f()
{
union { int a; char* p; };
a = 1;
// ...
p = "Jennifer";
// ...
}
a p ( ),
, .
static.
($$R.11), -.
,
, ,
union { int aa; char* p; } obj, *ptr=&obj;
aa = 1; //
ptr->aa = 1; //
aa , ..
.
, ,
$$R.8.4.1.
-, ,
opt : -
,
.
.
.
, - .
.
, - .
, . ,
.
,
.
.
($$R.3.6.1).
,
int (.. signed unsigned)
. &
, ,
.
.
.
.
. ,
,
,
.
int x;
int y;
class enclose {
public:
int x;
static int s;
class inner {
void f(int i)
{
x = i; // : enclose::x
s = i; // : enclose ::s
::x = i; // : x
y = i; // : y
}
void g(enclose* p, int i)
{
p->x = i; // : enclose ::x
}
};
};
inner* p = 0; // : `inner'
-
, ($$R.11).
, -
, :
class E {
int x;
class I {
int y;
void f(E* p, int i)
{
p->x = i; // : E::x
}
};
int g(I* p)
{
return p->y; // : I::y
}
};
- ,
, :
class enclose {
class inner {
static int x;
void f(int i);
};
};
typedef enclose::inner ei;
int ei::x = 1;
void enclose::inner::f(int i) { /* ... */ }
- ,
, .
, - (
$$R.10.4),
($$R.11).
,
.
,
.
,
, ,
. :
int x;
void f()
{
static int s;
int x;
extern int g();
struct local {
int h() { return x; } // : `x'
int j() { return s; } //
int k() { return ::x; } //
int l() { return g(); } //
}
}
, ($$R.11).
-
. ,
.
,
. , ,
, , :
class X {
public:
typedef int I;
class Y { /* ... */ }
I a;
};
I b; //
Y c; //
X::Y d; //
, ,
.
, - -typedef
. , - -typedef
- -typedef,
.
:
typedef int c;
enum { i = 1 };
class X {
char v[i];
int f() { return sizeof(c); }
char c; // : typedef
//
enum { i = 2 }; // : `i'
// `char[i]'
};
typedef char* T;
struct Y {
T a;
typedef long T; // : T
T b;
};
:
-:
: -
-:
-
- , -
-:
--
virtual - opt --
- virtual opt --
-:
private
protected
public
- -
($$R.9),
. ,
.
- $$R.11. ,
,
, . ,
.
:: ($$R.5.1)
. ,
.
, . $$R.11.2.
($$R.4.6).
($$R.4.7).
:
class base {
public:
int a, b;
};
class derived : public base {
public:
int b, c;
};
void f()
{
derived d;
d.a = 1;
d.base::b = 2;
d.b = 3;
d.c = 4;
base* bp = &d; // derived* base*
}
d, bp
d.
, -,
, ,
-.
, - :: ,
.
, .
:
class A { public: void f(); }
class B : public A { };
class C : public B { public: void f(); }
void C::f()
{
f(); // f() C
A::f(); // f() A
B::f(); // f() A
}
A::f(), f()
B.
, ,
, . $$R.12.6.2.
. :
class A { /* ... */ };
class B { /* ... */ };
class C { /* ... */ };
class D : public A, public B, public C { /* ... */ };
,
.
, ,
($$R.12.1), ($$R.12.4)
($$r.5.4, $$R.9.2, $$R.11.1).
.
,
.
class B { /* ... */ };
class D : public B, public B { /* ... */ }; //
class L { /* ... */ };
class A : public L { /* ... */ };
class B : public L { /* ... */ };
class C : public A, public B { /* ... */ }; //
C L.
virtual. V
, V
. :
class V { /* ... */ };
class A : virtual public V { /* ... */ };
class B : virtual public V { /* ... */ };
class C : public A, public B { /* ... */ };
C
V.
, :
class B { /* ... */ };
class X : virtual public B { /* ... */ };
class Y : virtual public B { /* ... */ };
class Z : public B { /* ... */ };
class AA : public X, public Y, public Z { /* ... */ };
AA B:
Z , X Y.
.
, ,
, , ,
.
($$R.11). :
class A {
public:
int a;
int (*b)();
int f();
int f(int);
int g();
};
class B {
int a;
int b();
public:
int f();
int g();
int h();
int h(int);
};
class C : public A, public B { };
void g(C* pc)
{
pc->a = 1; // : : A::a B::a
pc->b(); // : : A::b B::b
pc->f(); // : : A::f B::f
pc->f(1); // : : A::f B::f
pc->g(); // : : A::g B::g
pc->g = 1; // : : A::g B::g
pc->h(); //
pc->h(1); //
}
,
.
,
, , :
class A {
public:
int f();
};
class B {
public:
int f();
};
class C : public A, public B {
int f() { return A::f() + B::f(); }
};
, ,
,
, ,
. .
,
. :
class V { public: int v; };
class A { public: int a; };
class B : public A, public virtual V { };
class C : public A, public virtual V { };
class D : public B, public C { public: void f(); };
void D::f()
{
v++; //
a++; // , : `a' `D'
}
,
, ,
, . ,
, , ,
.
, ..
.
, B::f A::f,
A B .
, :
. :
class V { public: int f(); int x; };
class B : public virtual V { public: int f(); int x; };
class C : public virtual V { };
class D : public B, public C { void g(); };
void D::g()
{
x++; // : B::x V::x
f(); // : B::f() V::f()
}
,
, . :
class V { };
class A { };
class B : public A, public virtual V { };
class C : public A, public virtual V { };
class D : public B, public C { };
void g()
{
D d;
B* pb = &d;
A* pa = &d; // , : A C A B?
v* pv = &d; // : V
}
base ($$R.7.1.2) vf,
derived vf
, vf derived
derived::vf,
base. ,
. ,
($$R.8.2.5) ,
(. $$R.13.1). ,
.
:
struct base {
virtual void vf1();
virtual void vf2();
virtual void vf3();
void f();
};
class derived : public base {
public:
void vf1();
void vf2(int); // base::vf2()
char vf3(); // :
//
}
void g()
{
derived d;
base* bp = &d; // : derived* base*
bp->vf1(); // derived::vf1
bp->vf2(); // base::vf2
bp->f(); // base::f
}
d derived
derived::vf1, base::vf2 base::f . ,
,
,
-
. , bp->vf1()
derived::vf1(), bp
derived, derived::vf1()
base::vf1().
virtual , ,
( )
($$R.7.1.2).
, ..
, ,
.
. , ,
. virtual
, .
($$R.10.3). , ,
:
, .
,
($$R.5.1), :
class B { public: virtual void f(); };
class D : public B { public: void f(); };
void D::f() { /* ... */ B::f(); }
f D B::f, D::f.
, , , ,
, , .
,
.
,
, ..
,
.
,
.
- ($$R.9.2).
,
- ($$R.5.1). :
class point { /* ... */ };
class shape { //
point center;
// ...
public:
point where() { return center; }
void move(point p) { center=p; draw(); }
virtual void rotate(int) = 0; //
virtual void draw() = 0; //
// ...
};
,
,
.
, :
shape x; // :
shape* p; //
shape f(); //
void g(shape); //
shape& h(shape&); //
, :
class ab_circle : public shape {
int radius;
public:
void rotate(int) { }
// ab_circle::draw()
};
shape::draw() ,
ab_circle::draw().
circle ,
circle::draw() - .
class circle : public shape {
int radius:
public:
void rotate(int) { }
void draw(); // -
};
- ,
, , .
++. (
-typedef ($$R.7.1.3) - ($$R.9.1))
, .
,
$$R.3.3.
$$R.3.2.
(
) ($$R.10.1.1).
($$R.11) ,
. ,
, ,
.
, ,
::
( :: ->
.), , ,
, .
, X:: obj., obj X
X, , ptr->, ptr
X, X
X . , ptr-> ptr
Y, operator->(),
, ptr->operator()
X ($$R.13.4.6).
, , ,
, ,
, ,
.
,
. ,
($$R.13.4).
, , ,
,
X, , ,
, X,
X ,
.
,
.
.
, , ,
- X,
, ,
, X,
X , .
,
($$R.8.3), ,
( , ).
, ($$R.8.2.5),
, ,
.
,
($$R.3.2) ;
,
($$R.8.2.6).
-ctor ($$R.12.6.2)
, . ,
.
:
(private); ,
- , ;
(protected); ,
- , ,
- ,
(. $$R.11.5);
(public); ,
.
, class,
. ,
struct union, , :
class X {
int ; // X::
};
struct S {
int a; // S::a
};
($$R.10):
- : - opt
- ,
-, ,
class X {
int a; // X::a : 'class'
public:
int b; // X::b
int c; // X::c
};
, ,
struct S {
int a; // S::a : `struct'
protected:
int b; // S::b
private:
int c; // S::c
public:
int d; // S:: d
};
, ,
-, ($$R.9.2).
($$r.10)
public,
public protected
.
private, public
protected
private .
,
friend.
-,
, struct,
public,
class, - private, :
class B { /* ... */ };
class D1 : private B { /* ... */ };
class D2 : public B { /* ... */ };
class D3 : B { /* ... */ }; // `B'
struct D4 : public B { /* ... */ };
struct D5 : private B { /* ... */ };
struct D6 : B { /* ... */ }; // `B'
(public) D2, D4 D6
(private) D1, D2 D5.
private
. ,
,
,
.
- X X*
,
X.
,
public protected .
.
:
class B {
int a;
public:
int b, c;
int bf();
};
class D : private B {
int d;
public:
B::c; // adjust access to `B::c'
int e;
int df();
};
int ef(D&);
ef c, e, df.
df D,
b, c, bf, d, e df, a. bf - B
a, b, c bf.
, ,
,
, :
class B {
public:
int a;
private:
int b;
protected:
int c;
};
class D : private B {
public:
B::a; // `a' D
B::b; // : ,
// `b' D
protected:
B::c; // `c' D
B::a; // : ,
// `a' D
};
, :
class X {
public:
f();
f(int);
};
class Y : private X {
public:
X::f; // makes X::f() and X::f(int) public in Y
};
, ,
:
class X {
public:
void f();
};
class Y : private X {
public:
void f(int);
X::f; // : f
};
, ,
. ,
($$R.5.2.4),
.
:
class X {
int a;
friend void friend_set(X*, int);
public:
void member_set(int);
};
void friend_set(X* p, int i) { p->a = i; }
void X::member_set(int i) { a = i; }
void f()
{
X obj;
friend_set(&obj,10);
obj.member_set(10);
}
friend
, ,
, . - X
Y, :
class Y {
friend char* X::foo(int);
// ...
};
X Y
-- ($$R.9.1):
class Y {
friend class X;
// ...
};
, ,
, , , :
class X {
enum { a=100 };
friend class Y;
};
class Y {
int v[X::a]; // Y X
};
class Z {
int v[X::a]; // : X::a
};
, , ,
, ,
friend ($$R.9.1).
, friend,
, extern ($$R.3.3, $$r.7.1.1).
- ,
inline
- ($$R.9.3.2).
-, ,
.
-, , .
friend -
($$R.9.2).
, .
:
class A {
friend class B;
int a;
};
class B {
friend class C;
};
class C {
void f(A* p);
{
p->a++; // : C A,
// A
}
};
class D : public B {
void f(A* p)
{
p->a++; // : D A,
// A
}
};
-
. -
,
( ,
). :
class B {
protected:
int i;
};
class D1 : public B {
};
class D2 : public B {
friend void fr(B*, D1*, D2*);
void mem(B*, D1*);
};
void fr(B* pb, D1* p1, D2* p2)
{
pb->i = 1; //
p1->i = 2; //
p2->i = 3; // ( D2)
}
void D2::mem(B* pb, D1* p1)
{
pb->i = 1; //
p1->i = 2; //
i = 3; // ( this)
}
void g(B* pb, D1* p1, D2* p2)
{
pb->i = 1; //
p1->i = 2; //
p2->i = 3; //
}
($$r.11)
,
. :
class B {
public:
virtual f();
};
class D : public B {
private:
f();
};
void f()
{
D d;
B* pb = &d;
D* pd = &d;
pb->f(); // : B::f()
// D::f()
pd->f(); // : D::f()
}
, ,
, - (
B*). - ,
(D ), .
,
,
, .
:
class W { public: void f(); };
class A : private virtual W { };
class B : public virtual W { };
class C : public A, public B {
void f() { W::f(); } //
};
W::f() C::f() ,
B, .
- ,
, , ,
.
.
- ($$R.11).
, protected
,
.
-,
, ,
. ,
, .
$$R.12.6.
const
volatile.
const volatile ($$R.9.3.1).
virtual static.
, ,
($$R.12.8). .
X
X, .
X ,
X .
X ,
X, ..
X. , X::X(const X&)
X::X(X&, int=0) .
,
.
X
X, X::X(X) .
($$R.8.2.4).
,
,
, . $$R.12.6.2
.
.
, void. return
.
.
:
- ( - opt )
:
complex zz = complex(1,2.3);
print( complex(7.8,1.2) );
, (
zz ), ,
, . $$R.12.2.
-, . $$R.12.7.
.
.
,
. ,
,
. :
class X {
// ...
public:
// ...
X(int);
X(X&);
~X();
};
X f(X);
void g()
{
X a(1);
X b = f(X(2));
a = f(b);
}
X(2),
f() X(X&). , -
X(2) ,
f(). ,
f(X(2)) ,
b X(X&),
: f(X(2)) b.
, f(),
a=f(a) a,
f(a),
, a.
.
.
:
( ) ,
. ,
.
, , .
,
.
$$R.8.4.3.
.
, ,
($$R.4). , X
X, T,
T X.
, :
($$R.8.4),
($$R.5.2.2), ($$R.6.6.3, $$R.8.2.5),
($$R.5), ,
($$R.6.4,$$R.6.5)
($$R.5.2.3, $$R.5.4).
($$R.10.1.1, $$R.12.3.2).
($$R.11).
($$R.10.4).
, , $$R.13.2.
, ,
, :
class X {
// ...
public:
X(int);
X(const char*, int = 0);
};
void f(X arg) {
X a = 1; // a = X(1);
X b = "Jessie"; // b = X("Jessie",0)
a = 2; // a = X(2)
f(3); // f(X(3))
}
X , ,
-
, X, :
class X { /* ... */ X(int); };
class Y { /* ... */ Y(X); };
Y a = 1; // : Y(X(1))
//
- X, ,
--:
operator --
--:
-- opt -ptr opt
X ,
--. -
. --
, -typedef,
.
:
class X {
// ...
public:
operator int();
};
void f(X a)
{
int i = int(a);
i = (int)a;
i = a;
}
X::operator int().
, :
void g(X a, X b)
{
int i = (a) ? 1+a : 0;
int j = (a&&b) ? a+b : i;
if (a) { // ...
}
}
.
.
(
), :
class X {
// ...
public:
operator int();
};
class Y {
// ...
public:
operator X();
};
Y a;
int b = a; // :
// a.operator X().operator int()
int c = X(a); // : a.operator X().operator int()
.
,
, :
class X {
public:
// ...
operator int();
};
class Y : public X {
public:
// ...
operator void*();
};
void f(Y& a)
{
if (a) { // :
}
}
- cl ~cl,
cl
, .
( void). .
const
volatile,
($$R.9.3.1). .
.
, - ,
,
.
public.
,
. ,
, , .
,
.
,
.
,
-
. "-"
, .
,
.
.
-, . $$R.12.7.
.
:
(1) auto ($$R.3.5)
($$R.12.2, $$R.8.4.3);
(2) ($$R.3.4)
($$R.3.5);
(3) delete ($$R.5.3.4) ,
new ($$R.5.3.3);
(4) .
delete,
($$R.12.6.2)
, delete() ($$R.5.3.4),
:
class X {
// ...
public:
X(int);
~X();
};
void g(X*);
void f() //
{
X* p = new X(111); //
g(p);
delete p; //
}
.
,
new.
. :
void* operator new(size_t, void* p) { return p; }
void f(X* p);
static char buf[sizeof(X)];
void g() // ,
{
X* p = new(buf) X(222); // buf[]
f(p);
p->X::~X(); //
}
, ,
, ,
int* p;
// ...
p->int::~int();
, ,
. ,
, ,
.
new,
() operator new() ($$R.5.3.3).
operator new() ,
0.
X X::operator new() ,
static.
size_t, - ,
<stddef.h>,
void*, :
class X {
// ...
void* operator new(size_t);
void* operator new(size_t, Arena*);
};
operator new()
$$R.5.3.3.
X X::operator delete()
, static.
void*
size_t. -
void, :
class X {
// ...
void operator delete(void*);
};
class Y {
// ...
void operator delete(void*, size_t);
};
operator delete(),
.
operator delete() void*.
,
,
.
( ) ()
. , ,
, ( ,
, ) ,
.
operator new() operator delete() ($$R.5.3.3, $$R.5.3.4).
X::operator new() X::operator delete()
, .
operator delete(),
, ,
:
struct B {
virtual ~B();
void* operator new(size_t);
void operator delete(void*);
};
struct D : B {
~D();
void* operator new(size_t);
void operator delete(void*);
};
void f()
{
B* p = new D;
delete p;
}
D
D::operator new(), ,
D::operator delete().
, ,
($$R.8.4.1).
($$R.12.1).
, .
($$R.12.1)
, .
,
. ,
= .
.
, :
class complex {
// ...
public:
complex();
complex(double);
complex(double,double);
// ...
};
complex sqrt(complex,complex);
complex a(1); //
// complex(double)
complex b = a; // `a'
complex c = complex(1,2); // complex(1,2)
// complex(double,double)
// `c'
complex d = sqrt(b,c); // sqrt(complex,complex),
// `d'
complex e; //
complex f = 3; // complex(3),
// complex(double)
// `f'
=
.
,
,
T x = a;
, new ($$R.5.3.3)
,
T x(a);
($$R.12.1) .
, ,
, ($$R.12.1).
, . :
complex cc = { 1, 2 }; // :
//
complex v[6] = { 1,complex(1,2),complex(),2 };
v[0] v[3] complex::complex(double),
v[1] complex::complex(double,double), v[2],
v[4] v[5] complex::complex().
M X
:
(1) M ;
(2) M ;
(3) X -ctor
($$R.12.6.2) M.
2
. ,
.
, ,
, . $$R.3.4, $$R.6.7,
$$R.9.4.
, .
, ,
.
-ctor
-ctor:
: --
--:
-
- , --
-:
-- ( - opt )
.
, const,
:
struct B1 { B1(int); /* ... */ };
struct B2 { B2(int); /* ... */ };
struct D : B1, B2 {
D(int);
B1 b;
const c;
};
D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4)
{ /* ... */ }
D d(10);
( -),
, D::D()
($$R.12.1). , ,
,
.
.
, ,
-
. "-" -
,
.
, ,
.
.
.
-
,
,
. -
, , .
:
class V {
public:
V();
V(int);
// ...
};
class A : public virtual V {
public:
A();
A(int);
// ...
};
class B : public virtual V {
public:
B();
B(int);
// ...
};
class C : public A, public B, private virtual V {
public:
C();
C(int);
// ...
};
A::A(int i) : V(i) { /* ... */ }
B::B(int i) { /* ... */ }
C::C(int i) { /* ... */ }
V v(1); // use V(int)
A a(2); // use V(int)
B b(3); // use V()
C c(4); // use V()
- ,
. ,
class X {
int a;
public:
const int& r;
X()::r(a) { }
};
X::r X X::a.
-.
, ( )
.
,
, .
,
.
:
class X {
public:
virtual void f();
X() { f(); } // X::f()
~X() { f(); } // X::f()
};
class Y : public X {
int& r;
public:
void f()
{
r++; // , `r'
}
Y(int& rr) ::r(rr) { }
};
,
($$R.10.3).
:
($$R.5.17), ($$R.12.1, $$R.8.4),
($$R.5.2.2)
($$R.6.6.3). X
($$R.12.1). ,
. ,
X
.
X
,
const, X
const X& :
X::X(const X&)
, X&:
X::X(X&)
const X
.
, X
, const,
X
const X& :
X& X::operator=(const X&)
, X&:
X& X::operator=(X&)
X const
.
, .
, ,
. ,
,
.
: X M,
M M .
const, , ,
, operator=() ,
.
, M
,
.
,
(..
). , X::operator=()
, ,
X X ,
X, X::operator=().
.
,
-
X ,
X& , .
X X::operator=(),
X,
. -
,
. :
class X {
// ...
public:
X(int);
X(const X&, int = 1);
};
X a(1); // X(int)
X b(a,0); // X(const X&,int)
X c = b; // X(const X&,int)
X
X::operator=(const X&). ($$R.12.3),
, :
class X {
public:
int b;
};
class Y : public X {
public:
int c;
};
void f()
{
X x1;
Y y1;
x1 = y1; //
y1 = x1; //
}
y1.b x1.b, x1.c .
. :
struct s {
virtual f();
// ...
};
struct ss : public s {
f();
// ...
};
void f()
{
s a;
ss b;
a = b; // a.s::operator=(b)
b = a; //
a.f(); // s::f
b.f(); // ss::f
(s&)b = a; // a b
// ((s&)b).s::operator=(a)
b.f(); // ss::f
}
a.f() s::f() (
s ($$R.10.2)), b.f() ss::f()
( ss).
, ,
.
, :
double abs(double);
int abs(int);
abs(1); // abs(int)
abs(1.0); // abs(double)
T T , T&
, ,
,
, , :
int f(int i)
{
// ...
}
int f(int& r) // :
{ //
// ...
}
, T T, const T
volatile T
, ,
, . ,
const T&, volatile T& T& ,
,
. ,
,
const T*, volatile T* T*.
,
.
-,
, ($$R.9.4).
typedef ,
($$R.7.1.3), ,
,
typedef, .
:
typedef int Int;
void f(int i) { /* ... */ }
void f(Int i) { /* ... */ } // : f
,
, :
enum E { a };
void f(int i) { /* ... */ }
void f(E i) { /* ... */ }
, ,
*, [], .
,
($$R.8.2.4).
:
f(char*);
f(char[]); // f(char*);
f(char[7]); // f(char*);
f(char[9]); // f(char*);
g(char(*)[10]);
g(char[5][10]); // g(char(*)[10]);
g(char[7][10]); // g(char(*)[10]);
g(char(*)[20]); // g(char(*)[10]);
,
($$R.13). -
, -
. :
class B {
public:
int f(int);
};
class D : public B {
public:
int f(char*);
};
D::f(char*) B::f(int),
.
void h(D* pd)
{
pd->f(1); // : D::f(char*) B::f(int)
pd->B::f(1); //
pd->f("Ben"); // , D::f
}
, , ,
.
int f(char*);
void g()
{
extern f(int);
f("asdf"); // : f(int) f(char*)
// f(char*)
}
-
, :
class buffer {
private:
char* p;
int size;
protected:
buffer(int s, char* store) { size = s; p = store; }
// ...
public:
buffer(int s) { p = new char[size = s]; }
};
, ,
, .
,
.
,
. ,
. , ,
, (
). ,
.
($$R.8.2.6), n,
n+1 .
-
, ,
, .
, ,
- ($$R.5.2.4),
operator ($$R.13.4).
,
.
X,
->, , const* X
const, volatile* X volatile
X* . -,
., ,
operator ($$R.9.4),
, : const X&
const, volatile X& volatile X&
. ->* .*
, -> . .
($$R.8.2.5)
.
,
. ,
, ,
,
.
.
, int->float->double
int double,
,
int->double.
,
T
:
T T&
T& T
T[] T*
T() T(*)()
T const T
T volatile T
T* const T*
T* volatile T*
,
, . ,
T, const T, volatile T,
T&, const T& volatile T&
.
const
volatile, [1] .
T&
, : , ,
T, volatile.
. ,
, ..
,
const ($$R.8.4.3).
:
[1] .
.
,
T* const T*, T* volatile T*, T& const T&
T& volatile T&.
[2] .
, [1],
,
($$R.4.1),
float double .
[3] .
, [2],
,
($$R.4.1, $$R.4.2, $$R.4.3, $$R.4.4,
$$R.4.5, $$R.4.6, $$R.4.7, $$R.4.8)
. A
B,
B* A* B*
void* const void*. , B
C,
C* B*, C* A*, C& B&,
C& A&.
($$R.4.8).
[4] .
, [3],
,
($$R.12.3), ($$R.4)
.
[5] .
, ,
.
,
,
.
class Y {
// ...
public:
operator int();
operator double();
};
void f(Y y)
{
int i = y; // Y::operator int()
double d;
d = y; // Y::operator double()
float f = y; // :
}
($$R.4) ,
, .
struct S { S(long); operator int(); };
void f(long), f(char*);
void g(S), g(char*);
void h(const S&), h(char*);
void k(S& a)
{
f(a); // f(long(a.operator int()))
g(1); // g(S(long(1)))
h(1); // h(S(long(1)))
}
,
,
, :
class x {
public:
x(int);
};
class y {
public:
y(long);
};
void f(x);
void f(y);
void g()
{
f(1); //
}
f(1) . ,
f(y(long(1))) ,
f(x(1)), .
($$R.12.1)
($$R.12.3.2) .
struct X {
operator int();
};
struct Y {
Y(X);
};
Y operator+(Y,Y);
void f(X a, X b)
{
a+b; // , :
// operator+(Y(a), Y(b))
// a.operator int() + b.operator int()
}
,
, .
:
($$R.8.4);
($$R.5.17);
($$R.5.2.2);
($$R.13.4);
, ($$R.8.2.5).
, f() g() ,
f(&g)
f(g) f() g().
:
int f(double);
int f(int);
int (*pfd)(double) = &f;
int (*pfi)(int) = &f;
int (*pfe)(...) = &f; // :
, - ,
, f() int(...).
,
($$R.4)
($$R.4.6). , B
D, :
D* f();
B* (*p1)() = &f; //
void g(D*);
void (*p2)(B*) = &g; //
.
--:
operator
:
new delete
+ - * / % ^ & | ~
! = < > += -= *= /= %=
^= &= |= << >> >>= <<= == !=
<= >= && || ++ -- , ->* ->
() []
- ($$R.5.2.2)
($$R.5.2.1).
( , )
:
+ - * &
:
. .* :: ?: sizeof
# ## ($$R.16).
, (-)
, ($$R.13.4.1, $$R.13.4.2).
, , :
complex z = a.operator+(b); // complex z = a+b
void* p = operator new(sizeof(int)*n);
new delete $$R.5.3.3 $$R.5.3.4
.
- -
.
, ,
: =,
& ,(), .
operator=(), - .
operator=() $$R.12.8.
(, ++a a+=1)
. ,
(,
+=). ,
.
($$R.8.2.6).
, $$R.13.4.3-$$R.13.4.7,
,
, $$R.13.4.1 $$R.13.4.2.
- ($$R.9.3),
, , . ,
@, @x
x.operator@() operator@(x).
- ,
,
($$R.13.2). , ++ -- ,
$$R.13.4.7.
- ($$R.9.3), ,
, , . ,
@ x@y
x.operator@(y) operator@(x,y).
- ,
, ($$R.13.2).
operator=()
-. ($$R.12.8). ,
X operator=,
operator=,
X.
X& X::operator=(const X& from)
{
// X
}
:
- ( - opt )
, -
, - ( ),
- . , , operator(),
x(arg1,arg2,arg3) x
x.operator()(arg1,arg2,arg3). operator()
- x.
, :
- [ ]
. x[y]
x x.operator[](y). operator[]
- x.
->:
- -> -
. x x->m
(x.operator->())->m. ,
operator->() ,
, ,
operator->(). - .
operator++
++.
operator++
++.
++ int, ,
,
operator++ , .
:
class X {
public:
X operator++(); // ++a
X operator++(int) // a++
};
void f(X a)
{
++a; // a.operator++();
a++; // a.operator++(0);
a.operator++(); // : ++a;
a.operator++(0); // : a++;
}
--
.
R.14
R.14.1
.
--:
template < --->
---:
--
--- , --
--:
-
-
-:
class
--
.
- -
.
. --
.
.
,
,
. vector :
template<class T> class vector {
T* v;
int sz;
public:
vector(int);
T& operator[](int);
T& elem(int i) { return v[i] }
// ...
};
template<class T> , ,
- T, ,
vector - T.
--:
--:
-- < --- >
---:
--
--- , --
-:
-
-- - ($$R.9).
, ,
,
- --, . $$R.14.5.
-- -- ,
.
,
, , , .
, ---
--, ,
--- -. ( ,
,
- .)
--- :
-, ,
, . ,
, ($$R.13.2).
vector:
vector<int> v1(20);
vector<complex> v2(30);
typedef vector<complex> cvec; // cvec
// vector<complex>
cvec v3(40); // v2 v3
v1[3] = 7;
v2[3] = v3.elem(4) = complex(7,8);
vector<int> vector<complex> ,
vector.
-- -,
, -, :
class vector<Shape*>
vector<Window>* current_window;
class svector : public vector<Shape*> { /* ... */ };
- $$R.14.6.
-- ,
. , x y ,
z:
template<class E, int size> class buffer;
buffer<char, 2*512> x;
buffer<char,1024> y;
buffer<char,512> z;
, x2 x3.
x1 x4:
template<class T, void(*err_fct)()>
class list { /* ... */ };
list<int,&error_handler1> x1;
list<int,&error_handler2> x2;
list<int,&error_handler2> x3;
list<char,&error_handler2> x4;
. ,
sort :
template<class T> void sort(vector<T>);
. , ,
. ,
, , . $$R.14.5.
,
. :
vector<complex> cv(100);
vector<int> ci(200);
void f(vector<complex>& cv, vector<int>& ci)
{
sort(cv); // sort(vector<complex>)
sort(ci); // sort(vector<int>)
}
,
.
:
[1] ($$R.13.2) ,
, .
[2] ,
. , .
[3]
($$R.13.2).
, .
, .
,
,
.
[2]
($$R.14.5),
, .
($$R.13.2).
($$R.13.3).
:
template<class T> T max(T a, T b) { return a>b?a:b; };
void f(int a, int b, char c, char d)
{
int m1 = max(a,b); // max(int a, int b)
char m2 = max(c,d); // max(char c, char b)
int m3 = max(a,c); // : max(int,char)
}
int max(int,int);
,
, char int,
max(a,c).
.
.
--,
---
.
template<class T> T* create(); //
template<class T>
void f() { //
T a;
// ...
}
--, ,
-.
. .
, .
-- .
.
:
.
, ,
, .
,
, .
() ,
,
.
:
template<class T> void sort(vector<T>& v) { /* ... */ }
void sort(vector<char*>& v) { /* ... */ }
sort
sort,
vector<char*>. vector
.
, , :
template<class T> class stream { /* ... */ };
class stream<char> { /* ... */ };
(stream<char>).
, .
, ,
,
.
,
, .
- ,
- .
, :
template<class T> class vector {
T* v;
int sz;
public:
vector(int);
T& operator[](int);
T& elem(int i) { return v[i]; }
// ...
};
, , :
template<class T> T& vector<T>::operator[](int i)
{
if (i<0 || sz>=i) error("vector: range error");
return v[i];
}
vector<T>::operator[]()
vector, .
vector<int> v1(20);
vector<complex> v2(30);
v1[3] = 7; // vector<int>::operator[]()
v2[3] = complex(7,8); // vector<complex>::operator[]()
- ,
:
template<class T> class task {
// ...
friend void next_time();
friend task<T>* preempt(task<T>*);
friend task* prmt(task*); //
// ...
};
next_time() task,
task preempt() c
. preempt()
.
template<class T>
task<T>* preempt(task<T>* t) { /* ... */ }
prmt() ,
task ,
task<int>, task<record>, ..
,
, .
:
template<class T> class X {
static T s;
// ...
};
X<int> aa;
X<char*> bb;
X<int> int,
X<char> char*.
, , f(int*)
s int, f(char**)
char**:
template<class T> f(T* p)
{
static T s;
// ...
}
void g(int a, char* b)
{
f(&a);
f(&b);
}
.
.
-, -
, -.
-:
try - -
-:
- opt
:
catch ( -- ) -
--:
--
-- -
--
...
-:
throw opt
- ($$R.6),
- - void ($$R.5).
- " ", ,
-, , "
. ,
.
.
, ,
. ,
throw "Help!";
char*:
try {
// ...
}
catch(const char* p) {
//
}
Overflow ():
class Overflow {
// ...
public:
Overflow(char,double,double);
};
void f(double x)
{
// ...
throw Overflow('+',x,3.45e107);
}
try {
// ...
f(1.2);
// ...
}
catch(Overflow& oo) {
// Overflow
}
. "" - ,
-
. ""
$$R.15.4.
-
, throw,
,
, .
(. $$R.15.4)
, throw
($$R.5.2.2) return.
,
($$R.12.1), ,
.
- ,
. -
,
.
, ,
, ,
:
try {
// ...
}
catch (...) { //
// ()
throw; //
}
,
, -.
,
.
,
,
.
,
- -, "
".
T, const T, T& const&
-, E, :
[1] T E ;
[2] T ($$R.4.6) E
;
[3] T , E ,
T
($$R.4.6).
:
class Matherr { /* ... */ virtual vf(); };
class Overflow : public Matherr { /* ... */ };
class Underflow : public Matherr { /* ... */ };
class Zerodivide : public Matherr { /* ... */ };
void f()
{
try {
g();
}
catch (Overflow oo) {
// ...
}
catch (Matherr mm) {
// ...
}
}
Overflow
Overflow, Matherr
Matherr , Matherr,
Underflow Zerodivide.
-
. ,
,
.
... -- ,
,
. ,
-.
-
,
-.
,
terminate() ($$R.15.7).
. " ".
. ,
,
. --
.
--:
throw ( - opt )
-:
-
- , -
:
void f() throw (X,Y)
{
// ...
}
,
unexpected(), . $$R.15.8.
,
,
- .
.
, --,
.
-- (throw())
.
X,
,
X.
--
.
:
terminate() unexpected().
, :
-
;
-
;
- ,
, ,
.
void terminate();
,
set_terminate():
typedef void(*PFV)();
PFV set_terminate(PFV);
, set_terminate(),
.
.
terminate() abort().
terminate() ,
,
, .
, --,
,
void unexpected();
,
set_unexpected():
typedef void(*PFV)();
PFV set_unexpected(PFV);
, set_unexpected(),
.
.
unexpected() terminate().
terminate() abort(),
.
catch
, ,
catch.
,
,
throw.
++
,
.
,
# (
). ,
.
,
( ++)
($$R.2).
, ,
,
. ,
, .
.
: ($$R.2.1),
, #include
,
.
.
,
, .
.
, ,
, .
.
()
($$R.16.2).
: ,
.
, .
. .
.
,
($$R.16.3, $$R.16.4, $$R.16.5, $$R.16.6, $$R.16.7 $$R.16.8).
($$R.2.5.2).
.
, ,
.
- ,
.
??= # ??( [
??/ \ ??) [
??' ^ ??! |
,
??=define arraycheck(a,b) a??(b??) ??!??! b??(a??)
#define arraycheck(a,b) a[b] || b[a]
#define -
. ,
, .
, , .
,
#define SIDE 8
char chessboard[side][side];
char chessboard[8][8];
#define, ,
.
, , .
( , ... ,) -
""
.
(.
, ,
, ,
. ,
, .
,
,
(, , ,
), .
, , .
, ,
,
.
, . , ,
,
.
.
.
( )
($$R.16.3.3);
, # ($$R.16.3.1),
## ($$R.16.3.2).
.
#define index_mask 0XFF00
#define extract(word,mask) word & mask
index = extract(packed_data,index_mask);
index = packed_data & 0XFF00;
($$R.16.3.3).
#, #
,
. ,
, \ " \.
,
#define path(logid,cmd) "/usr/" #logid "/bin/" #cmd
char* mytool=path(joe,readmail);
:
char* mytool="/usr/" "joe" "/bin/" "readmail";
($$R.16.1) :
char* mytool="/usr/joe/bin/readmail";
,
,
##, ##
. , ##
.
,
#define inherit(basenum) public Pubbase ## basenum, \
private Privbase ## basenum
class D : inherit(1) { };
:
class D : public Pubbase1, Privbase1 { };
,
##, , ,
. .
:
#define concat(a) a ## ball
#define base B
#define baseball sport
concat(base)
sport
Bball
,
,
.
,
.
, .
(
++)
#undef.
#undef :
#undef
""
.
, #undef
.
:
#include <>
.
.
, :
#include ""
. ()
, .
, ,
:
#include <>
, < >
>.
', \, ", /* //,
.
, "
", > .
' \ /* //,
.
#include -
, , ,
,
. ,
. .
#include ,
#include.
#include ,
#include
.
. :
:
-if -elif opt -else opt -endif
-if:
-if
-if:
# if -
# ifdef
# ifndef
-elif:
-elif
-elif -elif
-elif:
# elif -
-else:
-else
-else:
# else
-endif:
# endif
#if #elif ( )
,
. ++,
, , .
, .
, ,
#elif #else (.. ++
) . ,
. , #if
#elif, , ,
#else.
-, #if #elif
defined,
:
defined
defined ()
,
#define,
#undef, 1, 0.
defined ,
.
defined
,
. $$R.16.3.
-, $$R.5.19 ,
int unsigned int long unsigned long
,
, sizeof .
#ifdef
#if defined
#ifndef
#if !defined
, , ,
.
, ++,
:
#line "" opt
__LINE__ ($$R.16.10),
; :
,
. "",
__FILE__ ($$R.16.10)
. , __FILE__ .
.
:
#error -
,
.
:
#pragma -
"" .
#pragma .
#
.
.
__LINE__ ,
++.
__FILE__ ,
.
__DATE__ ,
"Mmm dd yyyy" "Mmm d yyyy", 10,
( Mmm , dd - , yyyy - ).
__TIME__ ,
"hh:mm:ss", ( hh , mm - ,
ss - ).
, ++
__cplusplus.
,
.
__LINE__ __FILE__
#line ($$R.16.6).
__STDC, , ,
.
C++.
++.
,
,
++. ,
($$r.6.8,
$$R.7.1, $$R.10.1.1). , ,
,
, .
: typedef ($$R.7.1.3), ($$R.9),
($$R.7.2), - ($$R.14) ,
, , :
-:
-:
-typedef:
, -typedef, ,
- ($$R.9.1).
:
-
, -
-:
-
- - -
-:
= *= /= %= += -= >>= <<= &= ^= |=
-:
--
-- ? : -
--:
--
-- || --
--:
-
-- && -
-:
--
- | --
--:
-
-- ^ -
-:
-
- & -
-:
-
- == -
- != -
-:
-
- < -
- > -
- <= -
- >= -
-:
-
- <<
- >>
-:
-
+ -
- - -
-:
-pm
- * -pm
- / -pm
- % -pm
-pm:
-
-pm .* -
-pm ->* -
-:
-
( - ) -
-:
-
++
--
- -
sizeof -
sizeof ( - )
-
-
-:
* & + - ! ~
-:
::opt new -new opt --new -new
::opt new -new opt ( - ) -new
-new:
( - )
--new:
-- -new opt
-new:
* --cv opt -new opt
- :: --cv opt -new opt
-new opt [ ]
-new:
( - opt )
-:
::opt delete -
::opt delete [] -
-:
-
- [ ]
- ( - opt )
-- ( - opt )
- .
- ->
- ++
- --
-:
-
- , -
-:
this
::
:: --
:: -
( )
:
--
--
~-
-
-:
-- ::
:
:
- opt - opt ;
-asm
-
-
-:
--
-
-fct
--
friend
typedef
-:
- opt -
--:
auto
register
static
extern
-fct:
inline
virtual
-:
--
-
-
--
:: -
const
volatile
--:
--
--
char
short
int
long
signed
unsigned
float
double
void
--:
-- -
--
--:
class
struct
union
--:
-typedef
- :: --
--:
--
:: --
--:
-
- :: --
-:
-:
enum opt { - }
-:
-
- , -
-:
= -
-:
extern - { - opt }
extern -
-:
-
-asm:
asm ( -) ;
-:
--
- , --
--:
opt
:
--
-ptr
(--) --cv opt
[ - opt]
( )
-ptr:
* --cv opt
& --cv opt
-- :: * --cv opt
--cv:
const
volatile
--:
-
~-
-typedef
--
-:
-- - opt
--:
- --
-:
-ptr - opt
- opt ( -- ) -_cv opt
- opt [ - opt ]
( - )
--:
-- opt ... opt
-- , ...
--:
-
-- , -
-:
-
- =
- - opt
- - opt =
-:
- opt -ctor -
-:
-
:
= -
= { - , opt }
( - )
-:
-
- , -
{ - , opt }
-:
- { - opt }
-:
-- opt - opt
-- - - opt
--:
class
struct
union
-:
- - opt
- : - opt
-:
- opt -- opt ;
- ; opt
- ;
--:
-
-- , -
-:
- opt
opt : -
-:
= 0
-:
-
- , -
-:
--
virtual - opt --
- virtual opt --
-:
private
protected
public
--:
operator --
--:
-- -ptr opt
-ctor:
: --
--:
-
- , --
-:
-- ( - opt )
--:
operator
:
new delete
+ - * / % ^ & | ~
! = < > += -= *= /= %=
^= &= |= << >> >>= <<= == !=
<= >= && || ++ -- , ->* ->
() []
:
-
-
-
-
-
-
-
-:
:
case - :
default :
-:
opt ;
-:
{ - opt }
-:
-
-:
if ( )
if ( ) else
switch ( )
-:
while ( )
do while ()
for ( - opt ; opt )
-:
-
-
-:
break ;
continue ;
return opt ;
goto ;
-:
#define -
#define ( , ... , ) -
#include ""
#include <>
#line "" opt
#undef
:
-if -elif opt -else opt -endif
-if:
-if
-if:
# if -
# ifdef
# ifndef
-elif:
-elif
-elif -elif
-elif:
# elif -
-else:
-else
-else:
# else
-endif:
# endif
--:
template < --->
---:
--
--- , --
--:
-
-
-:
class
--:
-- < --- >
---:
--
--- , --
-:
-
-:
try - -
-:
- opt
:
catch ( -- ) -
--:
--
-- -
--
...
-:
throw opt
--:
throw ( - opt )
-:
-
- , -
++
.
++ ( ,
78 ., K&R) ,
ANSI .
++, K&R C ANSI C
.
++ ANSI C. ++ ANSI C
:
sizeof('a') sizeof(int), ++
sizeof(char).
enum e { A };
sizeof(A) sizeof(int), ++ sizeof(e)
sizeof(int).
, ,
, , .
:
int x[99];
void f()
{
struct x { int a; };
sizeof(x); /* C */
/* C++ */
}
,
++.
, ,
++ 1985 .
($$R.8.2.5),
($$R.5.2.2).
($$R.5.2.2). ANSI C.
float
($$R.3.6.1 $$R.4.3). ANSI C.
; $$R.13.
; $$R.13.4
; $$R.7.1.2.
, ,
const; $$R.7.1.6. ANSI C.
; $$R.8.2.2 $$R.8.4.3.
new
delete; $$R.5.3.3 $$R.5.3.4.
, : ($$R.11),
($$R.12.1),
($$R.12.3)
($$R.10.2).
; $$R.9.
c , const volatile,
void*. ANSI C.
void*;
$$R.4.6.
; $$R.6.7.
; $$R.9.5.
++ 1985 .:
( ); $$R.10.1.
; $$R.11.
new delete ;
$$r.5.3.3, $$R.5.3.4, $$R.12.5.
"
this" ; $$R.18.3.3.
; $$R.12.4.
; $$R.12.8.
overload
; $$R.18.3.
; $$R.8.4.
, , volatile; $$R.7.1.6.
ANSI C.
; $$R.9.4.
- ; $$R.9.4.
- const volatile; $$R.9.3.1.
;
$$R.7.4.
->, ->* ` ; $$R.13.4.
; $$R.10.3.
.
; $$R.14.
; $$R.15.
++
, ANSI C, ANSI C
++, .
:
ANSI C,
++, ++; $$R.2.4:
asm catch class delete friend
inline new operator private protected
public template try this virtual
throw
ANSI C,
; ++
; $$R.2.3.
++ , ;
$$R.5.2.2.
f(); ++ , f
($$R.8.2.5), , f
. ANSI C.
ANSI C extern
, ++ ; $$R.3.3
++ , typedef,
; $$R.9.1.
ANSI C void*
,
; ++ $$R.7.1.6.
ANSI C , ;
++ .
ANSI C const
; ++ ; $$R.3.3.
""
++ ,
; $$R.18.3.1. ANSI C
.
++ (struct) ($$R.3.2);
ANSI C , ,
.
,
, ++
; $$R.7.2. ANSI C
.
, ,
; $$R.8.4.2.
++ char ($$R.2.5.2) int
ANSI C.
++ ($$R.7.2)
int ANSI C.
, ANSI
,
++ . ,
. ++
; $$R.3.3.
++ ,
ANSI C. ,
$$R.18.2, ++.
++ ANSI C , ,
.
++ ,
, ..
.
f(void), f().
const static
extern.
ANSI C ++
__cplusplus.
, ,
, , .
++ ,
,
++. ,
. ,
. ++
.
overload
- ($$R.7).
-,
.
, ,
($$R.8.4, $$R.9.4),
.
( ANSI C).
int.
, ,
; $$R.5.3.4.
operator++()
, ++; --;
$$R.13.4.6.
:
--:
- 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.
-
- , (int (*) ())p->f.
,
-
.
.
, ,
(
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
()
68
(ANSI)
()
-
-
()
-
-
-
-
-
-
-
\t
-
--
--
--
-
auto
\n
()
double
float
long
long double
unsigned
( )
error
null
pragma
()
case
default
ASCII
EBCDIC
-
friend
\
-
-
const
volatile
break
continue
do
for
goto
if
return
switch ()
while
-
-
-
(operator)
UNIX
!
#
##
%=
&&
&=
*=
++
+=
,
--
-=
/=
::
<<=
>>=
^=
>>
<<
-
( ? : )
delete
new
sizeof
asm
extern
friend
register
typedef
-
--
--
-
-
-
-
- inline
--
--
\f
( )
( )
-
--
*=
+
++
-
--
->
=
++ --
()
()
void*
++ --
-
++
(NULL)
++
()
NULL '\0'
_
()
class
ANSI C ()
()
auto
-
-
--
-
-
-
double
--char
enum
float
int
short
struct
union
unsigned
void
volatile
friend
inline
pure
-pure
static
typedef
template
virtual
-
-
-
-
-
-
---
---
-
const
volatile
include
-
char
double
float
int
long
long double
short
signed char
unsigned char
void
volatile
-
void*
const
-
-
(\)
-
--
--
-
-
-
- friend
- inline ()
-
- volatile
-
-
...
BCPL
C++
CLU
SMALLTALK
C C++
A
abstract
class
abstract-declarator
abstraction
data
levels
access
base class
base class member
class member
control
declaration
member name
protected member
specifier
virtual function
Ada
addition operator
additive operators
address
address-of operator
ADT abstract type ()
aggregate
Algol68 68
alignmemt
allocation
allocation-expression -
ambiguity
resolution
ambiguous type conversion
anachronism
anonymous union
ANSI ANSI
application framework
argument
argument-declaration -
arithmetic
conversion
exception
fixed point
pointer
type
unsigned
array
associative
initialization
multidimensional
storage of
type
arrow operator
ASCII character set ASCII
asm declaration asm
assembler
assignment
and initialization
and lvalue
assignment-expression -
assignment-operator -
associativity of operator
asynchronous events
auto
destruction
initialization
specifier auto
storage class auto
B
backslash
backspace
base
class
class access
class cast
base-list -
base-specifier -
BCPL BCPL
binding
bit ()
field
pattern
vector
bit-field
address of
alignment
declaration
layout
type
bitwise
AND operator
copy
exclusive OR operator
inclusive OR operator
logical operators
operators
block
statement { }
structure
body, function
break statement break
buffering, I/O -
built-in
operator
type ()
C
C C
C ANSI C ANSI
C++ C C++
C++ C++
evolution C++
call
by reference
by value
function
operator function
callback
carriage return
cast
base class
class object
derived class
integer to pointer
operator
pointer to function
pointer to integer
pointer to member
pointer to pointer
reference
cast-expression -
catch
CDT concrete type ()
char type char
type, signed signed char
type specifier --char
type, unsigned unsigned char
character
constant
set, ASCII ASCII
set, EBCDIC EBCDIC
class
abstract
alignment
and type
base
constructor and abstract
constructor for derived
conversion
conversion ambiguity
declaration
declaration, forward
declaration, friend
definition
derived
destructor for derived
exception
friend
handle
hierarchy
interface
member
member access
member access operator
member, alignment
member, constructor for
member declaration
member function -
member initialization
member of derived
member, private
member, public
member, static
name
name declaration
name, elaborated
nested
node
pointer to
private base
scope
storage
template
versus struct
versus union
virtual base
class-key class
class-name -
class-specifier -
CLU CLU
Cobol
comma operator
command line argument
comment
compatibility
with ANSI C summary ANSI C ()
with C summary ()
compilation, separate
complete-class-name --
compound statement
concatenation string
concrete type
type, CDT ()
conditional
compilation
expression operator ( ? : )
constant
character
decimal
double double
enumeration
expression
float float
floating point
hexadecimal
integer
long long
long double long double
multicharacter
octal
of user-defined type
unsigned unsigned
constant-expression -
constructor
address of
call, explicit
conversion by
copy
default
default copy
definition
exception handling
for array members
for class member
for derived class
for free store variable ,
for global variable
for local variable
for temporary
inheritance
local object
type of
undefined argument to
union
virtual
containment
and inheritance
continue statement continue
control access
conversion ()
argument
arithmetic
array pointer
base class pointer
by assignment
by constructor
class ()
derived class pointer
floating point integer
implicit
implicit type
integer
integer to pointer
lvalue
null pointer
of pointer to class
operator
pointer
pointer to function
pointer to integer
pointer to member
pointer to pointer
reference
return type
rules, type
standard
user-defined
user-defined type
void* pointer void*
zero pointer
conversion-function-name --
copy
bitwise
deep
shallow
D
data
abstraction
abstraction, support for
abstraction vs inheritance
global
debugging
declaration
access
argument
array
as definition
asm asm
bit-field
class
class member
class name
constant pointer
default argument
definition versus
ellipsis in function
extern extern
forward
friend friend
friend class
function
function member -
function template
local class
member
name
pointer
reference
register register
specifier
statement
static member
storage class
syntax summary ()
syntax summary, class ()
template
template class
template function
type
typedef typedef
declaration
declaration-list -
declaration-statement -
declarator
declarator-list -
decl-specifier -
decrement operator
default access control
argument
argument evaluation
argument, scope
argument type checking
array size
assignment operator
constructor
copy constructor
destructor
initialization
definition
class
constructor
enumerator
function
function template
inline member function - inline
member
member function -
object
pure virtual function
scope of function
static member
template class
template function
virtual function
delete operator delete
dereferencing ( )
derived class
design aims
and classes
and language
and programming
library
method
of C++ ++
stage
steps
tools
destruction
of auto
of local static
of local variable
destructor
default
for derived class
for temporary
inheritance
invocation
local object
virtual
development cycle
process
stages
difference from C expression
evaluation
from C function declaration
from C linkage
from C name space
from C scope
direct base class
directed acyclic graph
directive error preprocessing error
pragma preprocessing pragma
preprocessing
discriminating union
discrimination of exceptions
do statement do
double constant double
type double
type specifier double
dynamic type checking
E
EBCDIC character set EBCDIC
elaborated class name
ellipsis ... ...
empty argument list
queue
statement
encapsulation
enum type specifier enum
enumeration
constant
enumerator
equality operator
equivalence template type
type
error handling
handling, multilevel
linkage
preprocessing directive error
run-time
escape character (\)
sequence
evaluation default argument
of expression, order of
order of
order of argument
evolution of ++ ++
exception
arithmetic
class
handler
hierarchies
throwing
exception-declaration --
exception-specification --
exhaustion free store
explicit constructor call
destructor call
type conversion
expression
assignment
constant
order of evaluation of
postfix
primary
reference
statement
syntax summary
unary
expression-list -
expression-statement -
extern declaration
linkage
linkage specification
external linkage
F
fat interface
field
bit
fixed point arithmetic
float constant float
type float
type specifier float
for statement for
format string
form feed \f \f
forward class declaration
declaration
declaration of template
free store
store exhaustion
store management
friend friend
class
declaration friend
function
member function - friend
scope of friend
specifier friend
function
argument
argument passing
argument type checking
argument type conversion
body
call
call mechanism
call, recursive
declaration
definition
friend
inline -
inline member - inline ()
linkage specification
member -
object -
operator (operator)
pointer to
pointer to member -
pure virtual
scope
specifier
template
type
value return
virtual
function-definition -
fundamental type
G
garbage collection
global anonymous union
data
name
objects
scope
goto statement goto
greater than operator
greater than or equal operator
grouping of exceptions
H
handle class
handler, exception
handler-list -
header file
hexadecimal constant
hierarchy class
object
horizontal tab \t \t
hybrid design
I
identifier
if statement if
implementation
implicit conversion
destructor call
type conversion
user-defined conversion
include directory, standard include
file
inclusion source file
increment operator
indentation
inderect base class
inderection operator
inequality operator
inheritance
containment and
multiple
of constructor
of destructor
initialization
array
array of class objects
assignment and
character array
class member
class object
default
dynamic
member
member object -
of base class
of structure
initializer
initializer-list -
inline inline
function -
member function - inline
input and output -
of built-in type
of user-defined type
operator >> >>
int int
type int
type specifier int
integer constant
conversion
integral promotion
type
interface
class
inheritance
fat
specifications
internal linkage
structure
I/O buffering -
iteration
statement
J
jump statement
jump-statement -
K
keyword
list
L
label
case case
default default
scope of
labeled statement
language
design and
high-level
low-level
layout bit-field
class objects
left shift operator
less than operator
than or equal to operator
levels of abstraction
lexical conventions
library
design
headers
initialization
lifetime of object
linkage
consistency
error
external
internal
linker-specification -
linker
Lisp
list of operator functions
literal
constants
loader
local class declaration
class member function -
class, scope of
scope
locking ()
logical AND operator
OR operator
negation operator
operators, bitwise
long long
constant long
double long double
double constant long double
double type long double
type long
loop statement
lvalue
assignment and
cast
conversion
modifiable
M
macro
definition, preprocessing
expansion, preprocessing
function-like
name, scope of
names, predefined
preprocessing
syntax summary ()
maintenance, software
management
free store
memory
manipulator
member
member-declaration -
member-declarator -
member-list -
modifiable lvalue
modular programming
modularity
multicharacter constant
multidimensional array
multiple inheritance
multiplication operator
multiplicative-expression -
N
name
global
hiding
length of
linkage of local
overloaded function
overloaded member
qualified
scope of
nested class declaration
class, scope of
new operator new
newline \n \n
node class
null character null '\0'
pointer (null)
O
object
object-oriented programming -
octal constant
number
operand const const
reference
volatile volatile
operator , ,
! !
# #
## ##
%= %=
&& &&
&= &=
*= *=
*=, user-defined *=
+, user-defined +
++ ++
++, user-defined ++
+= +=
-, user-defined -
-- --
--, user-defined --
-= -=
->, user-defined ->
/= /=
:: ::
<<, output <<
<<= <<=
=, user-defined =
>>, input >>
>>= >>=
^= ^=
address-of
assignment
associativity
binding strength
built-in
function call
precedence
sizeof sizeof
subscripting
summary
user-defined
operator function
function, list of
order of argument evaluation
of evaluation
output formatted
input and
of built-in type
of user-defined type
operator << <<
overflow
overloaded assignment operator
binary operator
decrement operator
function call operator
function name
increment operator
member access operator
member name
operator
subscripting operator
unary operator
overloading
and access
and scope
resolution
resolution rules
overriding virtual function
P
paradigm, programming
placement
pointer
arithmetic
assignment to
comparison
const const
conversion
declaration
null null
size of
substraction
type
postfix ++ and -- ++ --
expression
precedence of operator
predefined address-of operator
assignment operator
macronames
prefix ++ and -- ++ --
preprocessing
directive
directive, error error
directive, null null
directive, pragma pragma
macro definition
macro expansion ()
syntax summary
primary expression
private private
base class
class member
procedural programming
program
environment
partitioning
start
termination
protected protected
member
member access
prototypes
public public
class member
pure specifier pure
virtual function
pure-specifier -pure
Q
qualified name
qualified-class-name --
qualified-name -
qualified-type-name --
queue empty
quote, single
double
R
range checking
recursion
recursive decent parser
function call
reference
assignment
assignment to
call by
cast
conversion
const const
declaration
initialization
operand
overloading and
volatile volatile
register declaration register
initialization
relational operator
relational-expression -
reserved identifier
resolution ambiguity
scoping ambiguity
template function overloading
resource acquisition
exhaustion
release
re-throw ( )
return return
return statement return
return type
run-time error
initialization
type information
S
scope
class
file
function
global
local
of label
of local class
of macro name
of name
of nested class
resolution operator
rules summary
separate compilation
shift-expression -
short type short
type specifier short
side effects
sign extension
signed char type signed char
type
simple-type-name --
Simula
size of pointer
of string
of structure
sizeof operator sizeof
Smalltalk Smalltalk
source file
file, inclusion
special character
specifier auto auto
declaration
friend friend
function
inline inline
static static
storage class
template
typedef typedef
virtual virtual
stack unwinding
standard component
conversion
headers
include directory
libraries
statement
break break
compound
continue continue
declaration
do do
empty
expression
for for
goto goto
if if
summary
switch switch ()
syntax summary
while while
static type checking
static static
class member
linkage of
local object
member
member declaration
member definition
member function -
specifier static
storage class
stream closing of
file and
state
string
string class
concatenation
constant
type of
wide-character
struct struct
type specifier struct
structure
initialization of
subclass
subscripting user-defined
summary class declaration syntax
compatibility with ANSI C ANSI C
compatibility with C
declaration syntax
declarator syntax
exception handling syntax
expression syntax
macro syntax
scope rules
statement syntax
template syntax
support for data abstraction
for object-oriented programming -
T
template
class
class declaration
class definition
declaration
function
function declaration
function definition
linkage of
member function -
specifier template
syntax summary
template-arg --
template-arg-list ---
template-argument --
template-argument-list ---
template-class-name --
template-declaration --
temporary
this this
throw throw
throw-expression -
throwing, exception
throw-point
token
tools design
translation phases
unit
trigraph
try try
try-block -
type
user-defined
type-specifier -
U
unary expression
minus operator
operator
operator, user-defined
plus, operator
unary-expression -
unary-operator -
uncaught exception
undeclared argument
underscore character _
unexpected exceptions
union
anonymous
constructor
destructor
discriminating
initialization
member function -
type specifier union
UNIX UNIX
unsigned arithmetic
char type unsigned char
constant
type
type specifier unsigned
V
vertical tab \v \v
virtual virtual
base class
destructor
function
function access
function call
function, type of
specifier virtual
user-defined conversion
void void
argument
pointer to void*
type void
type specifier void
volatile volatile
member function - volatile
operand volatile
reference volatile
type volatile
type specifier volatile
W
waterfall model
white space
wide-character string
#include <stream.hxx>
main()
{
cout << "Hello, world\n";
}
#include <stream.hxx>
main ()
{
int inch = 0;
cout << "inches=";
cin >> inch;
cout << inch;
cout << "in = ";
cout << inch*2.54;
cout << " cm\n";
}
#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";
}
}
#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;
}
#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;
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 o");
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);
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);
}
#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);
}
main() {
char *p = new char[100];
char *q = new char[100];
delete p;
delete p;
}
#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;
}
#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";
}
#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();
}
#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";
}
#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];
}
#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);
}
#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";
}
#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","");
}
Last-modified: Wed, 08 May 2002 14:07:44 GMT